/*******************************************************************************
 * Copyright (c) 2014, 2023 Dirk Fauth and others.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Dirk Fauth <dirk.fauth@googlemail.com> - initial API and implementation
 ******************************************************************************/
package org.eclipse.nebula.widgets.nattable.extension.glazedlists.groupby;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;

import org.eclipse.nebula.widgets.nattable.config.ConfigRegistry;
import org.eclipse.nebula.widgets.nattable.config.DefaultComparator;
import org.eclipse.nebula.widgets.nattable.data.IColumnPropertyAccessor;
import org.eclipse.nebula.widgets.nattable.data.IDataProvider;
import org.eclipse.nebula.widgets.nattable.data.ReflectiveColumnPropertyAccessor;
import org.eclipse.nebula.widgets.nattable.data.convert.DefaultDisplayConverter;
import org.eclipse.nebula.widgets.nattable.dataset.person.Person;
import org.eclipse.nebula.widgets.nattable.dataset.person.PersonService;
import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsSortModel;
import org.eclipse.nebula.widgets.nattable.extension.glazedlists.filterrow.DefaultGlazedListsFilterStrategy;
import org.eclipse.nebula.widgets.nattable.extension.glazedlists.groupBy.GroupByComparator;
import org.eclipse.nebula.widgets.nattable.extension.glazedlists.groupBy.GroupByConfigAttributes;
import org.eclipse.nebula.widgets.nattable.extension.glazedlists.groupBy.GroupByDataLayer;
import org.eclipse.nebula.widgets.nattable.extension.glazedlists.groupBy.GroupByModel;
import org.eclipse.nebula.widgets.nattable.extension.glazedlists.groupBy.GroupByObject;
import org.eclipse.nebula.widgets.nattable.extension.glazedlists.groupBy.summary.SummationGroupBySummaryProvider;
import org.eclipse.nebula.widgets.nattable.filterrow.FilterRowDataProvider;
import org.eclipse.nebula.widgets.nattable.filterrow.TextMatchingMode;
import org.eclipse.nebula.widgets.nattable.filterrow.config.FilterRowConfigAttributes;
import org.eclipse.nebula.widgets.nattable.grid.data.DefaultColumnHeaderDataProvider;
import org.eclipse.nebula.widgets.nattable.grid.layer.DefaultColumnHeaderDataLayer;
import org.eclipse.nebula.widgets.nattable.layer.DataLayer;
import org.eclipse.nebula.widgets.nattable.layer.LabelStack;
import org.eclipse.nebula.widgets.nattable.layer.cell.AggregateConfigLabelAccumulator;
import org.eclipse.nebula.widgets.nattable.layer.cell.ColumnLabelAccumulator;
import org.eclipse.nebula.widgets.nattable.layer.cell.IConfigLabelAccumulator;
import org.eclipse.nebula.widgets.nattable.sort.ISortModel;
import org.eclipse.nebula.widgets.nattable.sort.SortConfigAttributes;
import org.eclipse.nebula.widgets.nattable.sort.SortDirectionEnum;
import org.eclipse.nebula.widgets.nattable.style.DisplayMode;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import ca.odell.glazedlists.EventList;
import ca.odell.glazedlists.FilterList;
import ca.odell.glazedlists.GlazedLists;
import ca.odell.glazedlists.SortedList;
import ca.odell.glazedlists.event.ListEvent;
import ca.odell.glazedlists.event.ListEventListener;

public class GroupByDataLayerTest {

    ConfigRegistry configRegistry = new ConfigRegistry();

    GroupByModel groupByModel = new GroupByModel();
    GroupByDataLayer<Person> dataLayer;

    IColumnPropertyAccessor<Person> columnPropertyAccessor;

    SortedList<Person> sortedList;
    ISortModel sortModel;

    FilterList<Person> filterList;
    FilterRowDataProvider<Person> filterRowDataProvider;

    static final String MY_LABEL = "myLabel";

    // property names of the Person class
    String[] propertyNames = { "firstName", "lastName", "money", "gender", "married", "birthday" };

