public boolean isTasksVisible(String... taskNames) {
        return tasks.filter(visible).contains(taskNames);
    }
/*
    ох ты и залез в дебри)

    давай читать код)

    метод isTasksVisible
    что я жду от метода с таким именем и такими параметрами
    я жду - что он определит - таски с переданными именами - видимы или нет

    пока оставим за скобками - зачем это нам

    раз умеешь такой сложный код писать - значит умеешь такой же сложный код читать)

    смотрим на реализацию

    tasks.filter(visible) - возвратит ElementsCollection - коллекцию тасок
    зажав ctrl - наведи курсор мыши на filter
    во всплывающей подсказке - будет сигнатура метода

    давай посмотрим - что это за тип такой - ElementsCollection
    зажав ctrl - кникни на ElementsCollection

    видим
    public class ElementsCollection extends AbstractList<SelenideElement>
    а AbstractList - наследуется от AbstractCollection
    public abstract class AbstractCollection<E> implements Collection<E>
    и тут ты уже сможешь посмотреть на реализацию метода contains

    у нас - список с элементами типа SelenideElement
    и вызывая метод contains для списка элементов типа SelenideElement - мы ищем -
    а нет ли в списке элемента типа массив строк String[] taskNames
    как ты думаешь, мы найдем такой элемент?

    это равносильно поиску груши в лотке с яйцами
    нету там груши )

    этот метод при любых переданных в него параметрах - вернет false

    а теперь - подумай - как работают методы - где ты вызываешь isTasksVisible
    совсем не так, как ты планировал.

    не спеши поправлять этот метод
    так как - его надо просто удалить)
    не нужен тебе такой метод вообще

    далее - когда будем рассматривать реализованные методы, где isTasksVisible вызывается
    ты поймешь - почему
*/
***************************************************
    public void toggle(String... taskNames) {
         for (String name : taskNames) {
             if (isTasksVisible(name)) {
                 tasks.findBy(exactText(name)).find(".toggle").click();
             }
         }
    }
/*
    ты помнишь, почему мы себе позволили реализовать add с параметром String... taskNames ?
        мы это сделали - т к могут быть такие тесты,
        в которых нам сразу на старте надо добавить несколько тасок

    а тут - зачем нам такой сложный метод - переключающий стостояния нескольких тасок?

    я писала тебе - что каждая операция должна быть проверена сразу
    и лишь в определенных случаях - можно отложить проверку на небольшое количество шагов

    добавляя несколько тасок - мы делаем однотипные операции
    и проверив единожды после добавления нескольких тасок -
    мы в общем поймем - все ли ок с операцией добавления

    с toggle - история посложнее
        самое главное - нам на старте теста - не надо переключать несколько тасок
        нам не нужна такая функциональность - мы не будем городить такие предварительные действия в тесте
        а для тестируемых шагов - нам достаточно toggle для одной таски

        второе - такой toggle(String... taskNames) - не так прост, как кажется на первый взгляд
        в ситуации - когда ты вызываешь toggle("a", "b")
        где a - активная таска, b - закомпличеная таска
        такой метод таску a - закомплитит, таску  b - переоткроет
        ты не находишь - что сложный метод?
        после каждого такого действия - toggle ОДНОЙ таски - нужна проверка состяния всего списка тасок

        а то получим
        вызвали toggle("a", "b")
        потом - проверили состояние списка
        и допустим - оно не такое
        как сделать вывод - что к этому привело?
        а точно и быстро сделать такой вывод?
        в общем случае - не получится...

    вот и получается - что кроме add
    такие параметры String... taskNames -
    другим методам-действиям - категорически не нужны

    заметь - я не говорю сейчас про методы-проверки состояния списка тасок

    теперь про реализацию
        предположим - что метод isTasksVisible - работает правильно =
        определяет - видима ли такая-то таска

        допустим, мы пишем тест
        в предварительных действиях - добавили таски a, b, c
        и далее - вызываем toggle (a, b, c)
        по идее - когда такое пишем - мы рассчитываем со всеми 3-мя тасками и поработать
        а у нас - ошибочная ситуация - таски b не видно
        и наш очень умный (я бы даже сказала - не в меру умный) метод - вполне без ошибок отработает
        вопрос - а мы заинтересованы в таком методе, который не отлавливает проблемы, который обходит их?
        мы - при написании тест-метода - знаем свои ожидания максимально точно
        и мы  - вызывая toggle (a, b, c)
        рассчитываем - что с (a, b, c) - можно выполнить это действие
        и если хотя бы с какой-то таской такого выполнить нельзя - так тест ДОЛЖЕН упасть
        так что - делать вспомогательные методы настолько умными - вредно

        далее будут примеры - когда во вспомогательных методах нам и правда понадобится не простая логика

        тут - далеко не такой случай
        мы знаем - что хотим сделать, и какую операцию, и над какой таской
        и вот только это и должен делать метод

        мы же еще и отрапортуем - что такое-то действие - мы покрыли...
        а что ж мы покрыли - если мы в if-блок даже не зашли (при данной реализации - вообще не зашли,
        а при правильной реализации - может зашли, а может и нет - читуация ничем не лучше)
        т е - мы еще и про покрытие наврем с три короба...

    выводы
       цикла и если - категорически не нужно
       оставь методы максимально простыми
       от этого - будет только лучше

    вернись к ранее реализованной функциональности toggle

    да и вообще
       add("a","b") - это ДВЕ операции (мы покрыли ДВАЖДЫ добавление таски)
       toggle("a","b") - это тоже ДВЕ операции
       т е - это - не путь для оптимизации покрытия, это его иллюзия

    более про другие так реализованные методы - не распространяюсь
    примерно та же логика рассуждений

    метод должен делать ровно то - что декларирует
    ровно с теми тасками, имена которых в метод передали
    без взяких исключений

    и еще
        не жалей времени - визуально контролируй
        то ли делает твой тест
        то, что он отработал - еще абсолютно ничего не значит
        он еще должен был выполнить ровно то, что ты как автор - запланировал

        одинаково ошибся и в методах-действиях, и в методах-проверках
        и как результат - методы-действия работают криво + проверки точно также проверяют
        так что - в процессе разработки теста - визуальный контроль тоже должен быть
*/
******************************************************
    public void assertTasksAre(String... taskNames) {

        if (isTasksVisible(taskNames)) {
            tasks.shouldHave(exactTexts(taskNames));
        }
    }

    public void assertTasksEmpty() {
        if (isTasksVisible()) {
            tasks.shouldBe(empty);
        }
    }
