[xxx -- to remove] Batch-label currently failing tests

Put a "expected: reffail" on any test that the tester thought was failing
(which includes a few that currently fail due to the llvm-only mode)

Used a different word (vs "fail") so that we can see whether it was failing
before refcounting or not.

test/tests/_collections_test.py

+# expected: reffail
 import _collections
 
 d = _collections.deque()

test/tests/arg_unpacking.py

+# expected: reffail
 def f((a,b)):
     print a,b
     print sorted(list(locals().iteritems()))

test/tests/array_test.py

+# expected: reffail
 import array
 a = array.array("c", "hello world")
 print type(a)

test/tests/assign_literal.py

+# expected: reffail
 # skip-if: '-x' in EXTRA_JIT_ARGS
 # - CPython parser backend doesn't handle well the errors
 # should_error

test/tests/ast_test.py

+# expected: reffail
 import _ast
 
 def ast_parse(source, filename='<unknown>', mode='exec'):

test/tests/augassign_analysis.py

+# expected: reffail
 # Augassigns are somewhat odd because they encode both a use and a def of a variable.
 # So for the sake of determining if a scope sets a variable, they count as a def, but
 # for the sake of whether or not a variable is live, they count as a use.

test/tests/backtick.py

+# expected: reffail
 print `42`
 print `int`
 print `2+3`

test/tests/bool_functions.py

+# expected: reffail
 # Regression test: we rely internally on CompilerType.nonzero() always returning a BOOL,
 # in at least these two cases.
 

test/tests/bool_passing.py

+# expected: reffail
 # Test that we can pass known-bool values through OSRs and what not:
 
 def f(b):

test/tests/buffer_test.py

+# expected: reffail
 s = 'Hello world'
 t = buffer(s, 6, 5)
 print t

test/tests/builtin_type_not_subclassable.py

+# expected: reffail
 import re
 import inspect
 def gen():

test/tests/builtins.py

+# expected: reffail
 import sys
 
 __builtins__.aoeu = 1

test/tests/builtins_future.py

+# expected: reffail
 from future_builtins import hex, oct, map, zip, filter
 from itertools import imap, izip, ifilter
 

test/tests/bz2_test.py

+# expected: reffail
 import bz2
 print bz2.decompress(bz2.compress("hello world"))

test/tests/cPickle_test.py

+# expected: reffail
 import cPickle
 
 l = [[], (123,)]

test/tests/callattr_exceptions.py

+# expected: reffail
 # Make sure that callattrs handle exceptions (including
 # different exception styles) correctly.
 class C(object):

test/tests/capi_slots.py

+# expected: reffail
 import slots_test
 
 for i in xrange(3):

test/tests/change_delattr.py

+# expected: reffail
 class C(object):
     pass
 

test/tests/class_and_func_name.py

+# expected: reffail
 class C(object):
     pass
 

test/tests/class_and_instance_freeing.py

+# expected: reffail
 import gc
 
 l = []

test/tests/class_changing.py

+# expected: reffail
 # Tests to make sure that setting __class__ changes the class, and that it's ok to disallow
 # having anything other than a type as the class
 class C(object):

test/tests/class_finalization.py

+# expected: reffail
 from testing_helpers import test_gc
 
 unordered_finalize = {}

test/tests/closure_ics_test.py

+# expected: reffail
 # Regression test: this triggers a bug in the way we guard for boxedfunctions and their closures.
 # In particular, we guard on the specific value of a BoxedFunction to say that it is the same, but
 # it's possible for the function to get destructed and then a new (and different) boxedfunction to

test/tests/closure_test.py

+# expected: reffail
 # closure tests
 
 # simple closure:

test/tests/coding_cp1252.py

+# expected: reffail
 # coding: cp1252
 s = u""
 print ord(s), s

test/tests/coding_cp1252_str.py

+# expected: reffail
 import os.path
 
 s = open(os.path.join(os.path.dirname(__file__), "coding_cp1252.py"), 'r').read()

test/tests/coding_koi8.py

+# expected: reffail
 # -*- coding: koi8-r -*-
 def test(s):
     print s, "len:", len(s)

test/tests/collections_test.py

+# expected: reffail
 import collections
 
 o = collections.OrderedDict()

test/tests/comparisons.py

+# expected: reffail
 def f(a, b):
     print repr(a), repr(b), "<", a < b
     print repr(a), repr(b), "<=", a <= b

test/tests/compile_eval.py

+# expected: reffail
 print compile
 c = compile("a", "test.py", "eval")
 print type(c), c.co_filename, c.co_name

test/tests/compile_exec.py

+# expected: reffail
 c = compile("a = 1; print a", "test.py", "exec")
 print type(c), c.co_filename, c.co_name
 

test/tests/compile_future.py

