jemmy/operators/ListOperator.java

/*
 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package org.netbeans.jemmy.operators;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.List;
import java.awt.event.ActionListener;
import java.awt.event.ItemListener;
import java.util.Hashtable;

import org.netbeans.jemmy.ComponentChooser;
import org.netbeans.jemmy.Outputable;
import org.netbeans.jemmy.TestOut;
import org.netbeans.jemmy.TimeoutExpiredException;
import org.netbeans.jemmy.drivers.DriverManager;
import org.netbeans.jemmy.drivers.MultiSelListDriver;

/**
 * <BR><BR>Timeouts used: <BR>
 * ComponentOperator.WaitComponentTimeout - time to wait component displayed
 * <BR>
 * ComponentOperator.WaitComponentEnabledTimeout - time to wait component
 * enabled <BR>.
 *
 * @see org.netbeans.jemmy.Timeouts
 *
 * @author Alexandre Iline (alexandre.iline@oracle.com)
 *
 */
public class ListOperator extends ComponentOperator
        implements Outputable {

    /**
     * Identifier for a "item" properties.
     *
     * @see #getDump
     */
    public static final String ITEM_PREFIX_DPROP = "Item";

    /**
     * Identifier for a "selected item" property.
     *
     * @see #getDump
     */
    public static final String SELECTED_ITEM_PREFIX_DPROP = "SelectedItem";

    private TestOut output;
    private MultiSelListDriver driver;

    /**
     * Constructor.
     *
     * @param b a component
     */
    public ListOperator(List b) {
        super(b);
        driver = DriverManager.getMultiSelListDriver(getClass());
    }

    /**
     * Constructs a ListOperator object.
     *
     * @param cont a container
     * @param chooser a component chooser specifying searching criteria.
     * @param index an index between appropriate ones.
     */
    public ListOperator(ContainerOperator<?> cont, ComponentChooser chooser, int index) {
        this((List) cont.
                waitSubComponent(new ListFinder(chooser),
                        index));
        copyEnvironment(cont);
    }

    /**
     * Constructs a ListOperator object.
     *
     * @param cont a container
     * @param chooser a component chooser specifying searching criteria.
     */
    public ListOperator(ContainerOperator<?> cont, ComponentChooser chooser) {
        this(cont, chooser, 0);
    }

    /**
     * Constructor. Waits item text first. Uses cont's timeout and output for
     * waiting and to init operator.
     *
     * @param cont a container
     * @param text Text of item which is currently selected.
     * @param itemIndex Item index.
     * @param index Ordinal component index.
     * @throws TimeoutExpiredException
     */
    public ListOperator(ContainerOperator<?> cont, String text, int itemIndex, int index) {
        this((List) waitComponent(cont,
                new ListByItemFinder(text, itemIndex,
                        cont.getComparator()),
                index));
        copyEnvironment(cont);
    }

    /**
     * Constructor. Waits component by selected item text first. Uses cont's
     * timeout and output for waiting and to init operator.
     *
     * @param cont a container
     * @param text Text of item which is currently selected.
     * @param index Ordinal component index.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     * @throws TimeoutExpiredException
     */
    public ListOperator(ContainerOperator<?> cont, String text, int index) {
        this(cont, text, -1, index);
    }

    /**
     * Constructor. Waits component in container first. Uses cont's timeout and
     * output for waiting and to init operator.
     *
     * @param cont a container
     * @param text Text of item which is currently selected.
     * @see ComponentOperator#isCaptionEqual(String, String, boolean, boolean)
     * @throws TimeoutExpiredException
     */
    public ListOperator(ContainerOperator<?> cont, String text) {
        this(cont, text, 0);
    }

    /**
     * Constructor. Waits component in container first. Uses cont's timeout and
     * output for waiting and to init operator.
     *
     * @param cont a container
     * @param index Ordinal component index.
     * @throws TimeoutExpiredException
     */
    public ListOperator(ContainerOperator<?> cont, int index) {
        this((List) waitComponent(cont,
                new ListFinder(),
                index));
        copyEnvironment(cont);
    }

    /**
     * Constructor. Waits component in container first. Uses cont's timeout and
     * output for waiting and to init operator.
     *
     * @param cont a container
     * @throws TimeoutExpiredException
     */
    public ListOperator(ContainerOperator<?> cont) {
        this(cont, 0);
    }

    /**
     * Searches List in container.
     *
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @param index Ordinal component index.
     * @return List instance or null if component was not found.
     */
    public static List findList(Container cont, ComponentChooser chooser, int index) {
        return (List) findComponent(cont, new ListFinder(chooser), index);
    }

    /**
     * Searches 0'th List in container.
     *
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @return List instance or null if component was not found.
     */
    public static List findList(Container cont, ComponentChooser chooser) {
        return findList(cont, chooser, 0);
    }

    @Override
    public void setOutput(TestOut output) {
        super.setOutput(output.createErrorOutput());
        this.output = output;
    }

    @Override
    public TestOut getOutput() {
        return output;
    }

    @Override
    public void copyEnvironment(Operator anotherOperator) {
        super.copyEnvironment(anotherOperator);
        driver
                = (MultiSelListDriver) DriverManager.
                getDriver(DriverManager.MULTISELLIST_DRIVER_ID,
                        getClass(),
                        anotherOperator.getProperties());
    }

    private int findItemIndex(String item, StringComparator comparator, int index) {
        int count = 0;
        for (int i = 0; i < getItemCount(); i++) {
            if (comparator.equals(getItem(i), item)) {
                if (count == index) {
                    return i;
                } else {
                    count++;
                }
            }
        }
        return -1;
    }

    /**
     * Searches an item index.
     *
     * @param item item text.
     * @param index an ordinal index between appropriate ones.
     * @return an index.
     */
    public int findItemIndex(String item, int index) {
        return findItemIndex(item, getComparator(), index);
    }

    /**
     * Searches an item index.
     *
     * @param item item text.
     * @return an index.
     */
    public int findItemIndex(String item) {
        return findItemIndex(item, 0);
    }

    private void selectItem(String item, StringComparator comparator, int index) {
        selectItem(findItemIndex(item, comparator, index));
    }

    /**
     * Selects an item.
     *
     * @param item item text.
     * @param index an ordinal index between appropriate ones.
     */
    public void selectItem(String item, int index) {
        selectItem(item, getComparator(), index);
    }

    /**
     * Selects an item.
     *
     * @param item item text.
     */
    public void selectItem(String item) {
        selectItem(item, 0);
    }

    /**
     * Selects an item.
     *
     * @param index an item index.
     */
    public void selectItem(int index) {
        output.printLine("Select " + Integer.toString(index) + "`th item in list\n    : "
                + toStringSource());
        output.printGolden("Select " + Integer.toString(index) + "`th item in list");
        driver.selectItem(this, index);
        if (getVerification()) {
            waitItemSelection(index, true);
        }
    }

    /**
     * Selects some items.
     *
     * @param from start selection index.
     * @param to end selection index.
     */
    public void selectItems(int from, int to) {
        output.printLine("Select items from " + Integer.toString(from)
                + "`th to " + Integer.toString(from) + "'th in list\n    : "
                + toStringSource());
        output.printGolden("Select items from " + Integer.toString(from)
                + "`th to " + Integer.toString(from) + "'th");
        driver.selectItems(this, new int[]{from, to});
        if (getVerification()) {
            waitItemsSelection(from, to, true);
        }
    }

    /**
     * Waits for items to be selected.
     *
     * @param from Start selection inex
     * @param to End selection inex
     * @param selected Selected (true) or unselected (false).
     */
    public void waitItemsSelection(final int from, final int to, final boolean selected) {
        getOutput().printLine("Wait items to be "
                + (selected ? "" : "un") + "selected in component \n    : "
                + toStringSource());
        getOutput().printGolden("Wait items to be "
                + (selected ? "" : "un") + "selected");
        waitState(new ComponentChooser() {
            @Override
            public boolean checkComponent(Component comp) {
                int[] indices = getSelectedIndexes();
                for (int indice : indices) {
                    if (indice < from
                            || indice > to) {
                        return false;
                    }
                }
                return true;
            }

            @Override
            public String getDescription() {
                return ("Items has been "
                        + (selected ? "" : "un") + "selected");
            }

            @Override
            public String toString() {
                return "ListOperator.waitItemsSelection.ComponentChooser{description = " + getDescription() + '}';
            }
        });
    }

    /**
     * Waits for item to be selected.
     *
     * @param itemIndex an item index to be selected.
     * @param selected Selected (true) or unselected (false).
     */
    public void waitItemSelection(final int itemIndex, final boolean selected) {
        waitItemsSelection(itemIndex, itemIndex, selected);
    }

    @Override
    public Hashtable<String, Object> getDump() {
        Hashtable<String, Object> result = super.getDump();
        addToDump(result, ITEM_PREFIX_DPROP, ((List) getSource()).getItems());
        addToDump(result, SELECTED_ITEM_PREFIX_DPROP, ((List) getSource()).getSelectedItems());
        return result;
    }

    ////////////////////////////////////////////////////////
    //Mapping                                             //
    /**
     * Maps {@code List.addActionListener(ActionListener)} through queue
     */
    public void addActionListener(final ActionListener actionListener) {
        runMapping(new MapVoidAction("addActionListener") {
            @Override
            public void map() {
                ((List) getSource()).addActionListener(actionListener);
            }
        });
    }

    /**
     * Maps {@code List.addItemListener(ItemListener)} through queue
     */
    public void addItemListener(final ItemListener itemListener) {
        runMapping(new MapVoidAction("addItemListener") {
            @Override
            public void map() {
                ((List) getSource()).addItemListener(itemListener);
            }
        });
    }

    /**
     * Maps {@code List.deselect(int)} through queue
     */
    public void deselect(final int i) {
        runMapping(new MapVoidAction("deselect") {
            @Override
            public void map() {
                ((List) getSource()).deselect(i);
            }
        });
    }

    /**
     * Maps {@code List.getItem(int)} through queue
     */
    public String getItem(final int i) {
        return (runMapping(new MapAction<String>("getItem") {
            @Override
            public String map() {
                return ((List) getSource()).getItem(i);
            }
        }));
    }

    /**
     * Maps {@code List.getItemCount()} through queue
     */
    public int getItemCount() {
        return (runMapping(new MapIntegerAction("getItemCount") {
            @Override
            public int map() {
                return ((List) getSource()).getItemCount();
            }
        }));
    }

    /**
     * Maps {@code List.getItems()} through queue
     */
    public String[] getItems() {
        return ((String[]) runMapping(new MapAction<Object>("getItems") {
            @Override
            public Object map() {
                return ((List) getSource()).getItems();
            }
        }));
    }

    /**
     * Maps {@code List.getMinimumSize(int)} through queue
     */
    public Dimension getMinimumSize(final int i) {
        return (runMapping(new MapAction<Dimension>("getMinimumSize") {
            @Override
            public Dimension map() {
                return ((List) getSource()).getMinimumSize(i);
            }
        }));
    }

    /**
     * Maps {@code List.getPreferredSize(int)} through queue
     */
    public Dimension getPreferredSize(final int i) {
        return (runMapping(new MapAction<Dimension>("getPreferredSize") {
            @Override
            public Dimension map() {
                return ((List) getSource()).getPreferredSize(i);
            }
        }));
    }

    /**
     * Maps {@code List.getRows()} through queue
     */
    public int getRows() {
        return (runMapping(new MapIntegerAction("getRows") {
            @Override
            public int map() {
                return ((List) getSource()).getRows();
            }
        }));
    }

    /**
     * Maps {@code List.getSelectedIndex()} through queue
     */
    public int getSelectedIndex() {
        return (runMapping(new MapIntegerAction("getSelectedIndex") {
            @Override
            public int map() {
                return ((List) getSource()).getSelectedIndex();
            }
        }));
    }

    /**
     * Maps {@code List.getSelectedIndexes()} through queue
     */
    public int[] getSelectedIndexes() {
        return ((int[]) runMapping(new MapAction<Object>("getSelectedIndexes") {
            @Override
            public Object map() {
                return ((List) getSource()).getSelectedIndexes();
            }
        }));
    }

    /**
     * Maps {@code List.getSelectedItem()} through queue
     */
    public String getSelectedItem() {
        return (runMapping(new MapAction<String>("getSelectedItem") {
            @Override
            public String map() {
                return ((List) getSource()).getSelectedItem();
            }
        }));
    }

    /**
     * Maps {@code List.getSelectedItems()} through queue
     */
    public String[] getSelectedItems() {
        return ((String[]) runMapping(new MapAction<Object>("getSelectedItems") {
            @Override
            public Object map() {
                return ((List) getSource()).getSelectedItems();
            }
        }));
    }

    /**
     * Maps {@code List.getSelectedObjects()} through queue
     */
    public Object[] getSelectedObjects() {
        return ((Object[]) runMapping(new MapAction<Object>("getSelectedObjects") {
            @Override
            public Object map() {
                return ((List) getSource()).getSelectedObjects();
            }
        }));
    }

    /**
     * Maps {@code List.getVisibleIndex()} through queue
     */
    public int getVisibleIndex() {
        return (runMapping(new MapIntegerAction("getVisibleIndex") {
            @Override
            public int map() {
                return ((List) getSource()).getVisibleIndex();
            }
        }));
    }

    /**
     * Maps {@code List.isIndexSelected(int)} through queue
     */
    public boolean isIndexSelected(final int i) {
        return (runMapping(new MapBooleanAction("isIndexSelected") {
            @Override
            public boolean map() {
                return ((List) getSource()).isIndexSelected(i);
            }
        }));
    }

    /**
     * Maps {@code List.isMultipleMode()} through queue
     */
    public boolean isMultipleMode() {
        return (runMapping(new MapBooleanAction("isMultipleMode") {
            @Override
            public boolean map() {
                return ((List) getSource()).isMultipleMode();
            }
        }));
    }

    /**
     * Maps {@code List.makeVisible(int)} through queue
     */
    public void makeVisible(final int i) {
        runMapping(new MapVoidAction("makeVisible") {
            @Override
            public void map() {
                ((List) getSource()).makeVisible(i);
            }
        });
    }

    /**
     * Maps {@code List.remove(int)} through queue
     */
    public void remove(final int i) {
        runMapping(new MapVoidAction("remove") {
            @Override
            public void map() {
                ((List) getSource()).remove(i);
            }
        });
    }

    /**
     * Maps {@code List.remove(String)} through queue
     */
    public void remove(final String string) {
        runMapping(new MapVoidAction("remove") {
            @Override
            public void map() {
                ((List) getSource()).remove(string);
            }
        });
    }

    /**
     * Maps {@code List.removeActionListener(ActionListener)} through queue
     */
    public void removeActionListener(final ActionListener actionListener) {
        runMapping(new MapVoidAction("removeActionListener") {
            @Override
            public void map() {
                ((List) getSource()).removeActionListener(actionListener);
            }
        });
    }

    /**
     * Maps {@code List.removeAll()} through queue
     */
    public void removeAll() {
        runMapping(new MapVoidAction("removeAll") {
            @Override
            public void map() {
                ((List) getSource()).removeAll();
            }
        });
    }

    /**
     * Maps {@code List.removeItemListener(ItemListener)} through queue
     */
    public void removeItemListener(final ItemListener itemListener) {
        runMapping(new MapVoidAction("removeItemListener") {
            @Override
            public void map() {
                ((List) getSource()).removeItemListener(itemListener);
            }
        });
    }

    /**
     * Maps {@code List.replaceItem(String, int)} through queue
     */
    public void replaceItem(final String string, final int i) {
        runMapping(new MapVoidAction("replaceItem") {
            @Override
            public void map() {
                ((List) getSource()).replaceItem(string, i);
            }
        });
    }

    /**
     * Maps {@code List.select(int)} through queue
     */
    public void select(final int i) {
        runMapping(new MapVoidAction("select") {
            @Override
            public void map() {
                ((List) getSource()).select(i);
            }
        });
    }

    /**
     * Maps {@code List.setMultipleMode(boolean)} through queue
     */
    public void setMultipleMode(final boolean b) {
        runMapping(new MapVoidAction("setMultipleMode") {
            @Override
            public void map() {
                ((List) getSource()).setMultipleMode(b);
            }
        });
    }

    //End of mapping                                      //
    ////////////////////////////////////////////////////////
    /**
     * Allows to find component by item text.
     */
    public static class ListByItemFinder implements ComponentChooser {

        String label;
        int itemIndex;
        StringComparator comparator;

        /**
         * Constructs ListByItemFinder.
         *
         * @param lb a text pattern
         * @param ii item index to check. If equal to -1, selected item is
         * checked.
         * @param comparator specifies string comparision algorithm.
         */
        public ListByItemFinder(String lb, int ii, StringComparator comparator) {
            label = lb;
            itemIndex = ii;
            this.comparator = comparator;
        }

        /**
         * Constructs ListByItemFinder.
         *
         * @param lb a text pattern
         * @param ii item index to check. If equal to -1, selected item is
         * checked.
         */
        public ListByItemFinder(String lb, int ii) {
            this(lb, ii, Operator.getDefaultStringComparator());
        }

        @Override
        public boolean checkComponent(Component comp) {
            if (comp instanceof List) {
                if (label == null) {
                    return true;
                }
                if (((List) comp).getItemCount() > itemIndex) {
                    int ii = itemIndex;
                    if (ii == -1) {
                        ii = ((List) comp).getSelectedIndex();
                        if (ii == -1) {
                            return false;
                        }
                    }
                    return (comparator.equals(((List) comp).getItem(ii),
                            label));
                }
            }
            return false;
        }

        @Override
        public String getDescription() {
            return ("List with text \"" + label + "\" in "
                    + itemIndex + "'th item");
        }

        @Override
        public String toString() {
            return "ListByItemFinder{" + "label=" + label + ", itemIndex=" + itemIndex + ", comparator=" + comparator + '}';
        }
    }

    /**
     * Checks component type.
     */
    public static class ListFinder extends Finder {

        /**
         * Constructs ListFinder.
         *
         * @param sf other searching criteria.
         */
        public ListFinder(ComponentChooser sf) {
            super(List.class, sf);
        }

        /**
         * Constructs ListFinder.
         */
        public ListFinder() {
            super(List.class);
        }
    }
}