java.lang.Object
- docking.widgets.table.columnfilter.ColumnTableFilterTest

```
public class ColumnTableFilterTest
extends java.lang.Object
```
This test performs operations on swing components in the test thread. I beleive this is ok since in this test, the widgets are never realized and the swing thread in generally not involved. If this test has displays intermittent failures, then more work will be needed to fix the threading when accessing swing components.

Constructor Summary

Constructors
Constructor Description

ColumnTableFilterTest()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`setup()`
`void`	`testAndOrConditions()`
`void`	`testAndOrPrecedenceAndFirst()`	This tests that the query ["Name starts with A" AND "Name ends With z" OR "Name starts with B"] is evaluated as [("Name starts with A" AND "Name ends With z") OR "Name starts with B"] and not ["Name starts with A" AND ("Name ends With z" OR "Name starts with B")] Since no entries end with "z", if the OR had precedence, you would get no results since the OR part would evaluate to "Bob" which when ANDed with "starts with A" would not match "Bob" and therefore no results would be found.
`void`	`testAndOrPrecedenceOrFirst()`	This tests the query ["Name starts with A" OR "Name starts With B" AND "Name ends with z"] is evaluated as ["Name starts with A" OR ("Name starts With B" AND "Name ends with z")] and not [("Name starts with A" OR "Name starts With B") AND "Name ends with z"] Since no entries end with "z", if the OR had precedence, you would get no results.
`void`	`testByteAtLeastFilter()`
`void`	`testByteAtMostFilter()`
`void`	`testByteInRangeFilter()`
`void`	`testByteNotInRangeFilter()`
`void`	`testDateAtLeastFilter()`
`void`	`testDateAtMostFilter()`
`void`	`testDateInRangeFilter()`
`void`	`testDateNotInRangeFilter()`
`void`	`testIntAtLeastFilter()`
`void`	`testIntAtMostFilter()`
`void`	`testIntInRangeFilter()`
`void`	`testIntNotInRangeFilter()`
`void`	`testIsValidAndGetErrorMessage()`
`void`	`testLoadingFilterModelFromExistingFilter()`
`void`	`testLongAtLeastFilter()`
`void`	`testLongAtMostFilter()`
`void`	`testLongInRangeFilter()`
`void`	`testLongNotInRangeFilter()`
`void`	`testMultipleConditionsAnded()`
`void`	`testOrCondition()`
`void`	`testOrConditions()`
`void`	`testSaveAndRestoreFilter()`
`void`	`testShortAtLeastFilter()`
`void`	`testShortAtMostFilter()`
`void`	`testShortInRangeFilter()`
`void`	`testShortNotInRangeFilter()`
`void`	`testStringContainsColumnFilter()`
`void`	`testStringDoesNotStartsWithColumnFilter()`
`void`	`testStringEndsWithColumnFilter()`
`void`	`testStringMatchesColumnFilter()`
`void`	`testStringNotContainsColumnFilter()`
`void`	`testStringStartsWithColumnFilter()`
`void`	`testTwoConditionsAnded()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ColumnTableFilterTest
```
public ColumnTableFilterTest()
```
- Method Detail
  - setup
```
public void setup()
```
  - testStringStartsWithColumnFilter
```
public void testStringStartsWithColumnFilter()
```
  - testStringDoesNotStartsWithColumnFilter
```
public void testStringDoesNotStartsWithColumnFilter()
```
  - testStringEndsWithColumnFilter
```
public void testStringEndsWithColumnFilter()
```
  - testStringContainsColumnFilter
```
public void testStringContainsColumnFilter()
```
  - testStringMatchesColumnFilter
```
public void testStringMatchesColumnFilter()
```
  - testStringNotContainsColumnFilter
```
public void testStringNotContainsColumnFilter()
```
  - testByteAtLeastFilter
```
public void testByteAtLeastFilter()
```
  - testByteAtMostFilter
```
public void testByteAtMostFilter()
```
  - testByteInRangeFilter
```
public void testByteInRangeFilter()
```
  - testByteNotInRangeFilter
```
public void testByteNotInRangeFilter()
```
  - testShortAtLeastFilter
```
public void testShortAtLeastFilter()
```
  - testShortAtMostFilter
```
public void testShortAtMostFilter()
```
  - testShortInRangeFilter
```
public void testShortInRangeFilter()
```
  - testShortNotInRangeFilter
```
public void testShortNotInRangeFilter()
```
  - testIntAtLeastFilter
```
public void testIntAtLeastFilter()
```
  - testIntAtMostFilter
```
public void testIntAtMostFilter()
```
  - testIntInRangeFilter
```
public void testIntInRangeFilter()
```
  - testIntNotInRangeFilter
```
public void testIntNotInRangeFilter()
```
  - testLongAtLeastFilter
```
public void testLongAtLeastFilter()
```
  - testLongAtMostFilter
```
public void testLongAtMostFilter()
```
  - testLongInRangeFilter
```
public void testLongInRangeFilter()
```
  - testLongNotInRangeFilter
```
public void testLongNotInRangeFilter()
```
  - testDateAtLeastFilter
```
public void testDateAtLeastFilter()
```
  - testDateAtMostFilter
```
public void testDateAtMostFilter()
```
  - testDateInRangeFilter
```
public void testDateInRangeFilter()
```
  - testDateNotInRangeFilter
```
public void testDateNotInRangeFilter()
```
  - testTwoConditionsAnded
```
public void testTwoConditionsAnded()
```
  - testMultipleConditionsAnded
```
public void testMultipleConditionsAnded()
```
  - testOrConditions
```
public void testOrConditions()
```
  - testAndOrConditions
```
public void testAndOrConditions()
```
  - testSaveAndRestoreFilter
```
public void testSaveAndRestoreFilter()
```
  - testLoadingFilterModelFromExistingFilter
```
public void testLoadingFilterModelFromExistingFilter()
```
  - testIsValidAndGetErrorMessage
```
public void testIsValidAndGetErrorMessage()
```
  - testOrCondition
```
public void testOrCondition()
```
  - testAndOrPrecedenceOrFirst
```
public void testAndOrPrecedenceOrFirst()
```
    This tests the query ["Name starts with A" OR "Name starts With B" AND "Name ends with z"] is evaluated as ["Name starts with A" OR ("Name starts With B" AND "Name ends with z")] and not [("Name starts with A" OR "Name starts With B") AND "Name ends with z"] Since no entries end with "z", if the OR had precedence, you would get no results.
  - testAndOrPrecedenceAndFirst
```
public void testAndOrPrecedenceAndFirst()
```
    This tests that the query ["Name starts with A" AND "Name ends With z" OR "Name starts with B"] is evaluated as [("Name starts with A" AND "Name ends With z") OR "Name starts with B"] and not ["Name starts with A" AND ("Name ends With z" OR "Name starts with B")] Since no entries end with "z", if the OR had precedence, you would get no results since the OR part would evaluate to "Bob" which when ANDed with "starts with A" would not match "Bob" and therefore no results would be found.

Class ColumnTableFilterTest

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ColumnTableFilterTest

Method Detail

setup

testStringStartsWithColumnFilter

testStringDoesNotStartsWithColumnFilter

testStringEndsWithColumnFilter

testStringContainsColumnFilter

testStringMatchesColumnFilter

testStringNotContainsColumnFilter

testByteAtLeastFilter

testByteAtMostFilter

testByteInRangeFilter

testByteNotInRangeFilter

testShortAtLeastFilter

testShortAtMostFilter

testShortInRangeFilter

testShortNotInRangeFilter

testIntAtLeastFilter

testIntAtMostFilter

testIntInRangeFilter

testIntNotInRangeFilter

testLongAtLeastFilter

testLongAtMostFilter

testLongInRangeFilter

testLongNotInRangeFilter

testDateAtLeastFilter

testDateAtMostFilter

testDateInRangeFilter

testDateNotInRangeFilter

testTwoConditionsAnded

testMultipleConditionsAnded

testOrConditions

testAndOrConditions

testSaveAndRestoreFilter

testLoadingFilterModelFromExistingFilter

testIsValidAndGetErrorMessage

testOrCondition

testAndOrPrecedenceOrFirst

testAndOrPrecedenceAndFirst