/*
    про isTasksVisible() - уже не распространяюсь
    см выше

    тут - тоже этого не надо - вызова isTasksVisible()

    фактически - "благодаря" isTasksVisible() - проверок и не происходило

    еще раз посмотри строки 144-150 прошлого ревью
    видео - тоже посмотри

    коллекция отфильтрованная по visible = tasks.filter(visible)
    как и любая другая ElementsCollection
    она может быть проверена с помощью метода shouldHave/shouldBe
*/
*********************************************************
    public int count() {

        return tasks.filter(visible).size();

    }
/*
    тебе не нужен такой метод

    прошлое ревью
    строки 25-109
    особенно - 53-58 и 63-69

    если не согласен
    или не понятно
    пообщайся в слеке на эту тему

    либо спрашивай, либо доказывай свою правоту
*/
*********************************************
ublic class TodoMVCTest {

    private TaskManagerPage page = new TaskManagerPage();

    @Test
    public void testTasksCommonFlow() {

        open("https://todomvc4tasj.herokuapp.com/");

        page.create("a", "b", "c");
        page.edit("a", "a edited");
        /*
            писала тебе про неявные проверки
            прошлое ревью
            строки 247-272

            если бы ты добавил лишь таску "a"
            то да edit("a" ... - проверило бы операцию добавления таски "a"

            а так - нет
            проверка должна проверять состояние всех тасок
            а их у тебя целых три
            добавь только ту таску - которая нужна
            тебе пока одной достаточно
            позже добавишь еще
                хоть
                    create("a", "b")
                или
                    create("a")
                    ...
                    create("b")
                это все равно - 2 покрытые операции добавления тасок
            потому - не надо стремиться надобавлять таски сразу
            ничего кроме сложностей - тебе это не даст
        */
        page.toggle("a edited", "b");
        /*
            хорошая идея - добавить-отредактировать-закомплитить таску (одну)
        */
        assertEquals(page.count(), 3);
        /*
            тут надо проверить - не количество тасок
            а их тексты
            причем - ждущей проверкой

            если тут будет сценарий
            добавить-отредактировать-закомплитить таску "a"
            то и тексты тасок будут "a"

            да, ты так не проверишь закомпличенность таски
            так это можно сделать после перехода на Active фильтр
            писала про это в прошлый раз
            строки 313-329

        */

        page.filterCompleted();
        /*
            переход на другой фильтр - это тоже действие
            и оно тоже должно быть проверено
            проверки нету
        */
        page.toggle("b");
        page.assertTasksAre("a edited");
        /*
            благодаря текущей реализации - этого всего не произошло

            да и вообще - маловато для Completed фильтра покрыл

            писала про более равномерное покрытие
        */

        page.filterActive();
        /*
            нужна проверка
        */
        page.toggleAll();
        page.assertTasksEmpty();

        page.filterAll();
        /*
            нужна проверка
        */
        page.delete("a edited", "c");
        /*
            нужна проверка
        */
        page.clearCompleted();
        /*
            нужна проверка
        */
/*
    проследи покрытие самостоятельно - аналогично описанию
    строки 153-196 прошлого ревью

    также учти - строки 238-242
*/