| /******************************************************************************* |
| * Copyright (c) 2018, 2020 Dirk Fauth. |
| * |
| * 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.test.integration; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import java.io.Serializable; |
| import java.util.Comparator; |
| import java.util.Date; |
| import java.util.List; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| import org.eclipse.nebula.widgets.nattable.command.DisposeResourcesCommand; |
| import org.eclipse.nebula.widgets.nattable.data.IColumnPropertyAccessor; |
| import org.eclipse.nebula.widgets.nattable.data.IRowDataProvider; |
| import org.eclipse.nebula.widgets.nattable.data.IRowIdAccessor; |
| import org.eclipse.nebula.widgets.nattable.data.ListDataProvider; |
| import org.eclipse.nebula.widgets.nattable.data.ReflectiveColumnPropertyAccessor; |
| import org.eclipse.nebula.widgets.nattable.data.command.RowDeleteCommandHandler; |
| import org.eclipse.nebula.widgets.nattable.data.command.RowInsertCommand; |
| import org.eclipse.nebula.widgets.nattable.data.command.RowObjectDeleteCommandHandler; |
| import org.eclipse.nebula.widgets.nattable.datachange.DataChangeHandler; |
| import org.eclipse.nebula.widgets.nattable.datachange.DataChangeLayer; |
| import org.eclipse.nebula.widgets.nattable.datachange.IdIndexIdentifier; |
| import org.eclipse.nebula.widgets.nattable.datachange.IdIndexKeyHandler; |
| import org.eclipse.nebula.widgets.nattable.datachange.RowDeleteDataChangeHandler; |
| import org.eclipse.nebula.widgets.nattable.datachange.RowInsertDataChangeHandler; |
| import org.eclipse.nebula.widgets.nattable.datachange.command.DiscardDataChangesCommand; |
| import org.eclipse.nebula.widgets.nattable.datachange.command.KeyRowInsertCommandHandler; |
| import org.eclipse.nebula.widgets.nattable.dataset.person.Person; |
| import org.eclipse.nebula.widgets.nattable.dataset.person.Person.Gender; |
| import org.eclipse.nebula.widgets.nattable.dataset.person.PersonService; |
| import org.eclipse.nebula.widgets.nattable.edit.command.UpdateDataCommand; |
| import org.eclipse.nebula.widgets.nattable.extension.glazedlists.GlazedListsEventLayer; |
| import org.eclipse.nebula.widgets.nattable.layer.DataLayer; |
| import org.eclipse.nebula.widgets.nattable.layer.ILayerListener; |
| import org.eclipse.nebula.widgets.nattable.layer.event.ILayerEvent; |
| import org.eclipse.nebula.widgets.nattable.layer.event.RowStructuralRefreshEvent; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.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.matchers.Matcher; |
| |
| @SuppressWarnings("unchecked") |
| public class RowStructuralDataChangeLayerIntegrationTest { |
| |
| private List<Person> dataModel; |
| private EventList<Person> eventList; |
| private SortedList<Person> sortedList; |
| private FilterList<Person> filterList; |
| private IRowDataProvider<Person> dataProvider; |
| private DataLayer dataLayer; |
| private DataChangeLayer dataChangeLayer; |
| private RowInsertDataChangeHandler insertHandler; |
| private RowDeleteDataChangeHandler deleteHandler; |
| |
| private CountDownLatch lock = new CountDownLatch(1); |
| |
| @Before |
| public void setup() { |
| this.dataModel = PersonService.getFixedPersons(); |
| this.eventList = GlazedLists.eventList(this.dataModel); |
| this.sortedList = new SortedList<>(this.eventList, null); |
| this.filterList = new FilterList<>(this.sortedList); |
| |
| IColumnPropertyAccessor<Person> columnPropertyAccessor = new ReflectiveColumnPropertyAccessor<>(new String[] { |
| "firstName", |
| "lastName", |
| "gender", |
| "married", |
| "birthday" }); |
| |
| IRowIdAccessor<Person> rowIdAccessor = new IRowIdAccessor<Person>() { |
| |
| @Override |
| public Serializable getRowId(Person rowObject) { |
| return rowObject.getId(); |
| } |
| }; |
| |
| this.dataProvider = new ListDataProvider<>( |
| this.filterList, |
| columnPropertyAccessor); |
| this.dataLayer = new DataLayer(this.dataProvider); |
| |
| // register the RowDeleteCommandHandler for delete operations by |
| // index, e.g. used for reverting row insert operations |
| this.dataLayer.registerCommandHandler(new RowDeleteCommandHandler<>(this.eventList)); |
| // register the RowObjectDeleteCommandHandler for delete operations |
| // by object, e.g. delete by UI interaction |
| this.dataLayer.registerCommandHandler(new RowObjectDeleteCommandHandler<>(this.eventList)); |
| // register the KeyRowInsertCommandHandler to be able to revert key |
| // insert operations by firing KeyRowInsertEvents |
| // uses an IdIndexKeyHandler with an alternative ListDataProvider on the |
| // base list in order to be able to discard the change on the base list |
| this.dataLayer.registerCommandHandler( |
| new KeyRowInsertCommandHandler<>( |
| this.eventList, |
| new IdIndexKeyHandler<>(new ListDataProvider<>(this.eventList, columnPropertyAccessor), rowIdAccessor))); |
| |
| GlazedListsEventLayer<Person> glazedListsEventLayer = |
| new GlazedListsEventLayer<>(this.dataLayer, this.filterList); |
| glazedListsEventLayer.setTestMode(true); |
| |
| this.dataChangeLayer = new DataChangeLayer(glazedListsEventLayer, |
| new IdIndexKeyHandler<>( |
| this.dataProvider, |
| rowIdAccessor), |
| // configure persistence mode for data changes |
| false, |
| // enable tracking of row structural changes |
| true); |
| |
| this.dataChangeLayer.addLayerListener(new ILayerListener() { |
| |
| @Override |
| public void handleLayerEvent(ILayerEvent event) { |
| if (event instanceof RowStructuralRefreshEvent) { |
| RowStructuralDataChangeLayerIntegrationTest.this.lock.countDown(); |
| } |
| } |
| }); |
| |
| for (DataChangeHandler h : this.dataChangeLayer.getDataChangeHandler()) { |
| if (h instanceof RowInsertDataChangeHandler) { |
| this.insertHandler = (RowInsertDataChangeHandler) h; |
| } else if (h instanceof RowDeleteDataChangeHandler) { |
| this.deleteHandler = (RowDeleteDataChangeHandler) h; |
| } |
| } |
| assertNotNull("RowInsertDataChangeHandler not found", this.insertHandler); |
| assertNotNull("RowDeleteDataChangeHandler not found", this.deleteHandler); |
| |
| } |
| |
| @After |
| public void tearDown() { |
| this.dataChangeLayer.doCommand(new DisposeResourcesCommand()); |
| } |
| |
| @Test |
| public void shouldUpdateDataInDataLayer() { |
| assertEquals("Simpson", this.dataLayer.getDataValue(1, 1)); |
| |
| this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, "Lovejoy")); |
| |
| assertEquals("Lovejoy", this.dataLayer.getDataValue(1, 1)); |
| assertEquals("Lovejoy", this.dataChangeLayer.getDataValueByPosition(1, 1)); |
| assertTrue("Dirty label not set", this.dataChangeLayer.getConfigLabelsByPosition(1, 1).hasLabel(DataChangeLayer.DIRTY)); |
| assertTrue("Column 1 is not dirty", this.dataChangeLayer.isColumnDirty(1)); |
| assertTrue("Row 1 is not dirty", this.dataChangeLayer.isRowDirty(1)); |
| assertTrue("Cell is not dirty", this.dataChangeLayer.isCellDirty(1, 1)); |
| } |
| |
| @Test |
| public void shouldTrackRowInsert() { |
| Person ralph = new Person(42, "Ralph", "Wiggum", Gender.MALE, false, new Date()); |
| this.dataChangeLayer.doCommand(new RowInsertCommand<>(ralph)); |
| |
| int ralphIndex = this.eventList.indexOf(ralph); |
| Object key = this.insertHandler.getKeyHandler().getKey(-1, ralphIndex); |
| |
| assertEquals(19, this.eventList.size()); |
| |
| // row added so all columns are actually dirty |
| assertTrue("Column 0 is not dirty", this.dataChangeLayer.isColumnDirty(0)); |
| assertTrue("Column 1 is not dirty", this.dataChangeLayer.isColumnDirty(1)); |
| assertTrue("Column 2 is not dirty", this.dataChangeLayer.isColumnDirty(2)); |
| assertTrue("Column 3 is not dirty", this.dataChangeLayer.isColumnDirty(3)); |
| assertTrue("Column 4 is not dirty", this.dataChangeLayer.isColumnDirty(4)); |
| |
| assertTrue("Row " + ralphIndex + " is not dirty", this.dataChangeLayer.isRowDirty(ralphIndex)); |
| |
| assertTrue("Cell 0/" + ralphIndex + " is not dirty", this.dataChangeLayer.isCellDirty(0, ralphIndex)); |
| assertTrue("Cell 1/" + ralphIndex + " is not dirty", this.dataChangeLayer.isCellDirty(1, ralphIndex)); |
| assertTrue("Cell 2/" + ralphIndex + " is not dirty", this.dataChangeLayer.isCellDirty(2, ralphIndex)); |
| assertTrue("Cell 3/" + ralphIndex + " is not dirty", this.dataChangeLayer.isCellDirty(3, ralphIndex)); |
| assertTrue("Cell 4/" + ralphIndex + " is not dirty", this.dataChangeLayer.isCellDirty(4, ralphIndex)); |
| |
| assertTrue("Dirty label not set", this.dataChangeLayer.getConfigLabelsByPosition(0, ralphIndex).hasLabel(DataChangeLayer.DIRTY)); |
| assertTrue("Dirty label not set", this.dataChangeLayer.getConfigLabelsByPosition(1, ralphIndex).hasLabel(DataChangeLayer.DIRTY)); |
| assertTrue("Dirty label not set", this.dataChangeLayer.getConfigLabelsByPosition(2, ralphIndex).hasLabel(DataChangeLayer.DIRTY)); |
| assertTrue("Dirty label not set", this.dataChangeLayer.getConfigLabelsByPosition(3, ralphIndex).hasLabel(DataChangeLayer.DIRTY)); |
| assertTrue("Dirty label not set", this.dataChangeLayer.getConfigLabelsByPosition(4, ralphIndex).hasLabel(DataChangeLayer.DIRTY)); |
| |
| assertEquals(1, this.dataChangeLayer.getDataChanges().size()); |
| assertEquals(1, this.insertHandler.getDataChanges().size()); |
| // we use the IdIndexKeyHandler so casting is fine |
| IdIndexIdentifier<Person> identifier = (IdIndexIdentifier<Person>) this.insertHandler.getDataChanges().get(key).getKey(); |
| assertEquals(ralph, identifier.rowObject); |
| assertEquals(42, identifier.rowId); |
| } |
| |
| @Test |
| public void shouldTrackRowInsertOnSort() { |
| Person ralph = new Person(42, "Ralph", "Wiggum", Gender.MALE, false, new Date()); |
| this.dataChangeLayer.doCommand(new RowInsertCommand<>(ralph)); |
| |
| assertEquals(18, this.sortedList.indexOf(ralph)); |
| assertEquals(19, this.sortedList.size()); |
| |
| // trigger DESC sorting |
| this.sortedList.setComparator(Comparator.comparing(Person::getLastName, (p1, p2) -> { |
| return p2.compareTo(p1); |
| })); |
| |
| int ralphIndex = this.sortedList.indexOf(ralph); |
| Object key = this.insertHandler.getKeyHandler().getKey(-1, ralphIndex); |
| |
| assertEquals(0, ralphIndex); |
| assertTrue("Column 0 is not dirty", this.dataChangeLayer.isColumnDirty(0)); |
| assertTrue("Row " + ralphIndex + " is not dirty", this.dataChangeLayer.isRowDirty(ralphIndex)); |
| assertTrue("Cell 0/" + ralphIndex + " is not dirty", this.dataChangeLayer.isCellDirty(0, ralphIndex)); |
| assertTrue("Dirty label not set", this.dataChangeLayer.getConfigLabelsByPosition(0, ralphIndex).hasLabel(DataChangeLayer.DIRTY)); |
| |
| assertEquals(1, this.dataChangeLayer.getDataChanges().size()); |
| assertEquals(1, this.insertHandler.getDataChanges().size()); |
| // we use the IdIndexKeyHandler so casting is fine |
| IdIndexIdentifier<Person> identifier = (IdIndexIdentifier<Person>) this.insertHandler.getDataChanges().get(key).getKey(); |
| assertEquals(ralph, identifier.rowObject); |
| assertEquals(42, identifier.rowId); |
| } |
| |
| @Test |
| public void shouldTrackRowInsertInSortedState() { |
| assertEquals(18, this.sortedList.size()); |
| |
| // trigger DESC sorting |
| this.sortedList.setComparator(Comparator.comparing(Person::getLastName, (p1, p2) -> { |
| return p2.compareTo(p1); |
| })); |
| |
| // insert while the list is sorted |
| Person ralph = new Person(42, "Ralph", "Wiggum", Gender.MALE, false, new Date()); |
| this.dataChangeLayer.doCommand(new RowInsertCommand<>(ralph)); |
| |
| assertEquals(19, this.sortedList.size()); |
| int ralphIndex = this.sortedList.indexOf(ralph); |
| Object key = this.insertHandler.getKeyHandler().getKey(-1, ralphIndex); |
| |
| assertEquals(0, ralphIndex); |
| assertTrue("Column 0 is not dirty", this.dataChangeLayer.isColumnDirty(0)); |
| assertTrue("Row " + ralphIndex + " is not dirty", this.dataChangeLayer.isRowDirty(ralphIndex)); |
| assertTrue("Cell 0/" + ralphIndex + " is not dirty", this.dataChangeLayer.isCellDirty(0, ralphIndex)); |
| assertTrue("Dirty label not set", this.dataChangeLayer.getConfigLabelsByPosition(0, ralphIndex).hasLabel(DataChangeLayer.DIRTY)); |
| |
| assertEquals(1, this.dataChangeLayer.getDataChanges().size()); |
| assertEquals(1, this.insertHandler.getDataChanges().size()); |
| // we use the IdIndexKeyHandler so casting is fine |
| IdIndexIdentifier<Person> identifier = (IdIndexIdentifier<Person>) this.insertHandler.getDataChanges().get(key).getKey(); |
| assertEquals(ralph, identifier.rowObject); |
| assertEquals(42, identifier.rowId); |
| } |
| |
| @Test |
| public void shouldDiscardRowInsertInSortedState() { |
| Person ralph = new Person(42, "Ralph", "Wiggum", Gender.MALE, false, new Date()); |
| this.dataChangeLayer.doCommand(new RowInsertCommand<>(ralph)); |
| |
| assertEquals(18, this.sortedList.indexOf(ralph)); |
| assertEquals(19, this.sortedList.size()); |
| |
| // trigger DESC sorting |
| this.sortedList.setComparator(Comparator.comparing(Person::getLastName, (p1, p2) -> { |
| return p2.compareTo(p1); |
| })); |
| |
| assertEquals(0, this.sortedList.indexOf(ralph)); |
| |
| // discard the change |
| this.dataChangeLayer.doCommand(new DiscardDataChangesCommand()); |
| |
| assertEquals(18, this.sortedList.size()); |
| |
| assertTrue(this.dataChangeLayer.getDataChanges().isEmpty()); |
| assertTrue(this.insertHandler.getDataChanges().isEmpty()); |
| |
| // check for states on row 0 |
| assertFalse("Column 0 is dirty", this.dataChangeLayer.isColumnDirty(0)); |
| assertFalse("Row 0 is dirty", this.dataChangeLayer.isRowDirty(0)); |
| assertFalse("Cell 0/0 is dirty", this.dataChangeLayer.isCellDirty(0, 0)); |
| assertFalse("Dirty label set", this.dataChangeLayer.getConfigLabelsByPosition(0, 0).hasLabel(DataChangeLayer.DIRTY)); |
| |
| assertFalse("Ralph is still here", this.sortedList.contains(ralph)); |
| } |
| |
| @Test |
| public void shouldDiscardRowInsertOnChangeSortedState() { |
| // trigger DESC sorting |
| this.sortedList.setComparator(Comparator.comparing(Person::getLastName, (p1, p2) -> { |
| return p2.compareTo(p1); |
| })); |
| |
| Person ralph = new Person(42, "Ralph", "Wiggum", Gender.MALE, false, new Date()); |
| this.dataChangeLayer.doCommand(new RowInsertCommand<>(ralph)); |
| |
| assertEquals(0, this.sortedList.indexOf(ralph)); |
| assertEquals(19, this.sortedList.size()); |
| |
| this.sortedList.setComparator(null); |
| |
| assertEquals(18, this.sortedList.indexOf(ralph)); |
| |
| // discard the change |
| this.dataChangeLayer.doCommand(new DiscardDataChangesCommand()); |
| |
| assertEquals(18, this.sortedList.size()); |
| |
| assertTrue(this.dataChangeLayer.getDataChanges().isEmpty()); |
| assertTrue(this.insertHandler.getDataChanges().isEmpty()); |
| |
| // check that no row is dirty |
| for (int row = 0; row < this.sortedList.size(); row++) { |
| assertFalse("Row " + row + " is dirty", this.dataChangeLayer.isRowDirty(row)); |
| } |
| |
| assertFalse("Ralph is still here", this.sortedList.contains(ralph)); |
| } |
| |
| @Test |
| public void shouldDiscardMultipleRowInsertOnChangeSortedStateAppending() { |
| // trigger DESC sorting |
| this.sortedList.setComparator(Comparator.comparing(Person::getLastName, (p1, p2) -> { |
| return p2.compareTo(p1); |
| })); |
| |
| Person clancy = new Person(40, "Clancy", "Wiggum", Gender.MALE, true, new Date()); |
| Person sarah = new Person(41, "Sarah", "Wiggum", Gender.FEMALE, true, new Date()); |
| Person ralph = new Person(42, "Ralph", "Wiggum", Gender.MALE, false, new Date()); |
| this.dataChangeLayer.doCommand(new RowInsertCommand<>(this.dataChangeLayer, -1, clancy, sarah, ralph)); |
| |
| assertEquals(0, this.sortedList.indexOf(clancy)); |
| assertEquals(1, this.sortedList.indexOf(sarah)); |
| assertEquals(2, this.sortedList.indexOf(ralph)); |
| assertEquals(21, this.sortedList.size()); |
| |
| this.sortedList.setComparator(null); |
| |
| assertEquals(18, this.sortedList.indexOf(clancy)); |
| assertEquals(19, this.sortedList.indexOf(sarah)); |
| assertEquals(20, this.sortedList.indexOf(ralph)); |
| |
| assertTrue("Row 18 is not dirty", this.dataChangeLayer.isRowDirty(18)); |
| assertTrue("Row 19 is not dirty", this.dataChangeLayer.isRowDirty(19)); |
| assertTrue("Row 20 is not dirty", this.dataChangeLayer.isRowDirty(20)); |
| |
| // discard the change |
| this.dataChangeLayer.doCommand(new DiscardDataChangesCommand()); |
| |
| assertEquals(18, this.sortedList.size()); |
| |
| assertTrue(this.dataChangeLayer.getDataChanges().isEmpty()); |
| assertTrue(this.insertHandler.getDataChanges().isEmpty()); |
| |
| // check that no row is dirty |
| for (int row = 0; row < this.sortedList.size(); row++) { |
| assertFalse("Row " + row + " is dirty", this.dataChangeLayer.isRowDirty(row)); |
| } |
| |
| assertFalse("Clancy is still here", this.sortedList.contains(clancy)); |
| assertFalse("Sarah is still here", this.sortedList.contains(sarah)); |
| assertFalse("Ralph is still here", this.sortedList.contains(ralph)); |
| } |
| |
| @Test |
| public void shouldDiscardMultipleRowInsertOnChangeSortedState() { |
| // trigger DESC sorting |
| this.sortedList.setComparator(Comparator.comparing(Person::getLastName, (p1, p2) -> { |
| return p2.compareTo(p1); |
| })); |
| |
| Person clancy = new Person(40, "Clancy", "Wiggum", Gender.MALE, true, new Date()); |
| Person sarah = new Person(41, "Sarah", "Wiggum", Gender.FEMALE, true, new Date()); |
| Person ralph = new Person(42, "Ralph", "Wiggum", Gender.MALE, false, new Date()); |
| this.dataChangeLayer.doCommand(new RowInsertCommand<>(this.dataChangeLayer, 10, clancy, sarah, ralph)); |
| |
| assertEquals(0, this.sortedList.indexOf(clancy)); |
| assertEquals(1, this.sortedList.indexOf(sarah)); |
| assertEquals(2, this.sortedList.indexOf(ralph)); |
| assertEquals(21, this.sortedList.size()); |
| |
| this.sortedList.setComparator(null); |
| |
| assertEquals(10, this.sortedList.indexOf(clancy)); |
| assertEquals(11, this.sortedList.indexOf(sarah)); |
| assertEquals(12, this.sortedList.indexOf(ralph)); |
| |
| assertTrue("Row 10 is not dirty", this.dataChangeLayer.isRowDirty(10)); |
| assertTrue("Row 11 is not dirty", this.dataChangeLayer.isRowDirty(11)); |
| assertTrue("Row 12 is not dirty", this.dataChangeLayer.isRowDirty(12)); |
| |
| // discard the change |
| this.dataChangeLayer.doCommand(new DiscardDataChangesCommand()); |
| |
| assertEquals(18, this.sortedList.size()); |
| |
| assertTrue(this.dataChangeLayer.getDataChanges().isEmpty()); |
| assertTrue(this.insertHandler.getDataChanges().isEmpty()); |
| |
| // check that no row is dirty |
| for (int row = 0; row < this.sortedList.size(); row++) { |
| assertFalse("Row " + row + " is dirty", this.dataChangeLayer.isRowDirty(row)); |
| } |
| |
| assertFalse("Clancy is still here", this.sortedList.contains(clancy)); |
| assertFalse("Sarah is still here", this.sortedList.contains(sarah)); |
| assertFalse("Ralph is still here", this.sortedList.contains(ralph)); |
| } |
| |
| @Test |
| public void shouldKeepChangeOnFilter() throws InterruptedException { |
| this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, "Lovejoy")); |
| |
| this.filterList.setMatcher(new Matcher<Person>() { |
| |
| @Override |
| public boolean matches(Person item) { |
| return item.getLastName().equals("Simpson"); |
| } |
| }); |
| |
| // give the GlazedListsEventLayer some time to trigger the |
| // RowStructuralRefreshEvent |
| boolean completed = this.lock.await(1000, TimeUnit.MILLISECONDS); |
| |
| assertTrue("Timeout - no event received", completed); |
| |
| assertEquals(9, this.filterList.size()); |
| assertFalse(this.dataChangeLayer.getDataChanges().isEmpty()); |
| assertFalse("Column 1 is dirty", this.dataChangeLayer.isColumnDirty(1)); |
| |
| this.lock = new CountDownLatch(1); |
| this.filterList.setMatcher(null); |
| |
| // give the GlazedListsEventLayer some time to trigger the |
| // RowStructuralRefreshEvent |
| completed = this.lock.await(1000, TimeUnit.MILLISECONDS); |
| |
| assertTrue("Timeout - no event received", completed); |
| |
| assertEquals(18, this.filterList.size()); |
| assertFalse(this.dataChangeLayer.getDataChanges().isEmpty()); |
| assertTrue("Column 1 is not dirty", this.dataChangeLayer.isColumnDirty(1)); |
| } |
| |
| @Test |
| public void shouldNotThrowAnExceptionOnResize() throws InterruptedException { |
| this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, "Lovejoy")); |
| |
| this.filterList.setMatcher(new Matcher<Person>() { |
| |
| @Override |
| public boolean matches(Person item) { |
| return item.getLastName().equals("Simpson"); |
| } |
| }); |
| |
| this.dataLayer.setColumnWidthByPosition(2, 75); |
| |
| assertEquals(9, this.filterList.size()); |
| assertFalse(this.dataChangeLayer.getDataChanges().isEmpty()); |
| assertFalse("Column 1 is dirty", this.dataChangeLayer.isColumnDirty(1)); |
| |
| this.filterList.setMatcher(null); |
| |
| // give the GlazedListsEventLayer some time to trigger the |
| // RowStructuralRefreshEvent |
| boolean completed = this.lock.await(1000, TimeUnit.MILLISECONDS); |
| |
| assertTrue("Timeout - no event received", completed); |
| |
| assertEquals(18, this.filterList.size()); |
| assertFalse(this.dataChangeLayer.getDataChanges().isEmpty()); |
| assertTrue("Column 1 is not dirty", this.dataChangeLayer.isColumnDirty(1)); |
| } |
| } |
