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_mark.py

@@ -0,0 +1,672 @@
+import os
+
+import py, pytest
+from _pytest.mark import MarkGenerator as Mark
+
+class TestMark:
+    def test_markinfo_repr(self):
+        from _pytest.mark import MarkInfo
+        m = MarkInfo("hello", (1,2), {})
+        repr(m)
+
+    def test_pytest_exists_in_namespace_all(self):
+        assert 'mark' in py.test.__all__
+        assert 'mark' in pytest.__all__
+
+    def test_pytest_mark_notcallable(self):
+        mark = Mark()
+        pytest.raises((AttributeError, TypeError), mark)
+
+    def test_pytest_mark_name_starts_with_underscore(self):
+        mark = Mark()
+        pytest.raises(AttributeError, getattr, mark, '_some_name')
+
+    def test_pytest_mark_bare(self):
+        mark = Mark()
+        def f():
+            pass
+        mark.hello(f)
+        assert f.hello
+
+    def test_pytest_mark_keywords(self):
+        mark = Mark()
+        def f():
+            pass
+        mark.world(x=3, y=4)(f)
+        assert f.world
+        assert f.world.kwargs['x'] == 3
+        assert f.world.kwargs['y'] == 4
+
+    def test_apply_multiple_and_merge(self):
+        mark = Mark()
+        def f():
+            pass
+        mark.world
+        mark.world(x=3)(f)
+        assert f.world.kwargs['x'] == 3
+        mark.world(y=4)(f)
+        assert f.world.kwargs['x'] == 3
+        assert f.world.kwargs['y'] == 4
+        mark.world(y=1)(f)
+        assert f.world.kwargs['y'] == 1
+        assert len(f.world.args) == 0
+
+    def test_pytest_mark_positional(self):
+        mark = Mark()
+        def f():
+            pass
+        mark.world("hello")(f)
+        assert f.world.args[0] == "hello"
+        mark.world("world")(f)
+
+    def test_pytest_mark_positional_func_and_keyword(self):
+        mark = Mark()
+        def f():
+            raise Exception
+        m = mark.world(f, omega="hello")
+        def g():
+            pass
+        assert m(g) == g
+        assert g.world.args[0] is f
+        assert g.world.kwargs["omega"] == "hello"
+
+    def test_pytest_mark_reuse(self):
+        mark = Mark()
+        def f():
+            pass
+        w = mark.some
+        w("hello", reason="123")(f)
+        assert f.some.args[0] == "hello"
+        assert f.some.kwargs['reason'] == "123"
+        def g():
+            pass
+        w("world", reason2="456")(g)
+        assert g.some.args[0] == "world"
+        assert 'reason' not in g.some.kwargs
+        assert g.some.kwargs['reason2'] == "456"
+
+
+def test_marked_class_run_twice(testdir, request):
+    """Test fails file is run twice that contains marked class.
+    See issue#683.
+    """
+    py_file = testdir.makepyfile("""
+    import pytest
+    @pytest.mark.parametrize('abc', [1, 2, 3])
+    class Test1(object):
+        def test_1(self, abc):
+            assert abc in [1, 2, 3]
+    """)
+    file_name = os.path.basename(py_file.strpath)
+    rec = testdir.inline_run(file_name, file_name)
+    rec.assertoutcome(passed=6)
+
+
+def test_ini_markers(testdir):
+    testdir.makeini("""
+        [pytest]
+        markers =
+            a1: this is a webtest marker
+            a2: this is a smoke marker
+    """)
+    testdir.makepyfile("""
+        def test_markers(pytestconfig):
+            markers = pytestconfig.getini("markers")
+            print (markers)
+            assert len(markers) >= 2
+            assert markers[0].startswith("a1:")
+            assert markers[1].startswith("a2:")
+    """)
+    rec = testdir.inline_run()
+    rec.assertoutcome(passed=1)
+
+def test_markers_option(testdir):
+    testdir.makeini("""
+        [pytest]
+        markers =
+            a1: this is a webtest marker
+            a1some: another marker
+    """)
+    result = testdir.runpytest("--markers", )
+    result.stdout.fnmatch_lines([
+        "*a1*this is a webtest*",
+        "*a1some*another marker",
+    ])
+
+def test_markers_option_with_plugin_in_current_dir(testdir):
+    testdir.makeconftest('pytest_plugins = "flip_flop"')
+    testdir.makepyfile(flip_flop="""\
+        def pytest_configure(config):
+            config.addinivalue_line("markers", "flip:flop")
+
+        def pytest_generate_tests(metafunc):
+            try:
+                mark = metafunc.function.flipper
+            except AttributeError:
+                return
+            metafunc.parametrize("x", (10, 20))""")
+    testdir.makepyfile("""\
+        import pytest
+        @pytest.mark.flipper
+        def test_example(x):
+            assert x""")
+
+    result = testdir.runpytest("--markers")
+    result.stdout.fnmatch_lines(["*flip*flop*"])
+
+
+def test_mark_on_pseudo_function(testdir):
+    testdir.makepyfile("""
+        import pytest
+
+        @pytest.mark.r(lambda x: 0/0)
+        def test_hello():
+            pass
+    """)
+    reprec = testdir.inline_run()
+    reprec.assertoutcome(passed=1)
+
+def test_strict_prohibits_unregistered_markers(testdir):
+    testdir.makepyfile("""
+        import pytest
+        @pytest.mark.unregisteredmark
+        def test_hello():
+            pass
+    """)
+    result = testdir.runpytest("--strict")
+    assert result.ret != 0
+    result.stdout.fnmatch_lines([
+        "*unregisteredmark*not*registered*",
+    ])
+
+@pytest.mark.parametrize("spec", [
+        ("xyz", ("test_one",)),
+        ("xyz and xyz2", ()),
+        ("xyz2", ("test_two",)),
+        ("xyz or xyz2", ("test_one", "test_two"),)
+])
+def test_mark_option(spec, testdir):
+    testdir.makepyfile("""
+        import pytest
+        @pytest.mark.xyz
+        def test_one():
+            pass
+        @pytest.mark.xyz2
+        def test_two():
+            pass
+    """)
+    opt, passed_result = spec
+    rec = testdir.inline_run("-m", opt)
+    passed, skipped, fail = rec.listoutcomes()
+    passed = [x.nodeid.split("::")[-1] for x in passed]
+    assert len(passed) == len(passed_result)
+    assert list(passed) == list(passed_result)
+
+@pytest.mark.parametrize("spec", [
+        ("interface", ("test_interface",)),
+        ("not interface", ("test_nointer",)),
+])
+def test_mark_option_custom(spec, testdir):
+    testdir.makeconftest("""
+        import pytest
+        def pytest_collection_modifyitems(items):
+            for item in items:
+                if "interface" in item.nodeid:
+                    item.keywords["interface"] = pytest.mark.interface
+    """)
+    testdir.makepyfile("""
+        def test_interface():
+            pass
+        def test_nointer():
+            pass
+    """)
+    opt, passed_result = spec
+    rec = testdir.inline_run("-m", opt)
+    passed, skipped, fail = rec.listoutcomes()
+    passed = [x.nodeid.split("::")[-1] for x in passed]
+    assert len(passed) == len(passed_result)
+    assert list(passed) == list(passed_result)
+
+@pytest.mark.parametrize("spec", [
+        ("interface", ("test_interface",)),
+        ("not interface", ("test_nointer", "test_pass")),
+        ("pass", ("test_pass",)),
+        ("not pass", ("test_interface", "test_nointer")),
+])
+def test_keyword_option_custom(spec, testdir):
+    testdir.makepyfile("""
+        def test_interface():
+            pass
+        def test_nointer():
+            pass
+        def test_pass():
+            pass
+    """)
+    opt, passed_result = spec
+    rec = testdir.inline_run("-k", opt)
+    passed, skipped, fail = rec.listoutcomes()
+    passed = [x.nodeid.split("::")[-1] for x in passed]
+    assert len(passed) == len(passed_result)
+    assert list(passed) == list(passed_result)
+
+
+@pytest.mark.parametrize("spec", [
+        ("None", ("test_func[None]",)),
+        ("1.3", ("test_func[1.3]",)),
+        ("2-3", ("test_func[2-3]",))
+])
+def test_keyword_option_parametrize(spec, testdir):
+    testdir.makepyfile("""
+        import pytest
+        @pytest.mark.parametrize("arg", [None, 1.3, "2-3"])
+        def test_func(arg):
+            pass
+    """)
+    opt, passed_result = spec
+    rec = testdir.inline_run("-k", opt)
+    passed, skipped, fail = rec.listoutcomes()
+    passed = [x.nodeid.split("::")[-1] for x in passed]
+    assert len(passed) == len(passed_result)
+    assert list(passed) == list(passed_result)
+
+
+def test_parametrized_collected_from_command_line(testdir):
+    """Parametrized test not collected if test named specified
+       in command line issue#649.
+    """
+    py_file = testdir.makepyfile("""
+        import pytest
+        @pytest.mark.parametrize("arg", [None, 1.3, "2-3"])
+        def test_func(arg):
+            pass
+    """)
+    file_name = os.path.basename(py_file.strpath)
+    rec = testdir.inline_run(file_name + "::" + "test_func")
+    rec.assertoutcome(passed=3)
+
+
+class TestFunctional:
+
+    def test_mark_per_function(self, testdir):
+        p = testdir.makepyfile("""
+            import pytest
+            @pytest.mark.hello
+            def test_hello():
+                assert hasattr(test_hello, 'hello')
+        """)
+        result = testdir.runpytest(p)
+        result.stdout.fnmatch_lines(["*1 passed*"])
+
+    def test_mark_per_module(self, testdir):
+        item = testdir.getitem("""
+            import pytest
+            pytestmark = pytest.mark.hello
+            def test_func():
+                pass
+        """)
+        keywords = item.keywords
+        assert 'hello' in keywords
+
+    def test_marklist_per_class(self, testdir):
+        item = testdir.getitem("""
+            import pytest
+            class TestClass:
+                pytestmark = [pytest.mark.hello, pytest.mark.world]
+                def test_func(self):
+                    assert TestClass.test_func.hello
+                    assert TestClass.test_func.world
+        """)
+        keywords = item.keywords
+        assert 'hello' in keywords
+
+    def test_marklist_per_module(self, testdir):
+        item = testdir.getitem("""
+            import pytest
+            pytestmark = [pytest.mark.hello, pytest.mark.world]
+            class TestClass:
+                def test_func(self):
+                    assert TestClass.test_func.hello
+                    assert TestClass.test_func.world
+        """)
+        keywords = item.keywords
+        assert 'hello' in keywords
+        assert 'world' in keywords
+
+    def test_mark_per_class_decorator(self, testdir):
+        item = testdir.getitem("""
+            import pytest
+            @pytest.mark.hello
+            class TestClass:
+                def test_func(self):
+                    assert TestClass.test_func.hello
+        """)
+        keywords = item.keywords
+        assert 'hello' in keywords
+
+    def test_mark_per_class_decorator_plus_existing_dec(self, testdir):
+        item = testdir.getitem("""
+            import pytest
+            @pytest.mark.hello
+            class TestClass:
+                pytestmark = pytest.mark.world
+                def test_func(self):
+                    assert TestClass.test_func.hello
+                    assert TestClass.test_func.world
+        """)
+        keywords = item.keywords
+        assert 'hello' in keywords
+        assert 'world' in keywords
+
+    def test_merging_markers(self, testdir):
+        p = testdir.makepyfile("""
+            import pytest
+            pytestmark = pytest.mark.hello("pos1", x=1, y=2)
+            class TestClass:
+                # classlevel overrides module level
+                pytestmark = pytest.mark.hello(x=3)
+                @pytest.mark.hello("pos0", z=4)
+                def test_func(self):
+                    pass
+        """)
+        items, rec = testdir.inline_genitems(p)
+        item, = items
+        keywords = item.keywords
+        marker = keywords['hello']
+        assert marker.args == ("pos0", "pos1")
+        assert marker.kwargs == {'x': 1, 'y': 2, 'z': 4}
+
+        # test the new __iter__ interface
+        l = list(marker)
+        assert len(l) == 3
+        assert l[0].args == ("pos0",)
+        assert l[1].args == ()
+        assert l[2].args == ("pos1", )
+
+    @pytest.mark.xfail(reason='unfixed')
+    def test_merging_markers_deep(self, testdir):
+        # issue 199 - propagate markers into nested classes
+        p = testdir.makepyfile("""
+            import pytest
+            class TestA:
+                pytestmark = pytest.mark.a
+                def test_b(self):
+                    assert True
+                class TestC:
+                    # this one didnt get marked
+                    def test_d(self):
+                        assert True
+        """)
+        items, rec = testdir.inline_genitems(p)
+        for item in items:
+            print (item, item.keywords)
+            assert 'a' in item.keywords
+
+    def test_mark_decorator_subclass_does_not_propagate_to_base(self, testdir):
+        p = testdir.makepyfile("""
+            import pytest
+
+            @pytest.mark.a
+            class Base: pass
+
+            @pytest.mark.b
+            class Test1(Base):
+                def test_foo(self): pass
+
+            class Test2(Base):
+                def test_bar(self): pass
+        """)
+        items, rec = testdir.inline_genitems(p)
+        self.assert_markers(items, test_foo=('a', 'b'), test_bar=('a',))
+
+    def test_mark_decorator_baseclasses_merged(self, testdir):
+        p = testdir.makepyfile("""
+            import pytest
+
+            @pytest.mark.a
+            class Base: pass
+
+            @pytest.mark.b
+            class Base2(Base): pass
+
+            @pytest.mark.c
+            class Test1(Base2):
+                def test_foo(self): pass
+
+            class Test2(Base2):
+                @pytest.mark.d
+                def test_bar(self): pass
+        """)
+        items, rec = testdir.inline_genitems(p)
+        self.assert_markers(items, test_foo=('a', 'b', 'c'),
+                            test_bar=('a', 'b', 'd'))
+
+    def test_mark_with_wrong_marker(self, testdir):
+        reprec = testdir.inline_runsource("""
+                import pytest
+                class pytestmark:
+                    pass
+                def test_func():
+                    pass
+        """)
+        l = reprec.getfailedcollections()
+        assert len(l) == 1
+        assert "TypeError" in str(l[0].longrepr)
+
+    def test_mark_dynamically_in_funcarg(self, testdir):
+        testdir.makeconftest("""
+            import pytest
+            def pytest_funcarg__arg(request):
+                request.applymarker(pytest.mark.hello)
+            def pytest_terminal_summary(terminalreporter):
+                l = terminalreporter.stats['passed']
+                terminalreporter.writer.line("keyword: %s" % l[0].keywords)
+        """)
+        testdir.makepyfile("""
+            def test_func(arg):
+                pass
+        """)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines([
+            "keyword: *hello*"
+        ])
+
+    def test_merging_markers_two_functions(self, testdir):
+        p = testdir.makepyfile("""
+            import pytest
+            @pytest.mark.hello("pos1", z=4)
+            @pytest.mark.hello("pos0", z=3)
+            def test_func():
+                pass
+        """)
+        items, rec = testdir.inline_genitems(p)
+        item, = items
+        keywords = item.keywords
+        marker = keywords['hello']
+        l = list(marker)
+        assert len(l) == 2
+        assert l[0].args == ("pos0",)
+        assert l[1].args == ("pos1",)
+
+    def test_no_marker_match_on_unmarked_names(self, testdir):
+        p = testdir.makepyfile("""
+            import pytest
+            @pytest.mark.shouldmatch
+            def test_marked():
+                assert 1
+
+            def test_unmarked():
+                assert 1
+        """)
+        reprec = testdir.inline_run("-m", "test_unmarked", p)
+        passed, skipped, failed = reprec.listoutcomes()
+        assert len(passed) + len(skipped) + len(failed) == 0
+        dlist = reprec.getcalls("pytest_deselected")
+        deselected_tests = dlist[0].items
+        assert len(deselected_tests) == 2
+
+    def test_keywords_at_node_level(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            @pytest.fixture(scope="session", autouse=True)
+            def some(request):
+                request.keywords["hello"] = 42
+                assert "world" not in request.keywords
+
+            @pytest.fixture(scope="function", autouse=True)
+            def funcsetup(request):
+                assert "world" in request.keywords
+                assert "hello" in  request.keywords
+
+            @pytest.mark.world
+            def test_function():
+                pass
+        """)
+        reprec = testdir.inline_run()
+        reprec.assertoutcome(passed=1)
+
+    def test_keyword_added_for_session(self, testdir):
+        testdir.makeconftest("""
+            import pytest
+            def pytest_collection_modifyitems(session):
+                session.add_marker("mark1")
+                session.add_marker(pytest.mark.mark2)
+                session.add_marker(pytest.mark.mark3)
+                pytest.raises(ValueError, lambda:
+                        session.add_marker(10))
+        """)
+        testdir.makepyfile("""
+            def test_some(request):
+                assert "mark1" in request.keywords
+                assert "mark2" in request.keywords
+                assert "mark3" in request.keywords
+                assert 10 not in request.keywords
+                marker = request.node.get_marker("mark1")
+                assert marker.name == "mark1"
+                assert marker.args == ()
+                assert marker.kwargs == {}
+        """)
+        reprec = testdir.inline_run("-m", "mark1")
+        reprec.assertoutcome(passed=1)
+
+    def assert_markers(self, items, **expected):
+        """assert that given items have expected marker names applied to them.
+        expected should be a dict of (item name -> seq of expected marker names)
+
+        .. note:: this could be moved to ``testdir`` if proven to be useful
+        to other modules.
+        """
+        from _pytest.mark import MarkInfo
+        items = dict((x.name, x) for x in items)
+        for name, expected_markers in expected.items():
+            markers = items[name].keywords._markers
+            marker_names = set([name for (name, v) in markers.items()
+                                if isinstance(v, MarkInfo)])
+            assert marker_names == set(expected_markers)
+
+
+class TestKeywordSelection:
+    def test_select_simple(self, testdir):
+        file_test = testdir.makepyfile("""
+            def test_one():
+                assert 0
+            class TestClass(object):
+                def test_method_one(self):
+                    assert 42 == 43
+        """)
+        def check(keyword, name):
+            reprec = testdir.inline_run("-s", "-k", keyword, file_test)
+            passed, skipped, failed = reprec.listoutcomes()
+            assert len(failed) == 1
+            assert failed[0].nodeid.split("::")[-1] == name
+            assert len(reprec.getcalls('pytest_deselected')) == 1
+
+        for keyword in ['test_one', 'est_on']:
+            check(keyword, 'test_one')
+        check('TestClass and test', 'test_method_one')
+
+    @pytest.mark.parametrize("keyword", [
+        'xxx', 'xxx and test_2', 'TestClass', 'xxx and not test_1',
+        'TestClass and test_2', 'xxx and TestClass and test_2'])
+    def test_select_extra_keywords(self, testdir, keyword):
+        p = testdir.makepyfile(test_select="""
+            def test_1():
+                pass
+            class TestClass:
+                def test_2(self):
+                    pass
+        """)
+        testdir.makepyfile(conftest="""
+            import pytest
+            @pytest.hookimpl(hookwrapper=True)
+            def pytest_pycollect_makeitem(name):
+                outcome = yield
+                if name == "TestClass":
+                    item = outcome.get_result()
+                    item.extra_keyword_matches.add("xxx")
+        """)
+        reprec = testdir.inline_run(p.dirpath(), '-s', '-k', keyword)
+        py.builtin.print_("keyword", repr(keyword))
+        passed, skipped, failed = reprec.listoutcomes()
+        assert len(passed) == 1
+        assert passed[0].nodeid.endswith("test_2")
+        dlist = reprec.getcalls("pytest_deselected")
+        assert len(dlist) == 1
+        assert dlist[0].items[0].name == 'test_1'
+
+    def test_select_starton(self, testdir):
+        threepass = testdir.makepyfile(test_threepass="""
+            def test_one(): assert 1
+            def test_two(): assert 1
+            def test_three(): assert 1
+        """)
+        reprec = testdir.inline_run("-k", "test_two:", threepass)
+        passed, skipped, failed = reprec.listoutcomes()
+        assert len(passed) == 2
+        assert not failed
+        dlist = reprec.getcalls("pytest_deselected")
+        assert len(dlist) == 1
+        item = dlist[0].items[0]
+        assert item.name == "test_one"
+
+    def test_keyword_extra(self, testdir):
+        p = testdir.makepyfile("""
+           def test_one():
+               assert 0
+           test_one.mykeyword = True
+        """)
+        reprec = testdir.inline_run("-k", "mykeyword", p)
+        passed, skipped, failed = reprec.countoutcomes()
+        assert failed == 1
+
+    @pytest.mark.xfail
+    def test_keyword_extra_dash(self, testdir):
+        p = testdir.makepyfile("""
+           def test_one():
+               assert 0
+           test_one.mykeyword = True
+        """)
+        # with argparse the argument to an option cannot
+        # start with '-'
+        reprec = testdir.inline_run("-k", "-mykeyword", p)
+        passed, skipped, failed = reprec.countoutcomes()
+        assert passed + skipped + failed == 0
+
+    def test_no_magic_values(self, testdir):
+        """Make sure the tests do not match on magic values,
+        no double underscored values, like '__dict__',
+        and no instance values, like '()'.
+        """
+        p = testdir.makepyfile("""
+            def test_one(): assert 1
+        """)
+        def assert_test_is_not_selected(keyword):
+            reprec = testdir.inline_run("-k", keyword, p)
+            passed, skipped, failed = reprec.countoutcomes()
+            dlist = reprec.getcalls("pytest_deselected")
+            assert passed + skipped + failed == 0
+            deselected_tests = dlist[0].items
+            assert len(deselected_tests) == 1
+
+        assert_test_is_not_selected("__")
+        assert_test_is_not_selected("()")
+