Question: I am testing a UI in which the user clicks a delete button and a table entry disappears. As such, I want to be able to check that the table entry no longer exists.

I have tried using `ExpectedConditions.not()` to invert `ExpectedConditions.presenceOfElementLocated()`, hoping that it would mean "expect that there is not a presence of the specified element". My code is like so:

```
browser.navigate().to("http://stackoverflow.com");
new WebDriverWait(browser, 1).until(
        ExpectedConditions.not(
                ExpectedConditions.presenceOfElementLocated(By.id("foo"))));

```

However, I found that even doing this, I get a `TimeoutExpcetion` caused by a `NoSuchElementException` saying that the element "foo" does not exist. Of course, having no such element is what I want, but I don't want an exception to be thrown.

So how can I wait until an element no longer exists? I would prefer an example that does not rely on catching an exception if at all possible (as I understand it, exceptions should be thrown for exceptional behavior).

Answer: 
You can also use - 

```
new WebDriverWait(driver, 10).until(ExpectedConditions.invisibilityOfElementLocated(locator));

```

If you go through [the source](https://github.com/SeleniumHQ/selenium/blob/d1a06e59f242e7920c3b7ba8f6dcd2f546857b4b/java/client/src/org/openqa/selenium/support/ui/ExpectedConditions.java#L572) of it you can see that both `NoSuchElementException` and `staleElementReferenceException` are handled.

```
/**
   * An expectation for checking that an element is either invisible or not
   * present on the DOM.
   *
   * @param locator used to find the element
   */
  public static ExpectedCondition<Boolean> invisibilityOfElementLocated(
      final By locator) {
    return new ExpectedCondition<Boolean>() {
      @Override
      public Boolean apply(WebDriver driver) {
        try {
          return !(findElement(locator, driver).isDisplayed());
        } catch (NoSuchElementException e) {
          // Returns true because the element is not present in DOM. The
          // try block checks if the element is present but is invisible.
          return true;
        } catch (StaleElementReferenceException e) {
          // Returns true because stale element reference implies that element
          // is no longer visible.
          return true;
        }
      }

```
The solution would still rely on exception-handling. And this is pretty much ok, even [standard Expected Conditions](https://code.google.com/p/selenium/source/browse/java/client/src/org/openqa/selenium/support/ui/ExpectedConditions.java#453) rely on exceptions being thrown by `findElement()`.

The idea is to create a *custom Expected Condition*:

```
  public static ExpectedCondition<Boolean> absenceOfElementLocated(
      final By locator) {
    return new ExpectedCondition<Boolean>() {
      @Override
      public Boolean apply(WebDriver driver) {
        try {
          driver.findElement(locator);
          return false;
        } catch (NoSuchElementException e) {
          return true;
        } catch (StaleElementReferenceException e) {
          return true;
        }
      }

      @Override
      public String toString() {
        return "element to not being present: " + locator;
      }
    };
  }

```