github.com/google/skylark@v0.0.0-20181101142754-a5f7082aabed/testdata/misc.sky (about)

     1  # Miscellaneous tests of Skylark evaluation.
     2  # This is a "chunked" file: each "---" effectively starts a new file.
     3  
     4  # TODO(adonovan): move these tests into more appropriate files.
     5  # TODO(adonovan): test coverage:
     6  # - stmts: pass; if cond fail; += and failures;
     7  #    for x fail; for x not iterable; for can't assign; for
     8  #    error in loop body
     9  # - subassign fail
    10  # - x[i]=x fail in both operands; frozen x; list index not int; boundscheck
    11  # - x.f = ...
    12  # - failure in list expr [...]; tuple expr; dict expr (bad key)
    13  # - cond expr semantics; failures
    14  # - x[i] failures in both args; dict and iterator key and range checks;
    15  #   unhandled operand types
    16  # - +: list/list, int/int, string/string, tuple+tuple, dict/dict;
    17  # - * and ** calls: various errors
    18  # - call of non-function
    19  # - slice x[ijk]
    20  # - comprehension: unhashable dict key;
    21  #   scope of vars (local and toplevel); noniterable for clause
    22  # - unknown unary op
    23  # - ordering of values
    24  # - freeze, transitivity of its effect.
    25  # - add an application-defined type to the environment so we can test it.
    26  # - even more:
    27  #
    28  # eval
    29  #   pass statement
    30  #   assign to tuple l-value -- illegal
    31  #   assign to list l-value -- illegal
    32  #   assign to field
    33  #   tuple + tuple
    34  #   call with *args, **kwargs
    35  #   slice with step
    36  #   tuple slice
    37  #   interpolate with %c, %%
    38  
    39  load("assert.sky", "assert")
    40  
    41  # Ordered comparisons require values of the same type.
    42  assert.fails(lambda: None < False, "not impl")
    43  assert.fails(lambda: False < list, "not impl")
    44  assert.fails(lambda: list < {}, "not impl")
    45  assert.fails(lambda: {} < (lambda: None), "not impl")
    46  assert.fails(lambda: (lambda: None) < 0, "not impl")
    47  assert.fails(lambda: 0 < [], "not impl")
    48  assert.fails(lambda: [] < "", "not impl")
    49  assert.fails(lambda: "" < (), "not impl")
    50  # Except int < float:
    51  assert.lt(1, 2.0)
    52  assert.lt(2.0, 3)
    53  
    54  ---
    55  # cyclic data structures
    56  load("assert.sky", "assert")
    57  
    58  cyclic = [1, 2, 3] # list cycle
    59  cyclic[1] = cyclic
    60  assert.eq(str(cyclic), "[1, [...], 3]")
    61  assert.fails(lambda: cyclic < cyclic, "maximum recursion")
    62  assert.fails(lambda: cyclic == cyclic, "maximum recursion")
    63  cyclic2 = [1, 2, 3]
    64  cyclic2[1] = cyclic2
    65  assert.fails(lambda: cyclic2 == cyclic, "maximum recursion")
    66  
    67  cyclic3 = [1, [2, 3]] # list-list cycle
    68  cyclic3[1][0] = cyclic3
    69  assert.eq(str(cyclic3), "[1, [[...], 3]]")
    70  cyclic4 = {"x": 1}
    71  cyclic4["x"] = cyclic4
    72  assert.eq(str(cyclic4), "{\"x\": {...}}")
    73  cyclic5 = [0, {"x": 1}] # list-dict cycle
    74  cyclic5[1]["x"] = cyclic5
    75  assert.eq(str(cyclic5), "[0, {\"x\": [...]}]")
    76  assert.eq(str(cyclic5), "[0, {\"x\": [...]}]")
    77  assert.fails(lambda: cyclic5 == cyclic5 ,"maximum recursion")
    78  cyclic6 = [0, {"x": 1}]
    79  cyclic6[1]["x"] = cyclic6
    80  assert.fails(lambda: cyclic5 == cyclic6, "maximum recursion")
    81  
    82  ---
    83  # regression
    84  load("assert.sky", "assert")
    85  
    86  # was a parse error:
    87  assert.eq(("ababab"[2:]).replace("b", "c"), "acac")
    88  assert.eq("ababab"[2:].replace("b", "c"), "acac")
    89  
    90  # test parsing of line continuation, at toplevel and in expression.
    91  three = 1 + \
    92    2
    93  assert.eq(1 + \
    94    2, three)
    95  
    96  ---
    97  # A regression test for error position information.
    98  
    99  _ = {}.get(1, default=2) ### "get: unexpected keyword arguments"
   100  
   101  ---
   102  # Load exposes explicitly declared globals from other modules.
   103  load('assert.sky', 'assert', 'freeze')
   104  assert.eq(str(freeze), '<built-in function freeze>')
   105  
   106  ---
   107  # Load does not expose pre-declared globals from other modules.
   108  # See github.com/google/skylark/issues/75.
   109  load('assert.sky', 'assert', 'matches') ### "matches not found in module"
   110  
   111  ---
   112  # Load does not expose universals accessible in other modules.
   113  load('assert.sky', 'len') ### "len not found in module"
   114  
   115  
   116  ---
   117  # Test plus folding optimization.
   118  load('assert.sky', 'assert')
   119  
   120  s = "s"
   121  l = [4]
   122  t = (4,)
   123  
   124  assert.eq("a" + "b" + "c", "abc")
   125  assert.eq("a" + "b" + s + "c", "absc")
   126  assert.eq(() + (1,) + (2, 3), (1, 2, 3))
   127  assert.eq(() + (1,) + t + (2, 3), (1, 4, 2, 3))
   128  assert.eq([] + [1] + [2, 3], [1, 2, 3])
   129  assert.eq([] + [1] + l + [2, 3], [1, 4, 2, 3])
   130  
   131  assert.fails(lambda: "a" + "b" + 1 + "c", "unknown binary op: string \\+ int")
   132  assert.fails(lambda: () + () + 1 + (), "unknown binary op: tuple \\+ int")
   133  assert.fails(lambda: [] + [] + 1 + [], "unknown binary op: list \\+ int")