    @BeforeEach
    public void setup() {
        this.groupByModel = new GroupByModel();
        EventList<Person> eventList = GlazedLists.eventList(PersonService.getFixedPersons());
        this.sortedList = new SortedList<>(eventList, null);
        this.filterList = new FilterList<>(this.sortedList);

        this.columnPropertyAccessor = new ReflectiveColumnPropertyAccessor<>(this.propertyNames);

        this.dataLayer = new GroupByDataLayer<>(this.groupByModel, this.filterList, this.columnPropertyAccessor, this.configRegistry);
        this.dataLayer.setConfigLabelAccumulator(new ColumnLabelAccumulator());
    }

    void addSummaryConfiguration() {
        this.configRegistry.registerConfigAttribute(
                GroupByConfigAttributes.GROUP_BY_SUMMARY_PROVIDER,
                new SummationGroupBySummaryProvider<>(GroupByDataLayerTest.this.columnPropertyAccessor),
                DisplayMode.NORMAL,
                GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + 2);

        this.configRegistry.registerConfigAttribute(
                GroupByConfigAttributes.GROUP_BY_CHILD_COUNT_PATTERN,
                "[{0}] - ({1})");
    }

    void addConditionalStyling() {
        IConfigLabelAccumulator conditional = new IConfigLabelAccumulator() {

            @Override
            public void accumulateConfigLabels(LabelStack configLabels, int columnPosition, int rowPosition) {
                if (columnPosition == 2 && configLabels.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT)) {
                    Double value = (Double) GroupByDataLayerTest.this.dataLayer.getDataValueByPosition(
                            columnPosition, rowPosition, configLabels, false);
                    if (value > 800d) {
                        configLabels.addLabelOnTop(MY_LABEL);
                    }
                }
            }
        };

        AggregateConfigLabelAccumulator aggregate = new AggregateConfigLabelAccumulator();
        aggregate.add(new ColumnLabelAccumulator());
        aggregate.add(conditional);