+# expected: reffail
 from __future__ import division
 
 # compile() inherits the future flags of the parent module

test/tests/compile_future2.py

+# expected: reffail
 # co is compiled without the __future__ division import.
 # So even though the import is present in the exec statements,
 # the code will be evaluated without it. Each should print 0.

test/tests/compile_test.py

+# expected: reffail
 from __future__ import print_function
 import _ast
 

test/tests/compile_test2.py

+# expected: reffail
 # this tests are from cpythons test_compile.py
 import unittest
 from test import test_support

test/tests/complex.py

+# expected: reffail
 # TODO repr is wrong, so for now, only printing complex numbers whose real
 # and imaginary parts are non-integers
 

test/tests/constructor_args.py

+# expected: reffail
 class C(object):
     def __init__(self, a):
         print a

test/tests/contains.py

+# expected: reffail
 class C(object):
     def __init__(self, x):
         self.x = x

test/tests/copy_test.py

+# expected: reffail
 import copy
 class C(object):
     pass

test/tests/cpython_oldstyle_getattr_crash.py

+# expected: reffail
 # This segfaults under python-dbg
 # (In a release build it "works" since the use-after-free happens without penalty.)
 

test/tests/csv_test.py

+# expected: reffail
 import csv
 import StringIO
 

test/tests/ctypes_import.py

+# expected: reffail
 # We can only import ctypes for now - it would be nice to have tests later,
 # which will probably involve running the existing test suite for ctype rather
 # than add our own here (unless there's special Pyston-related edge cases).

test/tests/ctypes_test.py

+# expected: reffail
 from ctypes import *
 s = "tmp"
 ap = create_string_buffer(s)

test/tests/ctypes_traceback.py

+# expected: reffail
 from ctypes import *
 libc = CDLL("libc.so.6")
 qsort = libc.qsort

test/tests/curses_test.py

+# expected: reffail
 import curses, sys
 
 try:

test/tests/dash_c.py

+# expected: reffail
 import sys
 import subprocess
 

test/tests/dash_m.py

+# expected: reffail
 import os
 import sys
 import subprocess

test/tests/datetime_test.py

+# expected: reffail
 # Simple datetime test
 # Doesn't test much of the functionality, but even importing the module is tough:
 

test/tests/decimal_test.py

+# expected: reffail
 from decimal import Decimal
 
 for d in (Decimal("0.5"), Decimal("0"), Decimal(0), Decimal(1.0)):

test/tests/decorated_func_line.py

+# expected: reffail
 def wrapper(f):
     return f
 

test/tests/defaults_basic.py

+# expected: reffail
 d = {}
 print d.get(1)
 print d.setdefault(2)

test/tests/defaults_changing.py

+# expected: reffail
 
 def func(a, b=1):
     print a, b

test/tests/defaults_test.py

+# expected: reffail
 # Test for various defaults arguments in builtin functions:
 
 class ExpectationFailedException(Exception):

test/tests/del_closure_var_syntax_error.py

+# expected: reffail
 try:
     import __pyston__
     __pyston__.setOption("LAZY_SCOPING_ANALYSIS", 0)

test/tests/del_multi.py

+# expected: reffail
 def f4():
     a = 1
     b = 2

test/tests/del_name.py

+# expected: reffail
 import sys
 
 def p():

test/tests/del_name_scoping.py

+# expected: reffail
 x = 1
 def f():
     if 0:

test/tests/delattr.py

+# expected: reffail
 #delete attribute of built-in types 
 def del_builtin_attr(o):
     try:

test/tests/deopt_generator_tests.py

+# expected: reffail
 # skip-if: '-O' in EXTRA_JIT_ARGS or '-n'  in EXTRA_JIT_ARGS
 # statcheck: 4 <= noninit_count('num_deopt') < 50
 # statcheck: 1 <= stats["num_osr_exits"] <= 2

test/tests/deopt_namescope_tests.py

+# expected: reffail
 # skip-if: '-O' in EXTRA_JIT_ARGS
-# expected: statfail
 # statcheck: 4 <= noninit_count('num_deopt') < 50
 # statcheck: 1 <= stats["num_osr_exits"] <= 2
 

test/tests/deopt_tests.py

+# expected: reffail
 # skip-if: '-O' in EXTRA_JIT_ARGS
-# expected: statfail
 # statcheck: 4 <= noninit_count('num_deopt') < 50
 # statcheck: 1 <= stats["num_osr_exits"] <= 2
 

test/tests/deopt_tests2.py

+# expected: statfail
 # skip-if: '-O' in EXTRA_JIT_ARGS or '-n' in EXTRA_JIT_ARGS
 # statcheck: 4 == noninit_count('num_deopt')
 # this used to hit an abort in our LLVM tier codegen

