diff --git a/org.eclipse.nebula.widgets.nattable.core.test/.project b/org.eclipse.nebula.widgets.nattable.core.test/.project index a8929e83e..ffc5fa67c 100644 --- a/org.eclipse.nebula.widgets.nattable.core.test/.project +++ b/org.eclipse.nebula.widgets.nattable.core.test/.project @@ -1,6 +1,6 @@ - org.eclipse.nebula.widgets.nattable.core.tests + org.eclipse.nebula.widgets.nattable.core.test NatTable Core Tests diff --git a/org.eclipse.nebula.widgets.nattable.core.test/META-INF/MANIFEST.MF b/org.eclipse.nebula.widgets.nattable.core.test/META-INF/MANIFEST.MF index 6ac44a11e..3e8d79b66 100644 --- a/org.eclipse.nebula.widgets.nattable.core.test/META-INF/MANIFEST.MF +++ b/org.eclipse.nebula.widgets.nattable.core.test/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: NatTable Core Tests -Bundle-SymbolicName: org.eclipse.nebula.widgets.nattable.core.tests +Bundle-SymbolicName: org.eclipse.nebula.widgets.nattable.core.test Bundle-Version: 2.4.0.qualifier Fragment-Host: org.eclipse.nebula.widgets.nattable.core Bundle-RequiredExecutionEnvironment: JavaSE-1.8 @@ -22,4 +22,4 @@ Export-Package: org.eclipse.nebula.widgets.nattable.test.fixture, org.eclipse.nebula.widgets.nattable.test.fixture.layer, org.eclipse.nebula.widgets.nattable.test.integration Bundle-Vendor: Eclipse Nebula NatTable -Automatic-Module-Name: org.eclipse.nebula.widgets.nattable.core.tests +Automatic-Module-Name: org.eclipse.nebula.widgets.nattable.core.test diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerIdIndexTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerIdIndexTest.java index aed9cb894..634193306 100644 --- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerIdIndexTest.java +++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerIdIndexTest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2017, 2022 Dirk Fauth. + * Copyright (c) 2017, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -95,6 +95,7 @@ public void shouldUpdateDataInDataLayer() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); } @Test @@ -114,6 +115,7 @@ public void shouldClearWithoutReset() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -137,6 +139,7 @@ public void shouldDiscardChanges() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -160,6 +163,7 @@ public void shouldSaveChanges() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -184,6 +188,7 @@ public void shouldClearOnStructuralChange() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -212,6 +217,7 @@ public void shouldRemoveChangeOnRowDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(2), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 2), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -242,6 +248,7 @@ public void shouldUpdateChangeOnRowDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(2), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 2), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -310,6 +317,8 @@ public void shouldUpdateOnMultiRowDelete() { assertFalse(this.dataChangeLayer.getConfigLabelsByPosition(1, 11).hasLabel(DataChangeLayer.DIRTY), "Dirty label set"); assertFalse(this.dataChangeLayer.getConfigLabelsByPosition(1, 12).hasLabel(DataChangeLayer.DIRTY), "Dirty label set"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(0), "Row 0 is not dirty"); @@ -365,6 +374,7 @@ public void shouldUpdateChangeOnRowInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(3), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 3), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -454,6 +464,8 @@ public void shouldUpdateOnMultiRowInsert() { assertTrue(this.dataChangeLayer.getConfigLabelsByPosition(1, 14).hasLabel(DataChangeLayer.DIRTY), "Dirty label not set"); assertFalse(this.dataChangeLayer.getConfigLabelsByPosition(1, 15).hasLabel(DataChangeLayer.DIRTY), "Dirty label set"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertFalse(this.dataChangeLayer.isRowDirty(0), "Row 0 is not dirty"); @@ -507,6 +519,7 @@ public void shouldRemoveChangeOnColumnDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(2), "Row 2 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 2), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -531,6 +544,7 @@ public void shouldUpdateChangeOnColumnDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(2), "Row 2 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(0, 2), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -555,6 +569,7 @@ public void shouldUpdateChangeOnColumnInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(2), "Column 2 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(2), "Row 2 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(2, 2), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -585,6 +600,7 @@ public void shouldUpdateChangeOnSortAndDiscard() { assertFalse(this.dataChangeLayer.isRowDirty(2), "Row 2 is dirty"); assertTrue(this.dataChangeLayer.isRowDirty(17), "Row 17 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 17), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -602,6 +618,7 @@ public void shouldUpdateChangeOnSortAndDiscard() { assertFalse(this.dataChangeLayer.isRowDirty(2), "Row 2 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(17), "Row 17 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 17), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -658,6 +675,7 @@ public Serializable getRowId(Person rowObject) { assertFalse(this.dataChangeLayer.isRowDirty(2), "Row 2 is dirty"); assertTrue(this.dataChangeLayer.isRowDirty(17), "Row 17 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 17), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(tempHandler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(tempHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -675,6 +693,7 @@ public Serializable getRowId(Person rowObject) { assertFalse(this.dataChangeLayer.isRowDirty(2), "Row 2 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(17), "Row 17 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 17), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(tempHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(tempHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -694,6 +713,7 @@ public void shouldNotBeDirtyForSameValue() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertEquals(0, this.dataChangeLayer.dataChanges.size()); } @@ -709,6 +729,7 @@ public void shouldNotBeDirtyOnSettingSameValue() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertEquals(1, this.dataChangeLayer.dataChanges.size()); this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, "Simpson")); @@ -719,6 +740,7 @@ public void shouldNotBeDirtyOnSettingSameValue() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertEquals(2, this.dataChangeLayer.dataChanges.size()); } diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerTempStorageTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerTempStorageTest.java index 1ffe80b09..6a302fbac 100644 --- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerTempStorageTest.java +++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerTempStorageTest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2017, 2022 Dirk Fauth. + * Copyright (c) 2017, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -83,6 +83,7 @@ public void shouldNotUpdateDataInDataLayer() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); } @Test @@ -103,6 +104,7 @@ public void shouldClearWithoutReset() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -130,6 +132,7 @@ public void shouldDiscardChanges() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -164,6 +167,7 @@ public void shouldSaveChanges() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -198,6 +202,7 @@ public void shouldClearOnStructuralChange() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -228,6 +233,7 @@ public void shouldDiscardAfterDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(8), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 8), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -245,6 +251,7 @@ public void shouldDiscardAfterDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(8), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 8), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -275,6 +282,7 @@ public void shouldSaveAfterDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(8), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 8), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -292,6 +300,7 @@ public void shouldSaveAfterDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(8), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 8), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -322,6 +331,7 @@ public void shouldSaveAfterInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(10), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 10), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -339,6 +349,7 @@ public void shouldSaveAfterInsert() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 10), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -358,6 +369,7 @@ public void shouldNotBeDirtyForSameValue() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -372,6 +384,7 @@ public void shouldNotBeDirtyOnResettingSameValue() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, "Simpson")); @@ -381,6 +394,7 @@ public void shouldNotBeDirtyOnResettingSameValue() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -395,6 +409,7 @@ public void shouldUpdateToNullAndBackAgain() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, "Simpson")); @@ -404,6 +419,7 @@ public void shouldUpdateToNullAndBackAgain() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -420,6 +436,7 @@ public void shouldUpdateNullValueAndBackAgain() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, null)); @@ -429,6 +446,7 @@ public void shouldUpdateNullValueAndBackAgain() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -445,5 +463,6 @@ public void shouldNotDirtyNullToNull() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } } diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerTest.java index d5e86b6dd..703670483 100644 --- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerTest.java +++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayerTest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2017, 2022 Dirk Fauth. + * Copyright (c) 2017, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -85,6 +85,7 @@ public void shouldUpdateDataInDataLayer() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); } @Test @@ -104,6 +105,7 @@ public void shouldClearWithoutReset() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -130,6 +132,7 @@ public void shouldDiscardChanges() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -164,6 +167,7 @@ public void shouldDiscardToOriginalAfterMultipleChanges() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -190,6 +194,7 @@ public void shouldSaveChanges() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -221,6 +226,7 @@ public void shouldClearOnStructuralChange() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -249,6 +255,7 @@ public void shouldRemoveChangeOnRowDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(2), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 2), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -279,6 +286,7 @@ public void shouldUpdateChangeOnRowDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(2), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 2), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -347,6 +355,8 @@ public void shouldUpdateOnMultiRowDelete() { assertFalse(this.dataChangeLayer.getConfigLabelsByPosition(1, 11).hasLabel(DataChangeLayer.DIRTY), "Dirty label set"); assertFalse(this.dataChangeLayer.getConfigLabelsByPosition(1, 12).hasLabel(DataChangeLayer.DIRTY), "Dirty label set"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(0), "Row 0 is not dirty"); @@ -402,6 +412,7 @@ public void shouldUpdateChangeOnRowInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(3), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 3), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -491,6 +502,8 @@ public void shouldUpdateOnMultiRowInsert() { assertTrue(this.dataChangeLayer.getConfigLabelsByPosition(1, 14).hasLabel(DataChangeLayer.DIRTY), "Dirty label not set"); assertFalse(this.dataChangeLayer.getConfigLabelsByPosition(1, 15).hasLabel(DataChangeLayer.DIRTY), "Dirty label set"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertFalse(this.dataChangeLayer.isRowDirty(0), "Row 0 is not dirty"); @@ -544,6 +557,7 @@ public void shouldRemoveChangeOnColumnDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(2), "Row 2 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 2), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -568,6 +582,7 @@ public void shouldUpdateChangeOnColumnDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(2), "Row 2 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(0, 2), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -592,6 +607,7 @@ public void shouldUpdateChangeOnColumnInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(2), "Column 2 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(2), "Row 2 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(2, 2), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -621,6 +637,7 @@ public void shouldDiscardAfterDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(8), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 8), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -638,6 +655,7 @@ public void shouldDiscardAfterDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(8), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 8), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -667,6 +685,7 @@ public void shouldSaveAfterDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(8), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 8), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -684,6 +703,7 @@ public void shouldSaveAfterDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(8), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 8), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); @@ -703,6 +723,7 @@ public void shouldNotBeDirtyForSameValue() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is not dirty"); assertEquals(0, this.dataChangeLayer.dataChanges.size()); } @@ -718,6 +739,7 @@ public void shouldNotBeDirtyOnSettingSameValue() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertEquals(1, this.dataChangeLayer.dataChanges.size()); this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, "Simpson")); @@ -728,6 +750,7 @@ public void shouldNotBeDirtyOnSettingSameValue() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertEquals(2, this.dataChangeLayer.dataChanges.size()); } @@ -743,6 +766,7 @@ public void shouldUpdateToNullAndBackAgain() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, "Simpson")); @@ -752,6 +776,7 @@ public void shouldUpdateToNullAndBackAgain() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -768,6 +793,7 @@ public void shouldUpdateNullValueAndBackAgain() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(1), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 1, null)); @@ -777,6 +803,7 @@ public void shouldUpdateNullValueAndBackAgain() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -793,6 +820,7 @@ public void shouldNotDirtyNullToNull() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(1), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -817,6 +845,7 @@ public void shouldDiscardAfterInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(10), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 10), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.handler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.handler.changedRows.isEmpty(), "changed rows are empty"); @@ -834,6 +863,7 @@ public void shouldDiscardAfterInsert() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 1 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 10), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.handler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.handler.changedRows.isEmpty(), "changed rows are not empty"); diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/RowStructuralDataChangeIdIndexTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/RowStructuralDataChangeIdIndexTest.java index 867e3f6f6..ea1599ed9 100644 --- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/RowStructuralDataChangeIdIndexTest.java +++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/RowStructuralDataChangeIdIndexTest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2018, 2022 Dirk Fauth. + * Copyright (c) 2018, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -107,6 +107,8 @@ public void shouldTrackRowInsertEvent() { assertEquals(19, this.dataModel.size()); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + // row added so all columns are actually dirty assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); @@ -150,6 +152,8 @@ public void shouldClearRowInsertWithoutReset() { assertEquals(1, this.dataChangeLayer.dataChanges.size()); assertEquals(1, this.insertHandler.dataChanges.size()); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is not dirty"); @@ -168,6 +172,7 @@ public void shouldClearRowInsertWithoutReset() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -195,6 +200,7 @@ public void shouldSaveRowInsertEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -226,6 +232,7 @@ public void shouldDiscardRowInsertEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -249,6 +256,7 @@ public void shouldClearRowInsertOnStructuralChange() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -287,6 +295,7 @@ public void shouldDiscardMultipleRowInsertEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -325,6 +334,7 @@ public void shouldDiscardMultipleRowInsertEventAppending() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -345,6 +355,8 @@ public void shouldTrackRowDeleteEvent() { assertEquals(17, this.dataModel.size()); assertFalse(this.dataModel.contains(toDelete)); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + // row deleted so all columns are actually dirty assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); @@ -386,6 +398,7 @@ public void shouldClearRowDeleteWithoutReset() { assertEquals(1, this.dataChangeLayer.dataChanges.size()); assertEquals(1, this.deleteHandler.dataChanges.size()); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -405,6 +418,7 @@ public void shouldClearRowDeleteWithoutReset() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -427,6 +441,7 @@ public void shouldSaveRowDeleteEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -456,6 +471,7 @@ public void shouldDiscardRowDeleteEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -478,6 +494,7 @@ public void shouldClearRowDeleteOnStructuralChange() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -515,6 +532,7 @@ public void shouldDiscardMultipleRowDeleteEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -543,6 +561,7 @@ public void shouldDiscardInsertAndDeleteAgain() { assertEquals(18, this.dataModel.size()); assertEquals(prev, this.dataModel.get(10)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -566,6 +585,7 @@ public void shouldResetUpdateDeleteOnDiscard() { assertEquals(18, this.dataModel.size()); assertEquals("Simpson", this.dataLayer.getDataValue(1, 1)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -591,6 +611,7 @@ public void shouldDiscardInsertAndUpdateInsertedItem() { assertEquals(18, this.dataModel.size()); assertEquals(prev, this.dataModel.get(10)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); // ensure that there is no Clancy or Ralph in an item afterwards for (Person p : this.dataModel) { @@ -621,6 +642,7 @@ public void shouldDiscardUpdateInsert() { assertEquals("Lovejoy", this.dataLayer.getDataValue(1, 2)); assertTrue(this.dataChangeLayer.isCellDirty(1, 2), "Cell is not dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); // discard the changes this.dataChangeLayer.doCommand(new DiscardDataChangesCommand()); @@ -628,6 +650,7 @@ public void shouldDiscardUpdateInsert() { assertEquals(18, this.dataModel.size()); assertEquals(prev, this.dataModel.get(0)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); // ensure that there is no Wiggum and no Lovejoy in an item afterwards for (Person p : this.dataModel) { @@ -658,6 +681,7 @@ public void shouldDiscardUpdateInsertAndUpdateBack() { assertEquals("Lovejoy", this.dataLayer.getDataValue(1, 2)); assertTrue(this.dataChangeLayer.isCellDirty(1, 2), "Cell is not dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); this.dataChangeLayer.doCommand(new UpdateDataCommand(this.dataChangeLayer, 1, 2, "Simpson")); @@ -670,6 +694,7 @@ public void shouldDiscardUpdateInsertAndUpdateBack() { assertEquals(18, this.dataModel.size()); assertEquals(prev, this.dataModel.get(0)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); // ensure that there is no Wiggum and no Lovejoy in an item afterwards for (Person p : this.dataModel) { @@ -698,6 +723,7 @@ public void shouldDiscardUpdateAfterDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(8), "Row 8 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 8), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.updateHandler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.updateHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -713,6 +739,7 @@ public void shouldDiscardUpdateAfterDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(9), "Row 9 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 9), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -746,6 +773,7 @@ public void shouldDiscardInsertAfterDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(9), "Row 9 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 9), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -762,6 +790,7 @@ public void shouldDiscardInsertAfterDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(9), "Row 9 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 9), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -796,6 +825,7 @@ public void shouldDiscardInsertAfterInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(11), "Row 9 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 11), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -812,6 +842,7 @@ public void shouldDiscardInsertAfterInsert() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(9), "Row 9 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 9), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -841,6 +872,7 @@ public void shouldDiscardUpdateAfterInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(10), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 10), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.updateHandler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.updateHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -856,6 +888,7 @@ public void shouldDiscardUpdateAfterInsert() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(9), "Row 9 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 9), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -886,6 +919,8 @@ public void shouldDiscardDeleteInsertedObject() { assertEquals("Simpson", this.dataLayer.getDataValue(1, 9)); assertEquals("Flanders", this.dataLayer.getDataValue(1, 10)); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + // no row dirty for (int row = 0; row < this.dataModel.size(); row++) { assertFalse(this.dataChangeLayer.isRowDirty(row), "Row " + row + " is dirty"); @@ -904,6 +939,8 @@ public void shouldDiscardDeleteInsertedObject() { assertEquals("Simpson", this.dataLayer.getDataValue(1, 9)); assertEquals("Flanders", this.dataLayer.getDataValue(1, 10)); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); + // no row dirty for (int row = 0; row < this.dataModel.size(); row++) { assertFalse(this.dataChangeLayer.isRowDirty(row), "Row " + row + " is dirty"); diff --git a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/RowStructuralDataChangeTest.java b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/RowStructuralDataChangeTest.java index c3a25f225..448b17228 100644 --- a/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/RowStructuralDataChangeTest.java +++ b/org.eclipse.nebula.widgets.nattable.core.test/src/org/eclipse/nebula/widgets/nattable/datachange/RowStructuralDataChangeTest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2018, 2022 Dirk Fauth. + * Copyright (c) 2018, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -95,6 +95,8 @@ public void shouldTrackRowInsertEvent() { assertEquals(19, this.dataModel.size()); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + // row added so all columns are actually dirty assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); @@ -138,6 +140,7 @@ public void shouldClearRowInsertWithoutReset() { assertEquals(1, this.dataChangeLayer.dataChanges.size()); assertEquals(1, this.insertHandler.dataChanges.size()); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is not dirty"); @@ -156,6 +159,7 @@ public void shouldClearRowInsertWithoutReset() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -183,6 +187,7 @@ public void shouldSaveRowInsertEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -214,6 +219,7 @@ public void shouldDiscardRowInsertEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -237,6 +243,7 @@ public void shouldClearRowInsertOnStructuralChange() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -275,6 +282,7 @@ public void shouldDiscardMultipleRowInsertEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -313,6 +321,7 @@ public void shouldDiscardMultipleRowInsertEventAppending() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.insertHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(ralphIndex), "Row " + ralphIndex + " is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, ralphIndex), "Cell 0/" + ralphIndex + " is dirty"); @@ -333,6 +342,8 @@ public void shouldTrackRowDeleteEvent() { assertEquals(17, this.dataModel.size()); assertFalse(this.dataModel.contains(toDelete)); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + // row deleted so all columns are actually dirty assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); @@ -374,6 +385,7 @@ public void shouldClearRowDeleteWithoutReset() { assertEquals(1, this.dataChangeLayer.dataChanges.size()); assertEquals(1, this.deleteHandler.dataChanges.size()); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertTrue(this.dataChangeLayer.isColumnDirty(0), "Column 0 is not dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -393,6 +405,7 @@ public void shouldClearRowDeleteWithoutReset() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -415,6 +428,7 @@ public void shouldSaveRowDeleteEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -444,6 +458,7 @@ public void shouldDiscardRowDeleteEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -466,6 +481,7 @@ public void shouldClearRowDeleteOnStructuralChange() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -503,6 +519,7 @@ public void shouldDiscardMultipleRowDeleteEvent() { assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); assertTrue(this.deleteHandler.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertFalse(this.dataChangeLayer.isColumnDirty(0), "Column 0 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(10), "Row 10 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(0, 10), "Cell 0/10 is dirty"); @@ -531,6 +548,7 @@ public void shouldDiscardInsertAndDeleteAgain() { assertEquals(18, this.dataModel.size()); assertEquals(prev, this.dataModel.get(10)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -554,6 +572,7 @@ public void shouldResetUpdateDeleteOnDiscard() { assertEquals(18, this.dataModel.size()); assertEquals("Simpson", this.dataLayer.getDataValue(1, 1)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } @Test @@ -579,6 +598,7 @@ public void shouldDiscardInsertAndUpdateInsertedItem() { assertEquals(18, this.dataModel.size()); assertEquals(prev, this.dataModel.get(10)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); // ensure that there is no Clancy or Ralph in an item afterwards for (Person p : this.dataModel) { @@ -610,12 +630,15 @@ public void shouldDiscardUpdateInsert() { assertTrue(this.dataChangeLayer.isCellDirty(1, 2), "Cell is not dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 1), "Cell is dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + // discard the changes this.dataChangeLayer.doCommand(new DiscardDataChangesCommand()); assertEquals(18, this.dataModel.size()); assertEquals(prev, this.dataModel.get(0)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); // ensure that there is no Wiggum and no Lovejoy in an item afterwards for (Person p : this.dataModel) { @@ -633,6 +656,7 @@ public void shouldDiscardUpdateInsertAndUpdateBack() { assertEquals("Lovejoy", this.dataLayer.getDataValue(1, 1)); assertTrue(this.dataChangeLayer.isCellDirty(1, 1), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); Person prev = this.dataModel.get(0); @@ -658,6 +682,7 @@ public void shouldDiscardUpdateInsertAndUpdateBack() { assertEquals(18, this.dataModel.size()); assertEquals(prev, this.dataModel.get(0)); assertTrue(this.dataChangeLayer.dataChanges.isEmpty()); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); // ensure that there is no Wiggum and no Lovejoy in an item afterwards for (Person p : this.dataModel) { @@ -686,6 +711,7 @@ public void shouldDiscardUpdateAfterDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(8), "Row 8 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 8), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.updateHandler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.updateHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -701,6 +727,7 @@ public void shouldDiscardUpdateAfterDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(9), "Row 9 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 9), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -734,6 +761,7 @@ public void shouldDiscardInsertAfterDelete() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(9), "Row 9 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 9), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -750,6 +778,7 @@ public void shouldDiscardInsertAfterDelete() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(9), "Row 9 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 9), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -784,6 +813,7 @@ public void shouldDiscardInsertAfterInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(11), "Row 9 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 11), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -800,6 +830,7 @@ public void shouldDiscardInsertAfterInsert() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(9), "Row 9 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 9), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -829,6 +860,7 @@ public void shouldDiscardUpdateAfterInsert() { assertTrue(this.dataChangeLayer.isColumnDirty(1), "Column 1 is not dirty"); assertTrue(this.dataChangeLayer.isRowDirty(10), "Row 1 is not dirty"); assertTrue(this.dataChangeLayer.isCellDirty(1, 10), "Cell is not dirty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); assertFalse(this.updateHandler.changedColumns.isEmpty(), "changed columns are empty"); assertFalse(this.updateHandler.changedRows.isEmpty(), "changed rows are empty"); @@ -844,6 +876,7 @@ public void shouldDiscardUpdateAfterInsert() { assertFalse(this.dataChangeLayer.isColumnDirty(1), "Column 1 is dirty"); assertFalse(this.dataChangeLayer.isRowDirty(9), "Row 9 is dirty"); assertFalse(this.dataChangeLayer.isCellDirty(1, 9), "Cell is dirty"); + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); assertTrue(this.updateHandler.changedColumns.isEmpty(), "changed columns are not empty"); assertTrue(this.updateHandler.changedRows.isEmpty(), "changed rows are not empty"); @@ -888,6 +921,8 @@ public void shouldDiscardDeleteInsertedObject() { assertFalse(this.deleteHandler.dataChanges.isEmpty(), "delete handler changes are empty"); assertFalse(this.dataChangeLayer.dataChanges.isEmpty(), "tracked changes are empty"); + assertTrue(this.dataChangeLayer.isDirty(), "State is not dirty"); + // now discard and check that previous state is restored correctly this.dataChangeLayer.doCommand(new DiscardDataChangesCommand()); @@ -905,6 +940,8 @@ public void shouldDiscardDeleteInsertedObject() { assertTrue(this.insertHandler.dataChanges.isEmpty(), "insert handler changes are not empty"); assertTrue(this.deleteHandler.dataChanges.isEmpty(), "delete handler changes are not empty"); assertTrue(this.dataChangeLayer.dataChanges.isEmpty(), "tracked changes are not empty"); + + assertFalse(this.dataChangeLayer.isDirty(), "State is dirty"); } } diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeHandler.java index cc431f5d6..19282b7e3 100644 --- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeHandler.java +++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeHandler.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2018, 2020 Dirk Fauth. + * Copyright (c) 2018, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -86,4 +86,13 @@ public interface DataChangeHandler { */ boolean isCellDirty(int columnPosition, int rowPosition); + /** + * Checks if there is a dirty state tracked by this handler. + * + * @return true if there is a dirty state (data has changed and + * not saved yet), false if not. + * + * @since 2.4 + */ + boolean isDirty(); } diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayer.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayer.java index 4f2e8a947..11483c6fc 100644 --- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayer.java +++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/DataChangeLayer.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2017, 2020 Dirk Fauth. + * Copyright (c) 2017, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -411,6 +411,23 @@ public boolean isCellDirty(int columnPosition, int rowPosition) { return false; } + /** + * Checks if there is a dirty state. + * + * @return true if there is a dirty state (data has changed and + * not saved yet), false if not. + * + * @since 2.4 + */ + public boolean isDirty() { + for (DataChangeHandler handler : this.dataChangeHandler) { + if (handler.isDirty()) { + return true; + } + } + return false; + } + @Override public Collection getProvidedLabels() { Collection providedLabels = super.getProvidedLabels(); diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/RowDeleteDataChangeHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/RowDeleteDataChangeHandler.java index 94dc0484d..fce414a59 100644 --- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/RowDeleteDataChangeHandler.java +++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/RowDeleteDataChangeHandler.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2018, 2020 Dirk Fauth. + * Copyright (c) 2018, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -67,6 +67,11 @@ public boolean isCellDirty(int columnPosition, int rowPosition) { return false; } + @Override + public boolean isDirty() { + return !this.dataChanges.isEmpty(); + } + @Override public void handleLayerEvent(RowObjectDeleteEvent event) { if (this.handleDataUpdate) { diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/RowInsertDataChangeHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/RowInsertDataChangeHandler.java index e30529904..8b8410530 100644 --- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/RowInsertDataChangeHandler.java +++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/RowInsertDataChangeHandler.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2018, 2020 Dirk Fauth. + * Copyright (c) 2018, 2024 Dirk Fauth. * * This program and the accompanying materials are made * available under the terms of the Eclipse Public License 2.0 @@ -197,6 +197,11 @@ public boolean isCellDirty(int columnPosition, int rowPosition) { return isRowDirty(rowPosition); } + @Override + public boolean isDirty() { + return !this.dataChanges.isEmpty(); + } + @Override public void handleLayerEvent(RowInsertEvent event) { if (this.handleDataUpdate) { diff --git a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/UpdateDataChangeHandler.java b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/UpdateDataChangeHandler.java index 3e997dd92..65c84862a 100644 --- a/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/UpdateDataChangeHandler.java +++ b/org.eclipse.nebula.widgets.nattable.core/src/org/eclipse/nebula/widgets/nattable/datachange/UpdateDataChangeHandler.java @@ -495,6 +495,11 @@ public boolean isCellDirty(int columnPosition, int rowPosition) { return false; } + @Override + public boolean isDirty() { + return !this.dataChanges.isEmpty(); + } + /** * Configure if the changes tracked by the {@link DataChangeLayer} should * also be updated on a horizontal/column structural changes. The update is diff --git a/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/.project b/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/.project index 75c541cec..b36c2f722 100644 --- a/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/.project +++ b/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/.project @@ -1,6 +1,6 @@ - org.eclipse.nebula.widgets.nattable.extension.glazedlists.tests + org.eclipse.nebula.widgets.nattable.extension.glazedlists.test diff --git a/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/META-INF/MANIFEST.MF b/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/META-INF/MANIFEST.MF index 79a4dda17..73c515e32 100644 --- a/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/META-INF/MANIFEST.MF +++ b/org.eclipse.nebula.widgets.nattable.extension.glazedlists.test/META-INF/MANIFEST.MF @@ -1,7 +1,7 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 Bundle-Name: NatTable GlazedLists Extensions Test -Bundle-SymbolicName: org.eclipse.nebula.widgets.nattable.extension.glazedlists.tests +Bundle-SymbolicName: org.eclipse.nebula.widgets.nattable.extension.glazedlists.test Bundle-Version: 2.4.0.qualifier Fragment-Host: org.eclipse.nebula.widgets.nattable.extension.glazedlists Bundle-RequiredExecutionEnvironment: JavaSE-1.8 @@ -30,4 +30,4 @@ Require-Bundle: ca.odell.glazedlists;bundle-version="1.9.0", junit-platform-commons;bundle-version="1.10.0", junit-jupiter-params;bundle-version="5.10.0", org.opentest4j;bundle-version="1.3.0" -Automatic-Module-Name: org.eclipse.nebula.widgets.nattable.extension.glazedlists.tests +Automatic-Module-Name: org.eclipse.nebula.widgets.nattable.extension.glazedlists.test