[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
 

test/tests/finalizers_inheritance.py

+# expected: reffail
 from testing_helpers import test_gc
 
 class C(object):

test/tests/finally_continue2.py

+# expected: reffail
 # Similar to finally_continue.py, but this is allowable
 
 for i in xrange(10):

test/tests/finally_except.py

+# expected: reffail
 # these may seem pointless, but they exercise a family of corner cases in our
 # CFG generation pass (cfg.cpp).
 def returner():

test/tests/float.py

+# expected: reffail
 print 123542598.12938712938192831293812983
 f = 1.0
 print f

test/tests/for.py

+# expected: reffail
 for i in range(10):
     print i
 for i in xrange(1, 15, 2):

test/tests/for_iter.py

+# expected: reffail
 class C(object):
     def __iter__(self):
         print "orig iter"

test/tests/fork.py

+# expected: reffail
 # no-collect-stats
 
 from thread import start_new_thread

test/tests/func_arg_passing.py

+# expected: reffail
 def f():
     def f1(a, b, c):
         print a, b, c

test/tests/functions.py

+# expected: reffail
 
 def f():
     """very nice function"""

test/tests/functools_test.py

+# expected: reffail
 import functools
 
 f = functools.partial(lambda *args: args, 1, 23)

test/tests/future_division.py

+# expected: reffail
 "docstring"
 
 from __future__ import division

test/tests/gc_type_object.py

+# expected: reffail
 import gc
 
 # Dynamically create new classes and instances of those classes in such a way

test/tests/gcj_2014_1c_b.py

+# expected: reffail
 import sys
 
 def compact(s):

test/tests/gcj_2014_2_c.py

+# expected: reffail
 import sys
 
 if __name__ == "__main__":

test/tests/gcj_2014_2_d.py

+# expected: reffail
 import sys
 
 P = 1000000007

test/tests/generator_closures.py

+# expected: reffail
 # Test to make sure that generators create and receive closures as appropriate.
 
 def f(E, N, M):

test/tests/generator_collection_running.py

+# expected: reffail
 # This test checks if generators which get started but haven't yet stopped (=not raisen a StopIteration exc, etc)
 # get freed when there aren't any references to the generators left.
 

test/tests/generator_custom_globals.py

+# expected: reffail
 s = """
 def g():
     yield x

test/tests/generator_cycle.py

+# expected: reffail
 # Test a generator cycle involving an unfinished generator.
 
 def f():

test/tests/generator_nonrunning_collection.py

+# expected: reffail
 def g():
     l1 = [1]
     l2 = [2]

test/tests/generator_osr.py

+# expected: reffail
 # This test could really benefit from defined/settable OSR limits
 
 def f(x):

test/tests/generator_thread_sharing.py

+# expected: reffail
 # Start a generator on one thread, pass it to another, and have that execute it for a while
 
 def gen():

test/tests/generator_threads.py

+# expected: reffail
 # Pass a started generator to two different threads, and make them both
 # try to run it at the same time.
 

test/tests/generator_threads2.py

+# expected: reffail
 import threading
 import traceback, sys
 

test/tests/generator_throw.py

+# expected: reffail
 import sys
 
 def generate(lst):

test/tests/generator_tracebacks.py

+# expected: reffail
 # Generators participate in the notional Python stack just like normal function calls do,
 # even if we implement them using separate C stacks.
 #

test/tests/generators.py

+# expected: reffail
 def G1(i=0):
     while True:
         yield i

test/tests/getattr_exceptions.py

+# expected: reffail
 
 # This throws an exception in the import machinery when we try to access __path__,
 # but that should get caught.

test/tests/getattr_guarding.py

+# expected: reffail
 # Test some weird getattr/hasattr guarding scenarios
 
 

test/tests/getattr_start_failing_test.py

+# expected: reffail
 g = 0
 class C(object):
     @property

test/tests/getattrfunc_rewriting.py

+# expected: reffail
 # Regression test: make sure we guard / invalidate our getattr() rewrites:
 
 class C(object):

test/tests/getitem.py

+# expected: reffail
 # getitem
 
 def f(l):

test/tests/global_and_local.py

+# expected: reffail
 # I would have expected this to be valid, but cPython and pypy err out saying "name 'x' is local and global"
 
 try:

test/tests/grp_test.py

+# expected: reffail
 import grp
 print grp.getgrnam("root")

test/tests/gzip_test.py

+# expected: reffail
 import gzip
 import io
 

test/tests/hasattr.py

+# expected: reffail
 a = 'test'
 assert hasattr(a, "__str__")
 assert hasattr(a, "dupa") == False

test/tests/hashlib_test.py

+# expected: reffail
 import hashlib
 
 #for m in [hashlib.md5(), hashlib.sha1(), hashlib.sha256(), hashlib.sha512()]:

test/tests/imp_test.py

+# expected: reffail
 import imp
 print len(imp.find_module("os"))
 e = imp.find_module("encodings")

test/tests/import_failure_test.py

+# expected: reffail
 try:
     import non_existent_module
     assert 0, "shouldn't get here"

test/tests/import_globals.py

+# expected: reffail
 import test_package.import_target
 import import_target
 print

test/tests/import_module_subclasses.py

+# expected: reffail
 
 # The six.py module exposed some issues with how we were handling imports;
 # an imported name is not necessarily an attribute of the module object itself,

test/tests/import_test.py

+# expected: reffail
 import import_target
 print import_target.x
 

test/tests/incremental_tb.py

+# expected: reffail
 import traceback
 import sys
 def f():

test/tests/incremental_tb_bjit.py

+# expected: reffail
 # This is the same as incremental_tb_bjit.py but tests the baseline JIT.
 try:
     import __pyston__

test/tests/inheritance.py

+# expected: reffail
 
 def f1():
     class C(object):

test/tests/init_must_return_none.py

+# expected: reffail
 # should_error
 # As the test filename says, init functions must return None.
 # This file tests that; it also makes sure that it gets tested

test/tests/input.py

+# expected: reffail
 import StringIO
 import sys
 

test/tests/inspect_test.py

+# expected: reffail
 import inspect
 
 def f1(a, b=2, *args, **kw):

test/tests/instance_methods.py

+# expected: reffail
 class C(object):
     def foo(self):
         pass

test/tests/int_ids2.py

+# expected: reffail
 # while I think nothing requires that this works I actually found this in a library...
 import subprocess
 def f():

test/tests/intern.py

+# expected: reffail
 try:
     print intern(123)
 except TypeError:

test/tests/interp2_small.py

+# expected: reffail
 class Random(object):
     def __init__(self, seed):
         self.cur = seed

test/tests/intmethods.py

+# expected: reffail
 # can't try large numbers yet due to lack of long
 for i in xrange(1, 100):
     for j in xrange(1, 100):

test/tests/io_test.py

+# expected: reffail
 import io
 filename = "io_test_.txt"
 

test/tests/isinstance.py

+# expected: reffail
 class M(type):
     pass
 

test/tests/iter_gc.py

+# expected: reffail
 # Regression test: make sure we GC special iterator objects correctly
 
 import gc

test/tests/itertools_test.py

+# expected: reffail
 import itertools
 
 its = []

test/tests/json_test.py

+# expected: reffail
 from StringIO import StringIO
 import json
 

test/tests/keyword_ics.py

+# expected: reffail
 # statcheck: noninit_count('slowpath_runtimecall') <= 500
 # statcheck: noninit_count('slowpath_callfunc') <= 500
 # run_args: -n

test/tests/kwarg_ics.py

+# expected: reffail
 # run_args: -n
 # statcheck: noninit_count('slowpath_runtimecall') < 20
 

test/tests/kwargs_protocol.py

+# expected: reffail
 class C(object):
     def __len__(self):
         print "__len__"

test/tests/list.py

+# expected: reffail
 l = range(5)
 print l
 print l * 5

test/tests/list_sorting_gc.py

+# expected: reffail
 # regression test: list sorting had a gc bug
 
 import gc

test/tests/list_subclassing.py

+# expected: reffail
 
 class MyList(list):
     pass

test/tests/listcomp.py

+# expected: reffail
 print [(i, j) for i in range(4) for j in range(4)]
 
 def f():

test/tests/locals_test.py

+# expected: reffail
 def f1():
     l = []
     for i in xrange(5):

test/tests/logging_test.py

+# expected: reffail
 import logging
 import warnings
 

test/tests/long.py

+# expected: reffail
 l = 2L
 print l
 print type(l)

test/tests/marshal_test.py

+# expected: reffail
 import marshal
 o = [-1, 1.23456789, complex(1.2, 3.4)]
 o += [True, False, None]

test/tests/math_test.py

+# expected: reffail
 import math
 print math.sqrt(2)
 print math.sqrt(0)

test/tests/member_descriptor_ics.py

+# expected: reffail
 # run_args: -n
 # statcheck: noninit_count('slowpath_member_descriptor_get') <= 1500
 

test/tests/memoryview_test.py

+# expected: reffail
 def test(v):
     print len(v), v.readonly, v.itemsize, v.tobytes(), v.tolist()
 

test/tests/metaclass_parent.py

+# expected: reffail
 # This would make a good Python quiz:
 
 sl = slice(1,2)

test/tests/metaclasses.py

+# expected: reffail
 class MM(type):
     def __new__(*args):
         print "MM.__new__", args[:3]

test/tests/method_ics.py

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

test/tests/module_subclassing.py

+# expected: reffail
 from types import ModuleType
 
 class MyModule(ModuleType):

test/tests/modulefinder_test.py

+# expected: reffail
 # Make sure we can at least support people who want to register themselves with modulefinder,
 # even if we don't actually support using modulefinder to find modules.
 

test/tests/modules.py

+# expected: reffail
 import empty_module
 import math
 import types

test/tests/multiline_repl.py

+# expected: reffail
 import os
 import pty
 import subprocess

test/tests/multinherit_metaclass_picking.py

+# expected: reffail
 # Test a relatively-obscure corner case of multiple inheritance:
 # the metaclass is normally the first base's metaclass, but type_new
 # will specifically delegate to a later base's metaclass if it is more

test/tests/multiple_inheritance.py

+# expected: reffail
 # Testing the basic multiple-inheritance rules and functionality:
 
 class C(object):

test/tests/multiprocessing_test.py

+# expected: reffail
 import multiprocessing
 
 # from https://docs.python.org/2/library/multiprocessing.html

test/tests/mutable_bases.py

+# expected: reffail
 class A(object):
     def foo(self):
         print "foo"

test/tests/name_forcing_syntax_error.py

+# expected: reffail
 # We could just have a file for each, but if we Do these in execs,
 # we don't need separate files for each, and that makes it easier
 # to just spam all the permutations.

test/tests/name_mangling.py

+# expected: reffail
 # Simple test:
 class MyClass(object):
     __a = 1

test/tests/native_print_tb.py

+# expected: reffail
 import sys
 import subprocess
 

test/tests/nbody_small.py

+# expected: reffail
 # -*- coding: utf-8 -*-
 # The Computer Language Benchmarks Game
 # http://shootout.alioth.debian.org/

test/tests/none__class__.py

+# expected: reffail
 print None.__class__
 
 print type(None).__doc__, None.__doc__

test/tests/nonself_resurrection.py

+# expected: reffail
 # Objects are allowed to resurrect other objects too, I guess
 from testing_helpers import test_gc
 

test/tests/nonzero_exceptions.py

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

test/tests/object_default_behavior.py

+# expected: reffail
 class C(object):
     def __delattr__(self, attr):
         print "delattr", attr

test/tests/object_new_arguments.py

+# expected: reffail
 # object.__new__ doesn't complain if __init__ is overridden:
 
 class C1(object):

test/tests/object_reduce.py

+# expected: reffail
 o = object()
 r = o.__reduce__()
 print type(r), len(r)

test/tests/oldstyle_classes.py

+# expected: reffail
 class C():
     pass
 

test/tests/operator_test.py

+# expected: reffail
 import operator
 
 print operator.methodcaller

test/tests/optparse_test.py

+# expected: reffail
 # Simple optparse test, taken from the optparse.py docstring:
 
 from optparse import OptionParser

test/tests/os_path.py

+# expected: reffail
 import os.path
 
 print type(os)

test/tests/os_test.py

+# expected: reffail
 #
 
 # currently broken:

test/tests/osr_frameinfo.py

+# expected: reffail
 try:
     import __pyston__
     __pyston__.setOption("OSR_THRESHOLD_BASELINE", 50)

test/tests/osr_into_failed_speculation.py

+# expected: reffail
 # statcheck: '-O' in EXTRA_JIT_ARGS or 1 <= stats['num_osr_exits'] <= 5
 
 # Try to trick the JIT into OSR'ing into an optimized version with a speculation

test/tests/override_assertionerror.py

+# expected: reffail
 
 orig_ae = AssertionError
 class MyAssertionError(Exception):

test/tests/package_test.py

+# expected: reffail
 import os
 
 import test_package

test/tests/parsing_bom.py

+# expected: reffail
 # I really don't understand all the intricacies of unicode parsing, but apparently in addition to
 # Python-specific coding lines, you can put a unicode byte order mark to signify that the text
 # is encoded.

test/tests/pickle_test.py

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

test/tests/pidigits_small.py

+# expected: reffail
 import time
 
 def pidigits(length):

test/tests/platform_test.py

+# expected: reffail
 import platform
 
 print type(platform.python_implementation())

test/tests/prevent_nonascii_attrs.py

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

test/tests/print_function.py

+# expected: reffail
 # This is the same as print.py, but using print as a function
 # I guess print() as a function doesn't use the softspace technique.
 

test/tests/property.py

+# expected: reffail
 # I think pypa has an issue parsing decorator expressions if they aren't simple names
 # https://github.com/vinzenz/libpypa/issues/15
 

test/tests/property_ics.py

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

test/tests/pwd_test.py

+# expected: reffail
 import pwd
 import os
 print pwd.getpwuid(os.getuid())[5] == os.environ["HOME"]

test/tests/pyc_stress_test.py

+# expected: reffail
 # skip-if: '-x' in EXTRA_JIT_ARGS
 # - too slow
 

test/tests/python_slots_test.py

+# expected: reffail
 print 'basic test'
 class C(object):
     __slots__ = ['a', 'b', '__private_var']

test/tests/raise_2arg.py

+# expected: reffail
 # two-argument `raise' statements where second argument is itself an exception
 class A(Exception): pass
 class B(Exception): pass

test/tests/random_test.py

+# expected: reffail
 import random
 
 print type(random.random())

test/tests/reduce.py

+# expected: reffail
 import operator
 
 print reduce(operator.add, range(50))

test/tests/refcounting_regression_test.py

+# expected: reffail
 # Random regression test from implementing refcounting:
 
 def f():

test/tests/reinitializable.py

+# expected: reffail
 # Not sure if these are important or not:
 
 p = property(1, 2, 3)

test/tests/relative_import4.py

+# expected: reffail
 import relative_import4_pkg

test/tests/reload_test.py

+# expected: reffail
 import os, sys
 
 def delete_file(name):

test/tests/reprtest.py

+# expected: reffail
 a=1
 try:
     a.b

test/tests/resource_test.py

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

test/tests/reversed.py

+# expected: reffail
 
 print list(reversed("hello"))
 print list(reversed(""))

test/tests/select_test.py

+# expected: reffail
 import gc
 import select
 

test/tests/seqiter_protocol.py

+# expected: reffail
 # Objects are iterable if they just implement __getitem__:
 
 class C(object):

test/tests/set-recursion.py

+# expected: reffail
 class C(object):
     def __init__(self):
         self.t = set([self])

test/tests/set.py

+# expected: reffail
 s1 = {1}
 
 def sorted(s):

test/tests/setattr.py

+# expected: reffail
 class MyDescr(object):
     def __set__(self, inst, val):
         print type(self), type(inst), val

test/tests/setcomp.py

+# expected: reffail
 # this file is adapted from dictcomp.py
 def set2str(s):
     # set isn't guaranteed to keep things in sorted order (although in CPython it does AFAICT)

test/tests/signal_test.py

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

test/tests/slice.py

+# expected: reffail
 class Indexable(object):
     def __getitem__(self, idx):
         print "called getitem on object", idx

test/tests/socket_test.py

+# expected: reffail
 import socket
 
 s = socket.socket()

test/tests/softspace.py

-# expected: fail
-
 import sys
 
 old_stdout = sys.stdout

test/tests/special_getattrs.py

+# expected: reffail
 def show(obj):
     print obj.__class__
     for b in obj.__class__.__mro__:

test/tests/sqlite_test.py

+# expected: reffail
 import os
 try:
     os.unlink('example.db')

test/tests/sre_compile_test.py

+# expected: reffail
 import sre_compile
 import sre_constants
 

test/tests/ssl_test.py

+# expected: reffail
 import ssl
 import socket
 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

test/tests/static_closure_locations.py

+# expected: reffail
 # The use of c makes sure a closure gets passed through all 4 functions.
 # The use of a in g makes sure that a is in f's closure.
 # The a in j should refer to the a in h, thus throwing an exception since

test/tests/stop_iterable.py

+# expected: reffail
 class C(object):
   i = 0
   def next(self):

test/tests/str_encode_decode.py

+# expected: reffail
 def test(string, encoding):
  s = string.encode(encoding)
  print encoding, s

test/tests/str_functions.py

+# expected: reffail
 print "-".join(["hello", "world"])
 print "-".join(("hello", "world"))
 

test/tests/str_manipulation.py

+# expected: reffail
 # Testing capitalize/title methods.
 
 def test(s):

test/tests/strop_test.py

+# expected: reffail
 import strop
 
 print repr(strop.whitespace)

test/tests/struct_test.py

+# expected: reffail
 import struct
 s = struct.pack("II", 1, 1234)
 print repr(s)

test/tests/subclass_builtins.py

+# expected: reffail
 class CustomInt(int):
     pass
 

test/tests/subclasshook_test.py

+# expected: reffail
 from abc import ABCMeta
 
 class SubClassHook:

test/tests/subprocess_test.py

+# expected: reffail
 import subprocess
 
 subprocess.check_call(["true"])

test/tests/super.py

+# expected: reffail
 class B(object):
     def __new__(cls, arg1):
         print "B.__new__", arg1

test/tests/super2.py

+# expected: reffail
 # this test is a modfied version of a testcase inside test_descr
 
 class C:

test/tests/super_long_string.py

+# expected: reffail
 import os
 import sys
 

test/tests/sys_current_frames.py

+# expected: reffail
 # this is copied out of cpythons test_sys.py and adopted to use assert stmts
 import sys
 import thread

test/tests/sys_excinfo.py

+# expected: reffail
 # should_error
 # Different ways of nesting exceptions
 

test/tests/sys_getframe.py

+# expected: reffail
 """
 Frame Hack Recipe #1: Ruby-style string interpolation (version 1)
 """

test/tests/sys_getframe_exited.py

+# expected: reffail
 import sys
 def f():
     var = 42

test/tests/sys_meta_path.py

+# expected: reffail
 # PEP-302  import hook test
 
 import sys

test/tests/sys_modules_replacement_test.py

+# expected: reffail
 import sys_modules_replacement_target
 
 print hasattr(sys_modules_replacement_target, "path")

test/tests/sys_modules_test.py

+# expected: reffail
 # Not sure how important or necessary this behavior is, but
 # CPython's behavior around sys.modules seems to be that it saves
 # an internal reference to the object, so if you set sys.modules

test/tests/sys_test.py

+# expected: reffail
 import sys
 import os.path
 

test/tests/tempfile_test.py

+# expected: reffail
 import os
 import tempfile
 

test/tests/termios_test.py

+# expected: reffail
 import termios, sys
 fd = sys.stdout.fileno()
 try:

test/tests/test_chr.py

+# expected: reffail
 
 
 assert chr(0) == '\x00'

test/tests/test_dictviews.py

+# expected: reffail
 # This is a copy of cpythons test with the recursive repr test disabled
 # remove this test when we can pass cpythons test
 

test/tests/testing_helpers.py

+# expected: reffail
 # This file isn't really meant to be run as a test, though it won't really
 # make a difference.
 

test/tests/thread_contention_test.py

+# expected: reffail
 from thread import start_new_thread
 import time
 

test/tests/thread_forking.py

+# expected: reffail
 # skip-if: '-n' in EXTRA_JIT_ARGS or '-O' in EXTRA_JIT_ARGS
 
 # Make sure that we can fork from a threaded environment

test/tests/thread_memory_model_test.py

+# expected: reffail
 from thread import start_new_thread
 import time
 

test/tests/thread_spawning.py

+# expected: reffail
 # Make sure we can spawn a bunch of threads
 
 import threading

test/tests/thread_test.py

+# expected: reffail
 from thread import start_new_thread, allocate_lock, _count
 import time
 

test/tests/threading_local.py

+# expected: reffail
 import gc
 import threading
 

test/tests/traceback_limits.py

+# expected: reffail
 import sys
 import traceback
 

test/tests/traceback_test.py

+# expected: reffail
 # A test of both the tracebacks we generate and the traceback module
 #
 # (We keep fixing tracebacks in one case to break them in another, so it's time for a test.)

test/tests/traceback_test2.py

+# expected: reffail
 import sys, traceback
 
 def lumberjack():

test/tests/trunc_test.py

+# expected: reffail
 import math
 
 def type_trunc(type, arg):

test/tests/try_class.py

+# expected: reffail
 # we have one test at global scope, another at local.
 # they behave differently in codegen; there have been points at which either was bugged when the other was not.
 try:

test/tests/try_def.py

+# expected: reffail
 def f():
     try:
         def foo(): return 0

test/tests/try_return_finally.py

+# expected: reffail
 def f():
     try:
         # Looks like this returns from the function, but it needs to go to the finally block

test/tests/tryfinally.py

+# expected: reffail
 # try-finally support
 
 import sys

test/tests/tuple_indexing.py

+# expected: reffail
 def f():
     print (1,2,3)[-1]
 f()

test/tests/tuple_iteration.py

+# expected: reffail
 d = {}
 for i in xrange(1000):
     d[i] = i ** 2

test/tests/tuple_unpacking_invalid.py

+# expected: reffail
 # should_error
 # Int not iterable:
 a, b, c = 1

test/tests/tuples.py

+# expected: reffail
 # Some parsing tests:
 print ((1, 2),)
 print (1, 2, 3)

test/tests/type_errors.py

+# expected: reffail
 # Regression test: make sure that we can handle various kinds of written type errors.
 # ex if we can prove that an expression would throw an error due to type issues, we should
 # still compile and run the function just fine.

test/tests/type_flags.py

+# expected: reffail
 import slots_test
 
 HEAPTYPE = 1<<9

test/tests/unaryops.py

+# expected: reffail
 def f(x):
     print x, not x, ~x, +x, -x
 

test/tests/unicode_test.py

+# expected: reffail
 print repr(unicode())
 print repr(unicode('hello world'))
 print unicode('hello world')

test/tests/unpacking_exceptions.py

+# expected: reffail
 # Test the behavior of tuple unpacking in the face of exceptions being thrown at certain points.
 # - If an exception gets thrown in the "unpack to a given size" part, none of the targets get set
 # - If setting a target throws an exception, then the previous targets had been set, but not the future ones

test/tests/urlparse_test.py

+# expected: reffail
 import urlparse
 print urlparse.urlparse("http://www.dropbox.com")

test/tests/uuid_test.py

+# expected: reffail
 import uuid
 
 # Hack to get the test passing until we support CTypes.

test/tests/vregs_only_introspection.py

+# expected: reffail
 import sys
 def f():
     # By the time of the f_locals call, x will only be alive because

test/tests/warnings_test.py

+# expected: reffail
 import warnings
 import _warnings
 

test/tests/weakdict_test.py

+# expected: reffail
 from weakref import WeakKeyDictionary, WeakValueDictionary
 
 class S(object):

test/tests/weakref1.py

+# expected: reffail
 import weakref
 import gc
 

test/tests/weakref4.py

+# expected: reffail
 import weakref
 
 def doStuff():

test/tests/weakref_finalizers.py

+# expected: reffail
 # test to ensure that weakref callbacks and finalizers get called in the
 # right order
 

test/tests/weakref_proxy.py

+# expected: reffail
 import weakref
 from testing_helpers import test_gc
 

test/tests/weakref_ref_subclass.py

+# expected: reffail
 # Make sure we can subclass from weakref.ref, since the weakref module itself does this
 
 from weakref import ref

test/tests/weakrefs.py

+# expected: reffail
 import weakref
 import array
 import re

test/tests/weakrefs_extensions.py

+# expected: reffail
 # Make sure we can support weakrefs on extension objects.
 # The _sre.SRE_Pattern type is one of the few builtin types that supports weakrefs natively.
 

test/tests/with_ctxclass_order_of_access.py

+# expected: reffail
 class Mgr(object):
     def __init__(self): print 'Mgr.__init__()'
 

test/tests/wrapperdesc.py

+# expected: reffail
 class C(object):
     pass
 print C.__str__ is object.__str__

test/tests/zipimport_hook_test.py

+# expected: reffail
 import sys, os
 
 # this zip contains two pkgs: test1 and test2

test/tests/zipimport_test.py

+# expected: reffail
 import os
 import zipimport
 

tools/tester.py

@@ -207,6 +207,9 @@ def get_test_options(fn, check_stats, run_memcheck):
         elif l.startswith("# no-collect-stats"):
             opts.collect_stats = False
 
+    if opts.expected == "reffail":
+        opts.expected = "fail"
+
     if not opts.skip:
         # consider other reasons for skipping file
         if SKIP_FAILING_TESTS and opts.expected == 'fail':