Module org.testfx
Package org.testfx.assertions.api

Class AbstractTableViewAssert<SELF extends AbstractTableViewAssert<SELF,​T>,​T>

  • All Implemented Interfaces:
    org.assertj.core.api.Assert<SELF,​Node>, org.assertj.core.api.Descriptable<SELF>, org.assertj.core.api.ExtensionPoints<SELF,​Node>
    Direct Known Subclasses:
    TableViewAssert
    public class AbstractTableViewAssert<SELF extends AbstractTableViewAssert<SELF,​T>,​T>
extends AbstractNodeAssert<SELF>
    Base class for all TableView assertions.

    • Constructor Detail

      • AbstractTableViewAssert

        protected AbstractTableViewAssert​(TableView<T> actual,
                                  Class<?> selfType)

    • Method Detail

      • hasTableCell

        public SELF hasTableCell​(Object expectedValue)
        Verifies that the actual TableView contains the given table cell expectedValue.
        Parameters:
        expectedValue - the given table cell value to ensure the TableView contains
        Returns:
        this assertion object

      • doesNotHaveTableCell

        public SELF doesNotHaveTableCell​(Object expectedValue)
        Verifies that the actual TableView does not contain the given table cell expectedValue.
        Parameters:
        expectedValue - the given table cell value to ensure the TableView does not contain
        Returns:
        this assertion object

      • hasExactlyNumRows

        public SELF hasExactlyNumRows​(int rows)
        Verifies that the actual TableView has exactly the given amount of rows.
        Parameters:
        rows - the given amount of rows to compare the actual amount of rows to
        Returns:
        this assertion object

      • doesNotHaveExactlyNumRows

        public SELF doesNotHaveExactlyNumRows​(int rows)
        Verifies that the actual TableView does not have exactly the given amount of rows.
        Parameters:
        rows - the given amount of rows to compare the actual amount of rows to
        Returns:
        this assertion object

      • containsRowAtIndex

        public SELF containsRowAtIndex​(int rowIndex,
                               Object... cells)
        Verifies that the actual TableView contains the given table cells at the given rowIndex.

        For example, given a TableView that has three columns: 

        
 TableColumn<RegularPolygon, String> nameColumn = new TableColumn<>("Name");
 TableColumn<RegularPolygon, Integer> numSidesColumn = new TableColumn<>("Number of Sides");
 TableColumn<RegularPolygon, Double> unitAreaColumn = new TableColumn<>("Area when Side = 1");
 polygonsTable.getColumns().setAll(nameColumn, numSidesColumn, unitAreaColumn);
        Then to verify that such a TableView, contains, at index 3, a row for a RegularPolygon that has the name "Pentagon", the number of sides 5, and a unit area of 1.720477401 one would use: 
        
 assertThat(polygonsTable).containsRowAtIndex(3, "Pentagon", 5, 1.720477401);
        Where the types of each argument, after the row index, correspond to the types of the TableColumns which in our example is (String, Integer, Double).
        Parameters:
        rowIndex - the given row index that the actual TableView should contain the given cells on
        cells - the cells that should be contained at the given row index
        Returns:
        this assertion object

      • doesNotContainRowAtIndex

        public SELF doesNotContainRowAtIndex​(int rowIndex,
                                     Object... cells)
        Verifies that the actual TableView does not contain the given table cells at the given rowIndex.
        Parameters:
        rowIndex - the given row index that the actual TableView should not contain the given cells on
        cells - the cells that should not be contained at the given row index
        Returns:
        this assertion object

      • containsRow

        public SELF containsRow​(Object... cells)
        Verifies that the actual TableView contains the given table cells at any row index.

        For example, given a TableView that has three columns: 

        
 TableColumn<Person, String> nameColumn = new TableColumn<>("Name");
 TableColumn<Person, Double> bmiColumn = new TableColumn<>("Body Mass Index");
 TableColumn<Person, Boolean> membershipColumn = new TableColumn<>("Gym Membership Valid");
 fitnessTable.getColumns().setAll(nameColumn, bmiColumn, membershipColumn);
        Then to verify that such a TableView, contains at least one row with a Person that has the name "Dan Anderson", the body mass index 28.83, and a valid gym membership (true) one would use: 
        
 assertThat(fitnessTable).containsRow("Dan Anderson", 28.83, true);
        Where the types of each argument correspond to the types of the TableColumns which in our example is (String, Double, Boolean).
        Parameters:
        cells - the cells that should be contained at any (at least one) row index
        Returns:
        this assertion object

      • doesNotContainRow

        public SELF doesNotContainRow​(Object... cells)
        Verifies that the actual TableView does not contain the given table cells at any row index.
        Parameters:
        cells - the cells that should not be contained at any (at least one) row index
        Returns:
        this assertion object