@Override
    public boolean is(Condition<WebElement> condition) {
        return condition.check(this);
    }
/*
    тут тоже try-catch нужен
    и передавай сразу getWrappedEntity() как параметр
*/
**********************
public class LazyElementInnerElement extends AbstractLazyElement {
....
    @Override
    public WebElement fetchWrappedEntity() {
        return parentElement.getWrappedEntity() == null ? null : parentElement.getWrappedEntity().findElement(locator);
    }
/*
    не надо нам вот этих проверок

    ведь  родительский getWrappedEntity() - не вернет нулл
    он вызовет эксепшен вместо этого

    тут делай просто parentElement.getWrappedEntity().findElement(locator);

    правило - мы сами не возвращаем null (речь про явный возврат нулла)
    но и лишних проверок не надо
    ведь на уровне абстрактного класса в getWrappedEntity() - мы проверяем  это и если что - кидаем эксепшен

    и тут - LazyElementInnerCollection - аналогично
*/
***************************************
public class LazyCollectionNthElement extends AbstractLazyElement {

    ...
    @Override
    public WebElement fetchWrappedEntity() {
        if (parentCollection.getWrappedEntity() == null) {
            throw new LazyСollectionIndexOutOfBoundsException();
        }
        return parentCollection.getWrappedEntity().get(index);
    }
/*
    тут - тоже
    не анализируй parentCollection.getWrappedEntity()
    нулла не будет (вместо него - будет вызван эксепшен)

    а вот окружить parentCollection.getWrappedEntity().get(index);
    секцией try-catch
    чтоб словить IndexOutOfBoundsException
    чтоб в случае такого эксепшена - бросить уже наш = LazyСollectionIndexOutOfBoundsException()

    кстати - передавай в конструкторы наших эксепшенов - пояснения
    лучше this.toString() - сложно что-то придумать

*/
****************************************
public class LazyCollectionFoundByConditionElement extends AbstractLazyElement {

......

    @Override
    public WebElement fetchWrappedEntity() {
        List<WebElement> elementList = parentCollection.getWrappedEntity();
        for (WebElement webElement : elementList) {
            if (condition.check(webElement)) {
                return webElement;
            }
        }
        return null;
        /*
            мы нулл не возвращаем

            бросай ElementNotFoundException()
            передавай в конструктор наших эксепшена - this.toString()
        */
    }
***********************************************
    public abstract class AbstractCondition<V> implements Condition<V> {

  ...
        public V apply(LazyEntity<V> lazyEntity) {
           ...
            if (!check(entity)) {
                throw new WebDriverAssertionException();
            }
        /*
            тоже - this.toString() - будет ок в качестве параметра
        */
***********************************************
public interface Matcher<V> {
    boolean check(V entity);
}
...

public class WaitFor {

    ....
    public <V> V until(Condition<V>... conditions){
/*
        когда применять V
        а когда  - T

        http://stackoverflow.com/questions/6008241/java-generics-e-and-t-what-is-the-difference

        когда типизируешь generic-типом класс (или интерфейс) - то T (T is meant to be a Type)

        а когда речь идет о типизации значения, возвращаемого методом -  V (V is Value (as a return value or mapped value))

        т е - в interface Matcher<V>  = правильно = T is meant to be a Type

        а вот в   public <V> V until - как раз V правильно
        т к V - это тип возвращаемого значения

        это и к остальным местам использования generic-ов примени
*/