        this.dataLayer.setConfigLabelAccumulator(aggregate);
    }

    void addSortingCapability() {
        this.dataLayer.setComparator(new GroupByComparator<Person>(this.groupByModel, this.columnPropertyAccessor) {
            @Override
            protected boolean isTreeColumn(int columnIndex) {
                // since we don't have a TreeLayer in the test setup, we specify
                // that column index 0 is the tree column
                return columnIndex == 0;
            }
        });

        // the ColumnHeaderDataLayer is needed to retrieve the comparator per
        // column
        IDataProvider columnHeaderDataProvider =
                new DefaultColumnHeaderDataProvider(this.propertyNames);
        DataLayer columnHeaderDataLayer =
                new DefaultColumnHeaderDataLayer(columnHeaderDataProvider);
        columnHeaderDataLayer.setConfigLabelAccumulator(new ColumnLabelAccumulator());
        this.sortModel = new GlazedListsSortModel<>(
                this.sortedList,
                this.columnPropertyAccessor,
                this.configRegistry,
                columnHeaderDataLayer);
        this.dataLayer.initializeTreeComparator(this.sortModel, null, true);

        this.configRegistry.registerConfigAttribute(
                SortConfigAttributes.SORT_COMPARATOR,
                DefaultComparator.getInstance());
    }

    void addFilterCapability() {
        IDataProvider columnHeaderDataProvider =
                new DefaultColumnHeaderDataProvider(this.propertyNames);
        DataLayer columnHeaderDataLayer =
                new DefaultColumnHeaderDataLayer(columnHeaderDataProvider);

        this.filterRowDataProvider = new FilterRowDataProvider<>(
                new DefaultGlazedListsFilterStrategy<>(
                        this.filterList,
                        this.columnPropertyAccessor,
                        this.configRegistry),
                columnHeaderDataLayer,
                columnHeaderDataProvider,
                this.configRegistry);

        this.configRegistry.registerConfigAttribute(
                FilterRowConfigAttributes.FILTER_DISPLAY_CONVERTER,
                new DefaultDisplayConverter());
        this.configRegistry.registerConfigAttribute(
                FilterRowConfigAttributes.TEXT_MATCHING_MODE,
                TextMatchingMode.CONTAINS);

        this.dataLayer.enableFilterSupport(this.filterRowDataProvider);
    }

    @Test
    public void testOneLevelGrouping() {
        assertEquals(18, this.dataLayer.getRowCount());

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);
        // 18 data rows + 2 GroupBy rows
        assertEquals(20, this.dataLayer.getRowCount());

        Object o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        o = this.dataLayer.getTreeList().get(9);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
    }

    @Test
    public void testGetElementsInGroupWithNullValue() {
        // Test with another list with null values
        this.sortedList.clear();
        this.sortedList.addAll(PersonService.getFixedPersonsWithNull());

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);

        // collect GroupBy Objects
        List<GroupByObject> groupByObjects = new ArrayList<>();
        for (Object o : this.dataLayer.getTreeList()) {
            if (o instanceof GroupByObject) {
                groupByObjects.add((GroupByObject) o);
            }
        }

        // test with getElementsInGroup() class GroupDescriptorMatcher.
        // testing like this, cause setup would be complex
        for (GroupByObject o : groupByObjects) {
            this.dataLayer.getItemsInGroup(o);
        }

        // if we get here, there is no NullPointerException in
        // GroupDescriptorMatcher.

    }

    @Test
    public void testTwoLevelGrouping() {
        assertEquals(18, this.dataLayer.getRowCount());

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);
        this.groupByModel.addGroupByColumnIndex(0);

        // 18 data rows + 2 GroupBy rows lastname + 8 data rows firstname
        assertEquals(28, this.dataLayer.getRowCount());

        // Flanders
        Object o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());

        o = this.dataLayer.getTreeList().get(1);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Maude", ((GroupByObject) o).getValue());

        o = this.dataLayer.getTreeList().get(4);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Ned", ((GroupByObject) o).getValue());

        o = this.dataLayer.getTreeList().get(7);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Rodd", ((GroupByObject) o).getValue());

        o = this.dataLayer.getTreeList().get(10);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Todd", ((GroupByObject) o).getValue());

        // Simpsons
        o = this.dataLayer.getTreeList().get(13);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());

        o = this.dataLayer.getTreeList().get(14);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Bart", ((GroupByObject) o).getValue());

        o = this.dataLayer.getTreeList().get(18);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Homer", ((GroupByObject) o).getValue());

        o = this.dataLayer.getTreeList().get(22);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Lisa", ((GroupByObject) o).getValue());

        o = this.dataLayer.getTreeList().get(25);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Marge", ((GroupByObject) o).getValue());
    }

    @Test
    public void testConfigLabelsWithoutGrouping() {
        // there should be never a groupBy label or groupBySummary label
        for (int row = 0; row < this.dataLayer.getRowCount(); row++) {
            for (int column = 0; column < this.dataLayer.getColumnCount(); column++) {
                LabelStack stack = this.dataLayer.getConfigLabelsByPosition(column, row);
                assertTrue(stack.hasLabel(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column), "column label not found");
                assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT), "groupBy object label found");
                assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column), "groupBy column label found");
                assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY), "groupBy summary label found");
                assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column), "groupBy summary column label found");
            }
        }
    }

    @Test
    public void testConfigLabelsWithGrouping() {
        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);

        for (int row = 0; row < this.dataLayer.getRowCount(); row++) {
            for (int column = 0; column < this.dataLayer.getColumnCount(); column++) {
                LabelStack stack = this.dataLayer.getConfigLabelsByPosition(column, row);
                assertTrue(stack.hasLabel(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column), "column label not found");

                if (row == 0 || row == 9) {
                    // row 0 is groupBy for flanders, row 9 groupBy for simpsons
                    // there should be groupBy labels but no groupBySummary
                    // labels
                    assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT), "groupBy object label not found");
                    assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column), "groupBy column label not found");

                    // respect the label order
                    assertEquals(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column, stack.get(0));
                    assertEquals(GroupByDataLayer.GROUP_BY_OBJECT, stack.get(1));
                    assertEquals(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column, stack.get(2));
                } else {
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT), "groupBy object label found");
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column), "groupBy column label found");
                }

                assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY), "groupBy summary label found");
                assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column), "groupBy summary column label found");
            }
        }
    }

    @Test
    public void testConfigLabelsWithGroupingAndSummary() {
        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);

        // add summary configuration
        addSummaryConfiguration();

        for (int row = 0; row < this.dataLayer.getRowCount(); row++) {
            for (int column = 0; column < this.dataLayer.getColumnCount(); column++) {
                LabelStack stack = this.dataLayer.getConfigLabelsByPosition(column, row);
                assertTrue(stack.hasLabel(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column), "column label not found");

                if (row == 0 || row == 9) {
                    // row 0 is groupBy for flanders, row 9 groupBy for simpsons
                    assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT), "groupBy object label not found");
                    assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column), "groupBy column label not found");

                    if (column == 2) {
                        assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY), "groupBy summary label not found");
                        assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column), "groupBy summary column label not found");

                        // respect the label order
                        assertEquals(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column, stack.get(0));
                        assertEquals(GroupByDataLayer.GROUP_BY_SUMMARY, stack.get(1));
                        assertEquals(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column, stack.get(2));
                        assertEquals(GroupByDataLayer.GROUP_BY_OBJECT, stack.get(3));
                        assertEquals(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column, stack.get(4));
                    } else {
                        assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY), "groupBy summary label found");
                        assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column), "groupBy summary column label found");

                        // respect the label order
                        assertEquals(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column, stack.get(0));
                        assertEquals(GroupByDataLayer.GROUP_BY_OBJECT, stack.get(1));
                        assertEquals(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column, stack.get(2));
                    }
                } else {
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT), "groupBy object label found");
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column), "groupBy column label found");
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY), "groupBy summary label found");
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column), "groupBy summary column label found");
                }
            }
        }
    }

    @Test
    public void testConfigLabelsWithGroupingAndSummaryWithConditional() {
        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);

        // add summary configuration
        addSummaryConfiguration();

        // add conditional styling labels
        addConditionalStyling();

        for (int row = 0; row < this.dataLayer.getRowCount(); row++) {
            for (int column = 0; column < this.dataLayer.getColumnCount(); column++) {
                LabelStack stack = this.dataLayer.getConfigLabelsByPosition(column, row);
                assertTrue(stack.hasLabel(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column), "column label not found");

                if (row == 0 || row == 9) {
                    // row 0 is groupBy for flanders, row 9 groupBy for simpsons
                    assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT), "groupBy object label not found");
                    assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column), "groupBy column label not found");

                    if (column == 2) {
                        assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY), "groupBy summary label not found");
                        assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column), "groupBy summary column label not found");

                        // simpsons are more than flanders, so only simpsons
                        // should have conditional formatting
                        if (row == 9) {
                            // respect the label order
                            assertEquals(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column, stack.get(0));
                            assertEquals(GroupByDataLayer.GROUP_BY_SUMMARY, stack.get(1));
                            assertEquals(MY_LABEL, stack.get(2));
                            assertEquals(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column, stack.get(3));
                            assertEquals(GroupByDataLayer.GROUP_BY_OBJECT, stack.get(4));
                            assertEquals(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column, stack.get(5));
                        } else {
                            // respect the label order
                            assertEquals(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column, stack.get(0));
                            assertEquals(GroupByDataLayer.GROUP_BY_SUMMARY, stack.get(1));
                            assertEquals(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column, stack.get(2));
                            assertEquals(GroupByDataLayer.GROUP_BY_OBJECT, stack.get(3));
                            assertEquals(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column, stack.get(4));
                        }
                    } else {
                        assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY), "groupBy summary label found");
                        assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column), "groupBy summary column label found");

                        // respect the label order
                        assertEquals(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column, stack.get(0));
                        assertEquals(GroupByDataLayer.GROUP_BY_OBJECT, stack.get(1));
                        assertEquals(ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + column, stack.get(2));
                    }
                } else {
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT), "groupBy object label found");
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + column), "groupBy column label found");
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY), "groupBy summary label found");
                    assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + column), "groupBy summary column label found");
                }
            }
        }
    }

    @Test
    public void testOneLevelGroupSortTree() {
        addSortingCapability();

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);
        // 18 data rows + 2 GroupBy rows
        assertEquals(20, this.dataLayer.getRowCount());

        Object o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        o = this.dataLayer.getTreeList().get(9);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        // unsorted leafs, first leaf in Simpson is Homer
        o = this.dataLayer.getTreeList().get(10);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Homer", ((Person) o).getFirstName());

        // sort ascending
        this.sortModel.sort(0, SortDirectionEnum.ASC, false);

        o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        o = this.dataLayer.getTreeList().get(9);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        // ascending sorted leafs, first leaf in Simpson is Bart
        o = this.dataLayer.getTreeList().get(10);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Bart", ((Person) o).getFirstName());

        // sort descending
        this.sortModel.sort(0, SortDirectionEnum.DESC, false);

        o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        o = this.dataLayer.getTreeList().get(11);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        // descending sorted leafs, first leaf in Flanders is Todd
        o = this.dataLayer.getTreeList().get(12);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Todd", ((Person) o).getFirstName());
    }

    @Test
    public void testOneLevelGroupSortOther() {
        addSortingCapability();

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);
        // 18 data rows + 2 GroupBy rows
        assertEquals(20, this.dataLayer.getRowCount());

        Object o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        o = this.dataLayer.getTreeList().get(9);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());

        // unsorted leafs, Maude is on position 3 within Flanders
        o = this.dataLayer.getTreeList().get(3);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Maude", ((Person) o).getFirstName());

        // sort ascending by gender
        this.sortModel.sort(3, SortDirectionEnum.ASC, false);

        o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        o = this.dataLayer.getTreeList().get(9);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());

        // ascending sorted leafs, Maude should be on last position within
        // Flanders
        o = this.dataLayer.getTreeList().get(8);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Maude", ((Person) o).getFirstName());

        // sort descending by gender
        this.sortModel.sort(3, SortDirectionEnum.DESC, false);

        // no changes to tree
        o = this.dataLayer.getTreeList().get(0);
        o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        o = this.dataLayer.getTreeList().get(9);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());

        // descending sorted leafs, Maude should be on first position within
        // Flanders
        o = this.dataLayer.getTreeList().get(1);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Maude", ((Person) o).getFirstName());
    }

    @Test
    public void testOneLevelGroupSortSummary() {
        addSortingCapability();
        addSummaryConfiguration();

        // increase the money amount for all flanders to show that the sort
        // order is related to the summary value and not the groupBy value
        double value = 600.0d;
        for (int i = 10; i < this.sortedList.size(); i++) {
            if ((i - 10) % 2 == 0) {
                value -= 100.0d;
            }
            this.sortedList.get(i).setMoney(value);
        }

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);
        // 18 data rows + 2 GroupBy rows
        assertEquals(20, this.dataLayer.getRowCount());

        Object o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        LabelStack labelStack = this.dataLayer.getConfigLabelsByPosition(2, 0);
        assertEquals(2800.0d, this.dataLayer.getDataValueByPosition(2, 0, labelStack, false));

        o = this.dataLayer.getTreeList().get(1);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Ned", ((Person) o).getFirstName());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, 1);
        assertEquals(500.0d, this.dataLayer.getDataValueByPosition(2, 1, labelStack, false));

        o = this.dataLayer.getTreeList().get(9);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, 9);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, 9, labelStack, false));

        // sort ascending by money
        this.sortModel.sort(2, SortDirectionEnum.ASC, false);

        o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, 0);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, 0, labelStack, false));

        o = this.dataLayer.getTreeList().get(11);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, 11);
        assertEquals(2800.0d, this.dataLayer.getDataValueByPosition(2, 11, labelStack, false));

        o = this.dataLayer.getTreeList().get(12);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Todd", ((Person) o).getFirstName());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, 1);
        assertEquals(100.0d, this.dataLayer.getDataValueByPosition(2, 1, labelStack, false));

        // sort descending by money
        this.sortModel.sort(2, SortDirectionEnum.DESC, false);

        o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, 0);
        assertEquals(2800.0d, this.dataLayer.getDataValueByPosition(2, 0, labelStack, false));

        o = this.dataLayer.getTreeList().get(9);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, 9);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, 9, labelStack, false));

        o = this.dataLayer.getTreeList().get(1);
        assertTrue(o instanceof Person, "Object is not a Person");
        assertEquals("Ned", ((Person) o).getFirstName());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, 1);
        assertEquals(500.0d, this.dataLayer.getDataValueByPosition(2, 1, labelStack, false));
    }

    @Test
    public void testTwoLevelGroupSortSummary() {
        addSortingCapability();
        addSummaryConfiguration();

        // increase the money amount for all flanders to show that the sort
        // order is related to the summary value and not the groupBy value
        double value = 600.0d;
        for (int i = 10; i < this.sortedList.size(); i++) {
            if ((i - 10) % 2 == 0) {
                value -= 100.0d;
            }
            this.sortedList.get(i).setMoney(value);
        }

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);
        // groupBy firstname
        this.groupByModel.addGroupByColumnIndex(0);
        // 18 data rows + 2 GroupBy rows lastname + 8 data rows firstname
        assertEquals(28, this.dataLayer.getRowCount());

        // Flanders
        int row = 0;
        Object o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        LabelStack labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(2800.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 1;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Maude", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(800.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 4;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Ned", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 7;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Rodd", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(600.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 10;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Todd", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(400.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        // Simpsons
        row = 13;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 14;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Bart", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(300.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 18;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Homer", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(300.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 22;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Lisa", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(200.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 25;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Marge", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(200.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        // sort ascending by money
        this.sortModel.sort(2, SortDirectionEnum.ASC, false);

        // Simpsons
        row = 0;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 1;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Lisa", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(200.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 4;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Marge", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(200.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 7;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Bart", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(300.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 11;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Homer", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(300.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        // Flanders
        row = 15;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(2800.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 16;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Todd", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(400.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 19;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Rodd", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(600.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 22;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Maude", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(800.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 25;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Ned", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        // sort descending by money
        this.sortModel.sort(2, SortDirectionEnum.DESC, false);

        // Flanders
        row = 0;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Flanders", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(2800.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 1;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Ned", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 4;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Maude", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(800.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 7;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Rodd", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(600.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 10;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Todd", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(400.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        // Simpsons
        row = 13;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(1000.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 14;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Homer", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(300.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 18;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Bart", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(300.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 22;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Marge", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(200.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));

        row = 25;
        o = this.dataLayer.getTreeList().get(row);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Lisa", ((GroupByObject) o).getValue());
        labelStack = this.dataLayer.getConfigLabelsByPosition(2, row);
        assertEquals(200.0d, this.dataLayer.getDataValueByPosition(2, row, labelStack, false));
    }

    @Test
    public void testTwoLevelGroupWithCustomComparator() {
        addSortingCapability();

        this.configRegistry.registerConfigAttribute(
                SortConfigAttributes.SORT_COMPARATOR,
                new Comparator<Double>() {

                    @Override
                    public int compare(Double o1, Double o2) {
                        return o2.compareTo(o1);
                    }

                },
                DisplayMode.NORMAL,
                ColumnLabelAccumulator.COLUMN_LABEL_PREFIX + 2);

        // groupBy money
        this.groupByModel.addGroupByColumnIndex(2);
        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);

        // if we get here, there is no class cast exception as reported in
        // Bug 459422

    }

    @Test
    public void testKeepSortOnGrouping() {
        addSortingCapability();

        // sort by lastname descending
        this.sortModel.sort(1, SortDirectionEnum.DESC, false);

        // 10 Simpsons, 8 Flanders
        assertEquals(18, this.dataLayer.getRowCount());
        for (int i = 0; i < this.dataLayer.getRowCount(); i++) {
            if (i < 10) {
                assertEquals("Simpson", this.dataLayer.getDataValue(1, i));
            } else {
                assertEquals("Flanders", this.dataLayer.getDataValue(1, i));
            }
        }

        // groupby firstname
        this.groupByModel.addGroupByColumnIndex(0);

        // 10 Simpsons, 8 Flanders, 8 GroupByObjects for firstnames
        assertEquals(26, this.dataLayer.getRowCount());

        Object o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Bart", ((GroupByObject) o).getValue());
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 1));
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 2));
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 3));

        o = this.dataLayer.getTreeList().get(4);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Homer", ((GroupByObject) o).getValue());
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 5));
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 6));
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 7));

        o = this.dataLayer.getTreeList().get(8);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Lisa", ((GroupByObject) o).getValue());
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 9));
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 10));

        o = this.dataLayer.getTreeList().get(11);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Marge", ((GroupByObject) o).getValue());
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 12));
        assertEquals("Simpson", this.dataLayer.getDataValue(1, 13));

        o = this.dataLayer.getTreeList().get(14);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Maude", ((GroupByObject) o).getValue());
        assertEquals("Flanders", this.dataLayer.getDataValue(1, 15));
        assertEquals("Flanders", this.dataLayer.getDataValue(1, 16));

        o = this.dataLayer.getTreeList().get(17);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Ned", ((GroupByObject) o).getValue());
        assertEquals("Flanders", this.dataLayer.getDataValue(1, 18));
        assertEquals("Flanders", this.dataLayer.getDataValue(1, 19));

        o = this.dataLayer.getTreeList().get(20);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Rodd", ((GroupByObject) o).getValue());
        assertEquals("Flanders", this.dataLayer.getDataValue(1, 21));
        assertEquals("Flanders", this.dataLayer.getDataValue(1, 22));

        o = this.dataLayer.getTreeList().get(23);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Todd", ((GroupByObject) o).getValue());
        assertEquals("Flanders", this.dataLayer.getDataValue(1, 24));
        assertEquals("Flanders", this.dataLayer.getDataValue(1, 25));
    }

    @Test
    public void testProvidedLabels() {
        Collection<String> labels = this.dataLayer.getProvidedLabels();
        assertEquals(14, labels.size());

        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_OBJECT));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + 0));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + 1));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + 2));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + 3));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + 4));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_COLUMN_PREFIX + 5));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_SUMMARY));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + 0));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + 1));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + 2));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + 3));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + 4));
        assertTrue(labels.contains(GroupByDataLayer.GROUP_BY_SUMMARY_COLUMN_PREFIX + 5));
    }

    @Test
    public void testGroupByItemCount() {
        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);

        GroupByObject flanders = (GroupByObject) this.dataLayer.getTreeList().get(0);
        assertEquals("Flanders", flanders.getValue());
        GroupByObject simpsons = (GroupByObject) this.dataLayer.getTreeList().get(9);
        assertEquals("Simpson", simpsons.getValue());

        List<Person> itemsInGroup = this.dataLayer.getItemsInGroup(flanders);
        List<Object> rowModelChildren = this.dataLayer.getTreeRowModel().getChildren(0);
        assertEquals(8, itemsInGroup.size());
        assertEquals(8, rowModelChildren.size());
        assertEquals(itemsInGroup, rowModelChildren);

        itemsInGroup = this.dataLayer.getItemsInGroup(simpsons);
        rowModelChildren = this.dataLayer.getTreeRowModel().getChildren(9);
        assertEquals(10, itemsInGroup.size());
        assertEquals(10, rowModelChildren.size());
        assertEquals(itemsInGroup, rowModelChildren);
    }

    @Test
    public void testGroupByItemCountAfterListChange() {
        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);

        GroupByObject flanders = (GroupByObject) this.dataLayer.getTreeList().get(0);
        assertEquals("Flanders", flanders.getValue());
        GroupByObject simpsons = (GroupByObject) this.dataLayer.getTreeList().get(9);
        assertEquals("Simpson", simpsons.getValue());

        List<Person> itemsInGroup = this.dataLayer.getItemsInGroup(flanders);
        List<Object> rowModelChildren = this.dataLayer.getTreeRowModel().getChildren(0);
        assertEquals(8, itemsInGroup.size());
        assertEquals(8, rowModelChildren.size());
        assertEquals(itemsInGroup, rowModelChildren);

        this.sortedList.addListEventListener(new ListEventListener<Person>() {

            @Override
            public void listChanged(ListEvent<Person> listChanges) {
                GroupByDataLayerTest.this.dataLayer.clearCache();
            }
        });

        // add new Flanders
        Person p = PersonService.createPersonWithAddress(4711);
        p.setLastName("Flanders");

        this.sortedList.add(p);

        itemsInGroup = this.dataLayer.getItemsInGroup(flanders);
        rowModelChildren = this.dataLayer.getTreeRowModel().getChildren(0);
        assertEquals(9, itemsInGroup.size());
        assertEquals(9, rowModelChildren.size());
        assertEquals(itemsInGroup, rowModelChildren);
    }

    @Test
    public void testRetainCollapsedStateOnGrouping() {
        assertEquals(18, this.dataLayer.getRowCount());

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);
        // 18 data rows + 2 GroupBy rows
        assertEquals(20, this.dataLayer.getRowCount());

        // collapse Flanders
        this.dataLayer.getTreeRowModel().collapse(0);

        // 18 data rows + 2 GroupBy rows - 8 flanders data rows collapsed
        assertEquals(12, this.dataLayer.getRowCount());

        // groupBy firstname
        this.groupByModel.addGroupByColumnIndex(0);

        // 18 data rows + 2 GroupBy rows lastname + 8 data rows firstname
        // - 12 because Flanders is collapsed
        assertEquals(16, this.dataLayer.getRowCount());
    }

    @Test
    public void testClearCollapsedStateOnReGrouping() {
        assertEquals(18, this.dataLayer.getRowCount());

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);
        // groupBy firstname
        this.groupByModel.addGroupByColumnIndex(0);

        // 18 data rows + 2 GroupBy rows lastname + 8 GroupBy rows firstname
        assertEquals(28, this.dataLayer.getRowCount());

        // collapse all Flanders sub-nodes
        this.dataLayer.getTreeRowModel().collapse(10);
        this.dataLayer.getTreeRowModel().collapse(7);
        this.dataLayer.getTreeRowModel().collapse(4);
        this.dataLayer.getTreeRowModel().collapse(1);

        // 18 data rows + 2 GroupBy rows lastname + 8 GroupBy rows firstname - 8
        // flanders data rows collapsed
        assertEquals(20, this.dataLayer.getRowCount());

        // ungroup firstname
        this.groupByModel.removeGroupByColumnIndex(0);

        // 18 data rows + 2 GroupBy rows
        assertEquals(20, this.dataLayer.getRowCount());

        // re-group firstname - new firstname groups start expanded
        this.groupByModel.addGroupByColumnIndex(0);
        assertEquals(28, this.dataLayer.getRowCount());
    }

    @Test
    public void shouldKeepInitialOrderOnFilteredGrouping() {
        addFilterCapability();

        assertEquals(18, this.dataLayer.getRowCount());
        assertEquals("Homer", this.dataLayer.getDataValue(0, 0));

        // apply a filter
        this.filterRowDataProvider.setDataValue(0, 0, "Homer");
        assertEquals(3, this.dataLayer.getRowCount());

        // group by last name
        this.groupByModel.addGroupByColumnIndex(1);

        assertEquals(4, this.dataLayer.getRowCount());
        Object o = this.dataLayer.getTreeList().get(0);
        assertTrue(o instanceof GroupByObject, "Object is not a GroupByObject");
        assertEquals("Simpson", ((GroupByObject) o).getValue());

        // ungroup lastname
        this.groupByModel.removeGroupByColumnIndex(1);
        assertEquals(3, this.dataLayer.getRowCount());

        // remove the filter
        this.filterRowDataProvider.setDataValue(0, 0, null);
        assertEquals(18, this.dataLayer.getRowCount());

        // Homer should be still at the first position
        // without setting the FilterRowDataProvider to the GroupByDataLayer,
        // this will fail
        assertEquals("Homer", this.dataLayer.getDataValue(0, 0));
    }

    @Test
    public void shouldGetCustomConfigLabelsByRowIndex() {
        // add a config label accumulator that uses the row index
        this.dataLayer.setConfigLabelAccumulator((configLabels, columnPosition, rowPosition) -> configLabels.add("ROW_" + rowPosition));

        // groupBy lastname
        this.groupByModel.addGroupByColumnIndex(1);

        LabelStack stack = this.dataLayer.getConfigLabelsByPosition(0, 0);
        assertTrue(stack.hasLabel("ROW_0"));
        assertTrue(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT));

        stack = this.dataLayer.getConfigLabelsByPosition(0, 1);
        assertTrue(stack.hasLabel("ROW_1"));
        assertFalse(stack.hasLabel(GroupByDataLayer.GROUP_BY_OBJECT));
    }
}