def test_element_stale(session):
    session.url = inline("<input id=foobar>")
    element = session.find.css("input", all=False)
    session.refresh()

    response = get_element_property(session, element.id, "id")
    assert_error(response, "stale element reference")

def test_set_to_state_cross_realm(session, create_window, state, realmSetting):
    original_window = session.window_handle
    session.window_handle = create_window()
    parameters = { "descriptor": { "name": "geolocation" }, "state": state }
    parameters.update(realmSetting)

    response = session.transport.send(
        "POST", "/session/{session_id}/permissions".format(**vars(session)),
        parameters
    )

    try:
        assert_success(response)
    except AssertionError:
        # > 4. If parameters.state is an inappropriate permission state for any
        # >    implementation-defined reason, return a WebDriver error with
        # >    WebDriver error code invalid argument.
        assert_error(response, "invalid argument")
        return

    assert response.body.get("value") == None

    session.window_handle = original_window

    response = query(session, "geolocation")

    assert_success(response)
    result = response.body.get("value")

    assert isinstance(result, dict)
    assert result.get("status") == "success"
    assert result.get("value") == state

def test_no_browsing_context(session, create_window):
    # 18.1 step 1
    session.window_handle = create_window()
    session.close()

    response = dismiss_alert(session)
    assert_error(response, "no such window")

def test_array(session):
    response = execute_script(session, """
        let arr = [];
        arr.push(arr);
        return arr;
        """)
    assert_error(response, "javascript error")

def test_object_in_array(session):
    response = execute_script(session, """
        let obj = {};
        obj.reference = obj;
        return [obj];
        """)
    assert_error(response, "javascript error")

def test_element_not_found(session):
    # 14.2 Step 2
    response = session.transport.send("POST", "session/{session_id}/element/{element_id}/clear"
                                      .format(session_id=session.session_id,
                                              element_id="box1"))

    assert_error(response, "no such element")

def test_disabled_element_not_resettable(session):
    # 14.2 Step 3
    session.url = inline("<input type=text value=Federer disabled>")

    element = session.find.css("input", all=False)
    response = clear(session, element)
    assert_error(response, "invalid element state")

def test_closed_context(session, create_window):
    new_window = create_window()
    session.window_handle = new_window
    session.close()

    response = get_active_element(session)
    assert_error(response, "no such window")

def test_no_browsing_context(session, create_window):
    # 18.4 step 3
    session.window_handle = create_window()
    session.close()

    response = send_alert_text(session, "Federer")
    assert_error(response, "no such window")

def test_no_browsing_context(session, create_window):
    # 13.1 step 1
    session.window_handle = create_window()
    session.close()

    result = is_element_selected(session, "foo")
    assert_error(result, "no such window")

def test_strict_display_none(session, create_files):
    files = create_files(["foo"])
    session.url = inline("""<input type=file style="display: none">""")
    element = session.find.css("input", all=False)

    response = element_send_keys(session, element, str(files[0]))
    assert_error(response, "element not interactable")

def test_handle_prompt_default(session, create_dialog, dialog_type):
    create_dialog(dialog_type, text="dialog")

    response = get_window_rect(session)
    assert_error(response, "unexpected alert open")

    assert_dialog_handled(session, expected_text="dialog")

def test_element_stale(session):
    session.url = _input
    element = session.find.css("input", all=False)
    session.refresh()

    result = get_element_property(session, element.id, "id")
    assert_error(result, "stale element reference")

def test_element_readonly(session):
    # 14.2 Step 7
    session.url = inline("<input type=text readonly value=Federer>")

    element = session.find.css("input", all=False)
    response = clear(session, element)
    assert_error(response, "invalid element state")

def test_await_promise_reject(session):
    response = execute_async_script(session, """
        let resolve = arguments[0];
        await Promise.reject(new Error('my error'));
        resolve('foo');
        """)
    assert_error(response, "javascript error")

def test_element_pointer_events_disabled(session):
    # 14.2 Step 7
    session.url = inline("<input type=text value=Federer style=\"pointer-events: none\">")

    element = session.find.css("input", all=False)
    response = clear(session, element)
    assert_error(response, "invalid element state")

def test_no_browsing_context(session, create_window):
    # 18.3 step 1
    session.window_handle = create_window()
    session.close()

    response = get_dialog_text(session)
    assert_error(response, "no such window")

def test_element_not_editable(session):
    # 14.2 Step 3
    session.url = inline("<p>This is not an editable paragraph.")

    element = session.find.css("p", all=False)
    response = clear(session, element)
    assert_error(response, "invalid element state")

def test_is_stale(session):
    session.url = inline("<button>foo</button>")
    button = session.find.css("button", all=False)
    session.url = inline("<button>bar</button>")

    response = click_element(session, button)
    assert_error(response, "stale element reference")

def test_stale(session):
    session.url = inline("<input>")
    element = session.find.css("input", all=False)
    session.refresh()

    result = take_element_screenshot(session, element.id)
    assert_error(result, "stale element reference")