test/tests/descr_selfdelete.py

+# expected: reffail
 # Test some internals: when we execute some special functions, we often need to
 # make sure to keep a reference to that function, in case that function ends up
 # unsetting itself.

test/tests/descriptors_double.py

+# expected: reffail
 # TODO This is a hodgepodge of stuff, should probably organize it better
 # maybe merge some of it into dunder_descriptors?
 

test/tests/descriptors_getset_ics.py

+# expected: reffail
 # run_args: -n
 # statcheck: noninit_count('slowpath_getattr') <= 10
 # statcheck: noninit_count('slowpath_setattr') <= 10

test/tests/descriptors_nonfunc_types.py

-# expected: fail
+# expected: reffail
 
 # See what happens when we make __get__ and __set__ things other than functions...
 # TODO add some with __del__

test/tests/dict.py

+# expected: reffail
 d = {2:2}
 d[1] = 1
 print d

test/tests/dict_setting.py

+# expected: reffail
 try:
     object().__dict__ = 1
 except AttributeError as e:

test/tests/dict_subclassing.py

+# expected: reffail
 class MyDict(dict):
     pass
 

test/tests/dictcomp.py

+# expected: reffail
 def dict2str(d):
     result = ''
     for k, v in sorted(d.items()):

test/tests/dir.py

+# expected: reffail
 import sys
 
 

test/tests/distutils_test.py

+# expected: reffail
 from distutils.core import setup
 
 import distutils.command.build as build

test/tests/doctest_test.py

+# expected: reffail
 # requires:
 # - code.co_firstlineno
 # - sys.dysplayhook

test/tests/elementree_test.py

+# expected: reffail
 # test is based on the cpython ElementTree doc
 def test(ET):
     xml_str = """<?xml version="1.0"?>

test/tests/encoding_test.py

+# expected: reffail
 import codecs
 
 ### Codec APIs

test/tests/eval_bad_indentation.py

+# expected: reffail
 try:
     eval("\n 2")
     print "bad, should have thrown an exception"

test/tests/eval_test.py

+# expected: reffail
 print eval("3 + 4")
 
 a = 5

test/tests/exceptions_basic.py

+# expected: reffail
 
 def f(x):
     print x

test/tests/exceptions_nonreprable.py

+# expected: reffail
 # should_error
 class BadException(Exception):
     def __str__(self):

test/tests/exceptions_test.py

+# expected: reffail
 class TestException(Exception):
     pass
 

test/tests/exec_basic.py

+# expected: reffail
 exec """print 'hi'
 a = 5
 print a"""

test/tests/exec_directory.py

+# expected: reffail
 import sys
 import os
 import subprocess

test/tests/exec_future_import.py

+# expected: reffail
 print 1 / 2
 
 exec """

test/tests/exec_future_import2.py

+# expected: reffail
 from __future__ import division
 
 print 1 / 2

test/tests/exec_in_basic_test.py

+# expected: reffail
 d = {}
 exec "a = 5" in d
 print d['a']

test/tests/exec_in_test.py

+# expected: reffail
 print 'Test getting'
 
 g = {'a': 1}

test/tests/exec_set_local.py

+# expected: reffail
 def f():
     exec "a = 5"
     print a

test/tests/exec_syntax_error.py

+# expected: reffail
 s = """
 def f():
     a = 1

test/tests/exec_syntaxerror.py

+# expected: reffail
 # fail-if: '-x' in EXTRA_JIT_ARGS
 # - we don't get syntax errors through the old parser correctly
 

test/tests/execfile_test.py

+# expected: reffail
 try:
     execfile("doesnt_exist.py")
 except IOError, e:

test/tests/execvpe.py

+# expected: reffail
 # no-collect-stats
 
 import os

test/tests/extension.py

+# expected: reffail
 import basic_test
 
 print type(basic_test)

test/tests/fcntl_test.py

+# expected: reffail
 import fcntl
 
 for k in sorted(dir(fcntl)):

test/tests/file.py

+# expected: reffail
 import sys
 import tempfile
 

test/tests/file_destructor.py

+# expected: reffail
 import gc
 
 def open_lots_of_files():

test/tests/file_writing.py

+# expected: reffail
 import os
 import tempfile
 import array

test/tests/finalizer_cycle.py

+# expected: reffail
 import gc
 
 finalized_at_least_once = False

test/tests/finalizer_exception.py

+# expected: reffail
 # Exceptions from finalizers should get caught:
 import sys
 from testing_helpers import test_gc

test/tests/finalizer_fallback.py

+# expected: reffail
 from testing_helpers import test_gc
 
 # __del__ does not get called because it doesn't fallback to getattr

test/tests/finalizer_gc_call.py

+# expected: reffail
 import gc
 from testing_helpers import test_gc