Update web-platform-tests and CSS tests.

- Update CSS tests to revision e05bfd5e30ed662c2f8a353577003f8eed230180.
- Update web-platform-tests to revision a052787dd5c069a340031011196b73affbd68cd9.

tests/wpt/css-tests/tools/pytest/testing/test_assertrewrite.py

@@ -0,0 +1,716 @@
+import os
+import stat
+import sys
+import zipfile
+import py
+import pytest
+
+ast = pytest.importorskip("ast")
+if sys.platform.startswith("java"):
+    # XXX should be xfail
+    pytest.skip("assert rewrite does currently not work on jython")
+
+import _pytest._code
+from _pytest.assertion import util
+from _pytest.assertion.rewrite import rewrite_asserts, PYTEST_TAG
+from _pytest.main import EXIT_NOTESTSCOLLECTED
+
+
+def setup_module(mod):
+    mod._old_reprcompare = util._reprcompare
+    _pytest._code._reprcompare = None
+
+def teardown_module(mod):
+    util._reprcompare = mod._old_reprcompare
+    del mod._old_reprcompare
+
+
+def rewrite(src):
+    tree = ast.parse(src)
+    rewrite_asserts(tree)
+    return tree
+
+def getmsg(f, extra_ns=None, must_pass=False):
+    """Rewrite the assertions in f, run it, and get the failure message."""
+    src = '\n'.join(_pytest._code.Code(f).source().lines)
+    mod = rewrite(src)
+    code = compile(mod, "<test>", "exec")
+    ns = {}
+    if extra_ns is not None:
+        ns.update(extra_ns)
+    py.builtin.exec_(code, ns)
+    func = ns[f.__name__]
+    try:
+        func()
+    except AssertionError:
+        if must_pass:
+            pytest.fail("shouldn't have raised")
+        s = str(sys.exc_info()[1])
+        if not s.startswith("assert"):
+            return "AssertionError: " + s
+        return s
+    else:
+        if not must_pass:
+            pytest.fail("function didn't raise at all")
+
+
+class TestAssertionRewrite:
+
+    def test_place_initial_imports(self):
+        s = """'Doc string'\nother = stuff"""
+        m = rewrite(s)
+        assert isinstance(m.body[0], ast.Expr)
+        assert isinstance(m.body[0].value, ast.Str)
+        for imp in m.body[1:3]:
+            assert isinstance(imp, ast.Import)
+            assert imp.lineno == 2
+            assert imp.col_offset == 0
+        assert isinstance(m.body[3], ast.Assign)
+        s = """from __future__ import with_statement\nother_stuff"""
+        m = rewrite(s)
+        assert isinstance(m.body[0], ast.ImportFrom)
+        for imp in m.body[1:3]:
+            assert isinstance(imp, ast.Import)
+            assert imp.lineno == 2
+            assert imp.col_offset == 0
+        assert isinstance(m.body[3], ast.Expr)
+        s = """'doc string'\nfrom __future__ import with_statement\nother"""
+        m = rewrite(s)
+        assert isinstance(m.body[0], ast.Expr)
+        assert isinstance(m.body[0].value, ast.Str)
+        assert isinstance(m.body[1], ast.ImportFrom)
+        for imp in m.body[2:4]:
+            assert isinstance(imp, ast.Import)
+            assert imp.lineno == 3
+            assert imp.col_offset == 0
+        assert isinstance(m.body[4], ast.Expr)
+        s = """from . import relative\nother_stuff"""
+        m = rewrite(s)
+        for imp in m.body[0:2]:
+            assert isinstance(imp, ast.Import)
+            assert imp.lineno == 1
+            assert imp.col_offset == 0
+        assert isinstance(m.body[3], ast.Expr)
+
+    def test_dont_rewrite(self):
+        s = """'PYTEST_DONT_REWRITE'\nassert 14"""
+        m = rewrite(s)
+        assert len(m.body) == 2
+        assert isinstance(m.body[0].value, ast.Str)
+        assert isinstance(m.body[1], ast.Assert)
+        assert m.body[1].msg is None
+
+    def test_name(self):
+        def f():
+            assert False
+        assert getmsg(f) == "assert False"
+        def f():
+            f = False
+            assert f
+        assert getmsg(f) == "assert False"
+        def f():
+            assert a_global  # noqa
+        assert getmsg(f, {"a_global" : False}) == "assert False"
+        def f():
+            assert sys == 42
+        assert getmsg(f, {"sys" : sys}) == "assert sys == 42"
+        def f():
+            assert cls == 42  # noqa
+        class X(object):
+            pass
+        assert getmsg(f, {"cls" : X}) == "assert cls == 42"
+
+    def test_assert_already_has_message(self):
+        def f():
+            assert False, "something bad!"
+        assert getmsg(f) == "AssertionError: something bad!\nassert False"
+
+    def test_assertion_message(self, testdir):
+        testdir.makepyfile("""
+            def test_foo():
+                assert 1 == 2, "The failure message"
+        """)
+        result = testdir.runpytest()
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "*AssertionError*The failure message*",
+            "*assert 1 == 2*",
+        ])
+
+    def test_assertion_message_multiline(self, testdir):
+        testdir.makepyfile("""
+            def test_foo():
+                assert 1 == 2, "A multiline\\nfailure message"
+        """)
+        result = testdir.runpytest()
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "*AssertionError*A multiline*",
+            "*failure message*",
+            "*assert 1 == 2*",
+        ])
+
+    def test_assertion_message_tuple(self, testdir):
+        testdir.makepyfile("""
+            def test_foo():
+                assert 1 == 2, (1, 2)
+        """)
+        result = testdir.runpytest()
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "*AssertionError*%s*" % repr((1, 2)),
+            "*assert 1 == 2*",
+        ])
+
+    def test_assertion_message_expr(self, testdir):
+        testdir.makepyfile("""
+            def test_foo():
+                assert 1 == 2, 1 + 2
+        """)
+        result = testdir.runpytest()
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "*AssertionError*3*",
+            "*assert 1 == 2*",
+        ])
+
+    def test_assertion_message_escape(self, testdir):
+        testdir.makepyfile("""
+            def test_foo():
+                assert 1 == 2, 'To be escaped: %'
+        """)
+        result = testdir.runpytest()
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "*AssertionError: To be escaped: %",
+            "*assert 1 == 2",
+        ])
+
+    def test_boolop(self):
+        def f():
+            f = g = False
+            assert f and g
+        assert getmsg(f) == "assert (False)"
+        def f():
+            f = True
+            g = False
+            assert f and g
+        assert getmsg(f) == "assert (True and False)"
+        def f():
+            f = False
+            g = True
+            assert f and g
+        assert getmsg(f) == "assert (False)"
+        def f():
+            f = g = False
+            assert f or g
+        assert getmsg(f) == "assert (False or False)"
+        def f():
+            f = g = False
+            assert not f and not g
+        getmsg(f, must_pass=True)
+        def x():
+            return False
+        def f():
+            assert x() and x()
+        assert getmsg(f, {"x" : x}) == "assert (x())"
+        def f():
+            assert False or x()
+        assert getmsg(f, {"x" : x}) == "assert (False or x())"
+        def f():
+            assert 1 in {} and 2 in {}
+        assert getmsg(f) == "assert (1 in {})"
+        def f():
+            x = 1
+            y = 2
+            assert x in {1 : None} and y in {}
+        assert getmsg(f) == "assert (1 in {1: None} and 2 in {})"
+        def f():
+            f = True
+            g = False
+            assert f or g
+        getmsg(f, must_pass=True)
+        def f():
+            f = g = h = lambda: True
+            assert f() and g() and h()
+        getmsg(f, must_pass=True)
+
+    def test_short_circut_evaluation(self):
+        def f():
+            assert True or explode  # noqa
+        getmsg(f, must_pass=True)
+        def f():
+            x = 1
+            assert x == 1 or x == 2
+        getmsg(f, must_pass=True)
+
+    def test_unary_op(self):
+        def f():
+            x = True
+            assert not x
+        assert getmsg(f) == "assert not True"
+        def f():
+            x = 0
+            assert ~x + 1
+        assert getmsg(f) == "assert (~0 + 1)"
+        def f():
+            x = 3
+            assert -x + x
+        assert getmsg(f) == "assert (-3 + 3)"
+        def f():
+            x = 0
+            assert +x + x
+        assert getmsg(f) == "assert (+0 + 0)"
+
+    def test_binary_op(self):
+        def f():
+            x = 1
+            y = -1
+            assert x + y
+        assert getmsg(f) == "assert (1 + -1)"
+        def f():
+            assert not 5 % 4
+        assert getmsg(f) == "assert not (5 % 4)"
+
+    def test_boolop_percent(self):
+        def f():
+            assert 3 % 2 and False
+        assert getmsg(f) == "assert ((3 % 2) and False)"
+        def f():
+            assert False or 4 % 2
+        assert getmsg(f) == "assert (False or (4 % 2))"
+
+    @pytest.mark.skipif("sys.version_info < (3,5)")
+    def test_at_operator_issue1290(self, testdir):
+        testdir.makepyfile("""
+            class Matrix:
+                def __init__(self, num):
+                    self.num = num
+                def __matmul__(self, other):
+                    return self.num * other.num
+
+            def test_multmat_operator():
+                assert Matrix(2) @ Matrix(3) == 6""")
+        testdir.runpytest().assert_outcomes(passed=1)
+
+    def test_call(self):
+        def g(a=42, *args, **kwargs):
+            return False
+        ns = {"g" : g}
+        def f():
+            assert g()
+        assert getmsg(f, ns) == """assert g()"""
+        def f():
+            assert g(1)
+        assert getmsg(f, ns) == """assert g(1)"""
+        def f():
+            assert g(1, 2)
+        assert getmsg(f, ns) == """assert g(1, 2)"""
+        def f():
+            assert g(1, g=42)
+        assert getmsg(f, ns) == """assert g(1, g=42)"""
+        def f():
+            assert g(1, 3, g=23)
+        assert getmsg(f, ns) == """assert g(1, 3, g=23)"""
+        def f():
+            seq = [1, 2, 3]
+            assert g(*seq)
+        assert getmsg(f, ns) == """assert g(*[1, 2, 3])"""
+        def f():
+            x = "a"
+            assert g(**{x : 2})
+        assert getmsg(f, ns) == """assert g(**{'a': 2})"""
+
+    def test_attribute(self):
+        class X(object):
+            g = 3
+        ns = {"x" : X}
+        def f():
+            assert not x.g # noqa
+        assert getmsg(f, ns) == """assert not 3
+ +  where 3 = x.g"""
+        def f():
+            x.a = False  # noqa
+            assert x.a   # noqa
+        assert getmsg(f, ns) == """assert x.a"""
+
+    def test_comparisons(self):
+        def f():
+            a, b = range(2)
+            assert b < a
+        assert getmsg(f) == """assert 1 < 0"""
+        def f():
+            a, b, c = range(3)
+            assert a > b > c
+        assert getmsg(f) == """assert 0 > 1"""
+        def f():
+            a, b, c = range(3)
+            assert a < b > c
+        assert getmsg(f) == """assert 1 > 2"""
+        def f():
+            a, b, c = range(3)
+            assert a < b <= c
+        getmsg(f, must_pass=True)
+        def f():
+            a, b, c = range(3)
+            assert a < b
+            assert b < c
+        getmsg(f, must_pass=True)
+
+    def test_len(self):
+        def f():
+            l = list(range(10))
+            assert len(l) == 11
+        assert getmsg(f).startswith("""assert 10 == 11
+ +  where 10 = len([""")
+
+    def test_custom_reprcompare(self, monkeypatch):
+        def my_reprcompare(op, left, right):
+            return "42"
+        monkeypatch.setattr(util, "_reprcompare", my_reprcompare)
+        def f():
+            assert 42 < 3
+        assert getmsg(f) == "assert 42"
+        def my_reprcompare(op, left, right):
+            return "%s %s %s" % (left, op, right)
+        monkeypatch.setattr(util, "_reprcompare", my_reprcompare)
+        def f():
+            assert 1 < 3 < 5 <= 4 < 7
+        assert getmsg(f) == "assert 5 <= 4"
+
+    def test_assert_raising_nonzero_in_comparison(self):
+        def f():
+            class A(object):
+                def __nonzero__(self):
+                    raise ValueError(42)
+                def __lt__(self, other):
+                    return A()
+                def __repr__(self):
+                    return "<MY42 object>"
+            def myany(x):
+                return False
+            assert myany(A() < 0)
+        assert "<MY42 object> < 0" in getmsg(f)
+
+    def test_formatchar(self):
+        def f():
+            assert "%test" == "test"
+        assert getmsg(f).startswith("assert '%test' == 'test'")
+
+    def test_custom_repr(self):
+        def f():
+            class Foo(object):
+                a = 1
+
+                def __repr__(self):
+                    return "\n{ \n~ \n}"
+            f = Foo()
+            assert 0 == f.a
+        assert r"where 1 = \n{ \n~ \n}.a" in util._format_lines([getmsg(f)])[0]
+
+
+class TestRewriteOnImport:
+
+    def test_pycache_is_a_file(self, testdir):
+        testdir.tmpdir.join("__pycache__").write("Hello")
+        testdir.makepyfile("""
+            def test_rewritten():
+                assert "@py_builtins" in globals()""")
+        assert testdir.runpytest().ret == 0
+
+    def test_pycache_is_readonly(self, testdir):
+        cache = testdir.tmpdir.mkdir("__pycache__")
+        old_mode = cache.stat().mode
+        cache.chmod(old_mode ^ stat.S_IWRITE)
+        testdir.makepyfile("""
+            def test_rewritten():
+                assert "@py_builtins" in globals()""")
+        try:
+            assert testdir.runpytest().ret == 0
+        finally:
+            cache.chmod(old_mode)
+
+    def test_zipfile(self, testdir):
+        z = testdir.tmpdir.join("myzip.zip")
+        z_fn = str(z)
+        f = zipfile.ZipFile(z_fn, "w")
+        try:
+            f.writestr("test_gum/__init__.py", "")
+            f.writestr("test_gum/test_lizard.py", "")
+        finally:
+            f.close()
+        z.chmod(256)
+        testdir.makepyfile("""
+            import sys
+            sys.path.append(%r)
+            import test_gum.test_lizard""" % (z_fn,))
+        assert testdir.runpytest().ret == EXIT_NOTESTSCOLLECTED
+
+    def test_readonly(self, testdir):
+        sub = testdir.mkdir("testing")
+        sub.join("test_readonly.py").write(
+        py.builtin._totext("""
+def test_rewritten():
+    assert "@py_builtins" in globals()
+            """).encode("utf-8"), "wb")
+        old_mode = sub.stat().mode
+        sub.chmod(320)
+        try:
+            assert testdir.runpytest().ret == 0
+        finally:
+            sub.chmod(old_mode)
+
+    def test_dont_write_bytecode(self, testdir, monkeypatch):
+        testdir.makepyfile("""
+            import os
+            def test_no_bytecode():
+                assert "__pycache__" in __cached__
+                assert not os.path.exists(__cached__)
+                assert not os.path.exists(os.path.dirname(__cached__))""")
+        monkeypatch.setenv("PYTHONDONTWRITEBYTECODE", "1")
+        assert testdir.runpytest_subprocess().ret == 0
+
+    @pytest.mark.skipif('"__pypy__" in sys.modules')
+    def test_pyc_vs_pyo(self, testdir, monkeypatch):
+        testdir.makepyfile("""
+            import pytest
+            def test_optimized():
+                "hello"
+                assert test_optimized.__doc__ is None"""
+        )
+        p = py.path.local.make_numbered_dir(prefix="runpytest-", keep=None,
+                                            rootdir=testdir.tmpdir)
+        tmp = "--basetemp=%s" % p
+        monkeypatch.setenv("PYTHONOPTIMIZE", "2")
+        monkeypatch.delenv("PYTHONDONTWRITEBYTECODE", raising=False)
+        assert testdir.runpytest_subprocess(tmp).ret == 0
+        tagged = "test_pyc_vs_pyo." + PYTEST_TAG
+        assert tagged + ".pyo" in os.listdir("__pycache__")
+        monkeypatch.undo()
+        monkeypatch.delenv("PYTHONDONTWRITEBYTECODE", raising=False)
+        assert testdir.runpytest_subprocess(tmp).ret == 1
+        assert tagged + ".pyc" in os.listdir("__pycache__")
+
+    def test_package(self, testdir):
+        pkg = testdir.tmpdir.join("pkg")
+        pkg.mkdir()
+        pkg.join("__init__.py").ensure()
+        pkg.join("test_blah.py").write("""
+def test_rewritten():
+    assert "@py_builtins" in globals()""")
+        assert testdir.runpytest().ret == 0
+
+    def test_translate_newlines(self, testdir):
+        content = "def test_rewritten():\r\n assert '@py_builtins' in globals()"
+        b = content.encode("utf-8")
+        testdir.tmpdir.join("test_newlines.py").write(b, "wb")
+        assert testdir.runpytest().ret == 0
+
+    @pytest.mark.skipif(sys.version_info < (3,3),
+            reason='packages without __init__.py not supported on python 2')
+    def test_package_without__init__py(self, testdir):
+        pkg = testdir.mkdir('a_package_without_init_py')
+        pkg.join('module.py').ensure()
+        testdir.makepyfile("import a_package_without_init_py.module")
+        assert testdir.runpytest().ret == EXIT_NOTESTSCOLLECTED
+
+class TestAssertionRewriteHookDetails(object):
+    def test_loader_is_package_false_for_module(self, testdir):
+        testdir.makepyfile(test_fun="""
+            def test_loader():
+                assert not __loader__.is_package(__name__)
+            """)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines([
+            "* 1 passed*",
+        ])
+
+    def test_loader_is_package_true_for_package(self, testdir):
+        testdir.makepyfile(test_fun="""
+            def test_loader():
+                assert not __loader__.is_package(__name__)
+
+            def test_fun():
+                assert __loader__.is_package('fun')
+
+            def test_missing():
+                assert not __loader__.is_package('pytest_not_there')
+            """)
+        testdir.mkpydir('fun')
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines([
+            '* 3 passed*',
+        ])
+
+    @pytest.mark.skipif("sys.version_info[0] >= 3")
+    @pytest.mark.xfail("hasattr(sys, 'pypy_translation_info')")
+    def test_assume_ascii(self, testdir):
+        content = "u'\xe2\x99\xa5\x01\xfe'"
+        testdir.tmpdir.join("test_encoding.py").write(content, "wb")
+        res = testdir.runpytest()
+        assert res.ret != 0
+        assert "SyntaxError: Non-ASCII character" in res.stdout.str()
+
+    @pytest.mark.skipif("sys.version_info[0] >= 3")
+    def test_detect_coding_cookie(self, testdir):
+        testdir.makepyfile(test_cookie="""
+            # -*- coding: utf-8 -*-
+            u"St\xc3\xa4d"
+            def test_rewritten():
+                assert "@py_builtins" in globals()""")
+        assert testdir.runpytest().ret == 0
+
+    @pytest.mark.skipif("sys.version_info[0] >= 3")
+    def test_detect_coding_cookie_second_line(self, testdir):
+        testdir.makepyfile(test_cookie="""
+            # -*- coding: utf-8 -*-
+            u"St\xc3\xa4d"
+            def test_rewritten():
+                assert "@py_builtins" in globals()""")
+        assert testdir.runpytest().ret == 0
+
+    @pytest.mark.skipif("sys.version_info[0] >= 3")
+    def test_detect_coding_cookie_crlf(self, testdir):
+        testdir.makepyfile(test_cookie="""
+            # -*- coding: utf-8 -*-
+            u"St\xc3\xa4d"
+            def test_rewritten():
+                assert "@py_builtins" in globals()""")
+        assert testdir.runpytest().ret == 0
+
+    def test_sys_meta_path_munged(self, testdir):
+        testdir.makepyfile("""
+            def test_meta_path():
+                import sys; sys.meta_path = []""")
+        assert testdir.runpytest().ret == 0
+
+    def test_write_pyc(self, testdir, tmpdir, monkeypatch):
+        from _pytest.assertion.rewrite import _write_pyc
+        from _pytest.assertion import AssertionState
+        try:
+            import __builtin__ as b
+        except ImportError:
+            import builtins as b
+        config = testdir.parseconfig([])
+        state = AssertionState(config, "rewrite")
+        source_path = tmpdir.ensure("source.py")
+        pycpath = tmpdir.join("pyc").strpath
+        assert _write_pyc(state, [1], source_path.stat(), pycpath)
+        def open(*args):
+            e = IOError()
+            e.errno = 10
+            raise e
+        monkeypatch.setattr(b, "open", open)
+        assert not _write_pyc(state, [1], source_path.stat(), pycpath)
+
+    def test_resources_provider_for_loader(self, testdir):
+        """
+        Attempts to load resources from a package should succeed normally,
+        even when the AssertionRewriteHook is used to load the modules.
+
+        See #366 for details.
+        """
+        pytest.importorskip("pkg_resources")
+
+        testdir.mkpydir('testpkg')
+        contents = {
+            'testpkg/test_pkg': """
+                import pkg_resources
+
+                import pytest
+                from _pytest.assertion.rewrite import AssertionRewritingHook
+
+                def test_load_resource():
+                    assert isinstance(__loader__, AssertionRewritingHook)
+                    res = pkg_resources.resource_string(__name__, 'resource.txt')
+                    res = res.decode('ascii')
+                    assert res == 'Load me please.'
+                """,
+        }
+        testdir.makepyfile(**contents)
+        testdir.maketxtfile(**{'testpkg/resource': "Load me please."})
+
+        result = testdir.runpytest_subprocess()
+        result.assert_outcomes(passed=1)
+
+    def test_read_pyc(self, tmpdir):
+        """
+        Ensure that the `_read_pyc` can properly deal with corrupted pyc files.
+        In those circumstances it should just give up instead of generating
+        an exception that is propagated to the caller.
+        """
+        import py_compile
+        from _pytest.assertion.rewrite import _read_pyc
+
+        source = tmpdir.join('source.py')
+        pyc = source + 'c'
+
+        source.write('def test(): pass')
+        py_compile.compile(str(source), str(pyc))
+
+        contents = pyc.read(mode='rb')
+        strip_bytes = 20  # header is around 8 bytes, strip a little more
+        assert len(contents) > strip_bytes
+        pyc.write(contents[:strip_bytes], mode='wb')
+
+        assert _read_pyc(source, str(pyc)) is None  # no error
+
+    def test_reload_is_same(self, testdir):
+        # A file that will be picked up during collecting.
+        testdir.tmpdir.join("file.py").ensure()
+        testdir.tmpdir.join("pytest.ini").write(py.std.textwrap.dedent("""
+            [pytest]
+            python_files = *.py
+        """))
+
+        testdir.makepyfile(test_fun="""
+            import sys
+            try:
+                from imp import reload
+            except ImportError:
+                pass
+
+            def test_loader():
+                import file
+                assert sys.modules["file"] is reload(file)
+            """)
+        result = testdir.runpytest('-s')
+        result.stdout.fnmatch_lines([
+            "* 1 passed*",
+        ])
+
+    def test_get_data_support(self, testdir):
+        """Implement optional PEP302 api (#808).
+        """
+        path = testdir.mkpydir("foo")
+        path.join("test_foo.py").write(_pytest._code.Source("""
+            class Test:
+                def test_foo(self):
+                    import pkgutil
+                    data = pkgutil.get_data('foo.test_foo', 'data.txt')
+                    assert data == b'Hey'
+        """))
+        path.join('data.txt').write('Hey')
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines('*1 passed*')
+
+
+def test_issue731(testdir):
+    testdir.makepyfile("""
+    class LongReprWithBraces(object):
+        def __repr__(self):
+           return 'LongReprWithBraces({' + ('a' * 80) + '}' + ('a' * 120) + ')'
+
+        def some_method(self):
+            return False
+
+    def test_long_repr():
+        obj = LongReprWithBraces()
+        assert obj.some_method()
+    """)
+    result = testdir.runpytest()
+    assert 'unbalanced braces' not in result.stdout.str()
+
+
+def test_collapse_false_unbalanced_braces():
+    util._collapse_false('some text{ False\n{False = some more text\n}')