swingx-master/swingx-core/src/test/java/org/jdesktop/swingx/decorator/HighlightPredicateTest.java
/*
 * $Id$
 *
 * Copyright 2004 Sun Microsystems, Inc., 4150 Network Circle,
 * Santa Clara, California 95054, U.S.A. All rights reserved.
 */

package org.jdesktop.swingx.decorator;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.Point;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.regex.Pattern;

import javax.swing.BorderFactory;
import javax.swing.JLabel;
import javax.swing.table.TableCellRenderer;

import org.jdesktop.swingx.InteractiveTestCase;
import org.jdesktop.swingx.JXTable;
import org.jdesktop.swingx.decorator.HighlightPredicate.AndHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.ColumnHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.ColumnTypeHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.DepthHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.EqualsHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.IdentifierHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.NotHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.OrHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.RowGroupHighlightPredicate;
import org.jdesktop.swingx.decorator.HighlightPredicate.TypeHighlightPredicate;
import org.jdesktop.swingx.rollover.RolloverProducer;
import org.jdesktop.test.AncientSwingTeam;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;


/**
 * 
 * Tests for Highlighters after overhaul.
 * 
 * @author Jeanette Winzenburg
 */
@RunWith(JUnit4.class)
public class HighlightPredicateTest extends InteractiveTestCase {

    
    protected JLabel backgroundNull ;
    protected JLabel foregroundNull;
    protected JLabel allNull;
    protected JLabel allColored;
    
    protected Color background = Color.RED;
    protected Color foreground = Color.BLUE;
    
    protected Color unselectedBackground = Color.CYAN;
    protected Color unselectedForeground = Color.GREEN;
    
    protected Color selectedBackground = Color.LIGHT_GRAY;
    protected Color selectedForeground = Color.MAGENTA;
    
    protected ColorHighlighter emptyHighlighter;

    @Before
    public void setUpJ4() throws Exception {
        setUp();
    }
    
    @After
    public void tearDownJ4() throws Exception {
        tearDown();
    }
    
    @Override
    protected void setUp() {
        backgroundNull = new JLabel("test");
        backgroundNull.setForeground(foreground);
        backgroundNull.setBackground(null);
        
        foregroundNull = new JLabel("test");
        foregroundNull.setForeground(null);
        foregroundNull.setBackground(background);
        
        allNull = new JLabel("test");
        allNull.setForeground(null);
        allNull.setBackground(null);
        
        allColored = new JLabel("test");
        allColored.setForeground(foreground);
        allColored.setBackground(background);
        
        emptyHighlighter = new ColorHighlighter();
    }

    // ---------------- predefined predicate
    
    /**
     * Issue #858-swingx: predefined focus predicate. 
     * 
     * Test the IS_SELECTED predicate
     */
    @Test
    public void testIsSelected() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        assertTrue("sanity", adapter.isSelected());
        assertEquals(adapter.isSelected(), HighlightPredicate.IS_SELECTED.isHighlighted(allColored, adapter));
    }
    
    /**
     * Issue #858-swingx: predefined focus predicate. 
     * 
     * Test the IS_SELECTED predicate
     */
    @Test
    public void testNotIsSelected() {
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("sanity", adapter.isSelected());
        assertEquals(adapter.isSelected(), HighlightPredicate.IS_SELECTED.isHighlighted(allColored, adapter));
    }
    
    /**
     * Issue #858-swingx: predefined focus predicate. 
     * 
     * Test the HAS_FOCUS predicate
     */
    @Test
    public void testHasFocus() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true, true);
        assertTrue("sanity", adapter.hasFocus());
        assertEquals(adapter.hasFocus(), HighlightPredicate.HAS_FOCUS.isHighlighted(allColored, adapter));
     }
 
    /**
     * Issue #858-swingx: predefined focus predicate. 
     * 
     * Test the HAS_FOCUS predicate
     */
    @Test
    public void testNotHasFocus() {
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("sanity", adapter.hasFocus());
        assertEquals(adapter.hasFocus(), HighlightPredicate.HAS_FOCUS.isHighlighted(allColored, adapter));
     }

    /**
     * Issue #1371-swingx: IS_TEXT_TRUNCATED must respect insets
     */
    @Test
    public void testIsTextTruncatedRespectsBorder() {
        allColored.setBorder(BorderFactory.createEmptyBorder(1, 1, 1, 1));
        Insets insets = allColored.getBorder().getBorderInsets(allColored);
        Dimension preferredSize = allColored.getPreferredSize();
        preferredSize.width -= insets.left + insets.right;
        preferredSize.height -= insets.top + insets.bottom;
        allColored.setSize(preferredSize);
        ComponentAdapter adapter = createComponentAdapter(allColored, true, true);
        assertTrue(HighlightPredicate.IS_TEXT_TRUNCATED.isHighlighted(allColored, adapter));
    }

    /**
     * Issue #1314: predefined truncated text predicate. 
     * 
     * Test the IS_TEXT_TRUNCATED predicate
     */
    @Test
    public void testIsTextTruncated() {
        allColored.setSize(1, 1); //ensure the size is too small to display full String
        ComponentAdapter adapter = createComponentAdapter(allColored, true, true);
        assertTrue(HighlightPredicate.IS_TEXT_TRUNCATED.isHighlighted(allColored, adapter));
    }
    
    /**
     * Issue #1314: predefined truncated text predicate. 
     * 
     * Test the IS_TEXT_TRUNCATED predicate
     */
    @Test
    public void testNotIsTextTruncated() {
        allColored.setSize(allColored.getPreferredSize()); // ensure enough space to display text
        ComponentAdapter adapter = createComponentAdapter(allColored, true, true);
        assertFalse(HighlightPredicate.IS_TEXT_TRUNCATED.isHighlighted(allColored, adapter));
    }
    
    /**
     * test the IS_FOLDER predicate.
     *
     */
    @Test
    public void testFolder() {
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertTrue(HighlightPredicate.IS_FOLDER.isHighlighted(allColored, adapter));
    }
    
    /**
     * test the IS_FOLDER predicate.
     *
     */
    @Test
    public void testNotFolder() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        assertFalse(HighlightPredicate.IS_FOLDER.isHighlighted(allColored, adapter));
    }

    /**
     * test the IS_LEAF predicate.
     *
     */
    @Test
    public void testLeaf() {
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse(HighlightPredicate.IS_LEAF.isHighlighted(allColored, adapter));
    }
    
    /**
     * test the IS_LEAF predicate.
     *
     */
    @Test
    public void testNotLeaf() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        assertTrue(HighlightPredicate.IS_LEAF.isHighlighted(allColored, adapter));
    }
    
    /**
     * Can't really test the unconditional predicates.
     *
     */
    @Test
    public void testAlways() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        assertTrue(HighlightPredicate.ALWAYS.isHighlighted(allColored, adapter));
    }
    
    /**
     * Can't really test the unconditional predicates.
     *
     */
    @Test
    public void testNever() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        assertFalse(HighlightPredicate.NEVER.isHighlighted(allColored, adapter));
    }
    
    /**
     * test the Editable predicate.
     *
     */
    @Test
    public void testEditable() {
        ComponentAdapter adapter = createComponentAdapter(allColored, false, true);
        assertTrue(HighlightPredicate.EDITABLE.isHighlighted(allColored, adapter));
        assertFalse(HighlightPredicate.READ_ONLY.isHighlighted(allColored, adapter));
    }

    /**
     * test the ReadOnly predicate.
     *
     */
    @Test
    public void testNotEditable() {
        ComponentAdapter adapter = createComponentAdapter(allColored, false, false);
        assertFalse(HighlightPredicate.EDITABLE.isHighlighted(allColored, adapter));
        assertTrue(HighlightPredicate.READ_ONLY.isHighlighted(allColored, adapter));
    }
    
    /**
     * test access the contained predicates
     */
    @Test
    public void testNotProperty() {
        HighlightPredicate inputPredicates = new IdentifierHighlightPredicate("t");
        NotHighlightPredicate predicate = new NotHighlightPredicate(inputPredicates);
        HighlightPredicate predicates = predicate.getHighlightPredicate();
        assertSame(inputPredicates, predicates);
    }
    
    /**
     * test the NOT predicate.
     *
     */
    @Test
    public void testNot() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        HighlightPredicate notNever = new NotHighlightPredicate(HighlightPredicate.NEVER);
        assertTrue(notNever.isHighlighted(allColored, adapter));
        HighlightPredicate notAlways = new NotHighlightPredicate(HighlightPredicate.ALWAYS);
        assertFalse(notAlways.isHighlighted(allColored, adapter));
    }

    /**
     * test access the contained predicates
     */
    @Test
    public void testOrProperty() {
        List<HighlightPredicate> inputPredicates = new ArrayList<HighlightPredicate>();
        inputPredicates.add(HighlightPredicate.NEVER);
        inputPredicates.add(new IdentifierHighlightPredicate("t"));
        OrHighlightPredicate predicate = new OrHighlightPredicate(inputPredicates);
        HighlightPredicate[] predicates = predicate.getHighlightPredicates();
        assertEquals(inputPredicates.size(), predicates.length);
        for (int i = 0; i < predicates.length; i++) {
            assertSame(inputPredicates.get(i), predicates[i]);
        }
    }
    
    /**
     * test that getPredicates return empty array if nothing contained.
     */
    @Test
    public void testOrEmptyProperty() {
        OrHighlightPredicate predicate = new OrHighlightPredicate();
        HighlightPredicate[] predicates = predicate.getHighlightPredicates();
        assertNotNull("array must not be null", predicates);
        assertEquals(0, predicates.length);
    }

    /**
     * test that empty array doesn't highlight. 
     */
    @Test
    public void testOrEmpty() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        HighlightPredicate emptyArray = new OrHighlightPredicate();
        assertFalse(emptyArray.isHighlighted(allColored, adapter));
        HighlightPredicate emptyList = new OrHighlightPredicate(new ArrayList<HighlightPredicate>());
        assertFalse(emptyList.isHighlighted(allColored, adapter));
    }
    /**
     * test the OR predicate array constructor. Boring as it is, is it complete?
     *
     */
    @Test
    public void testOr() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        HighlightPredicate oneTrue = new OrHighlightPredicate(HighlightPredicate.ALWAYS);
        assertTrue(oneTrue.isHighlighted(allColored, adapter));
        HighlightPredicate oneFalse = new OrHighlightPredicate(HighlightPredicate.NEVER);
        assertFalse(oneFalse.isHighlighted(allColored, adapter));
        HighlightPredicate oneFalseOneTrue = new OrHighlightPredicate(
                HighlightPredicate.NEVER, HighlightPredicate.ALWAYS);
        assertTrue(oneFalseOneTrue.isHighlighted(allColored, adapter));
        HighlightPredicate oneTrueOneFalse = new OrHighlightPredicate(
                HighlightPredicate.ALWAYS, HighlightPredicate.NEVER);
        assertTrue(oneTrueOneFalse.isHighlighted(allColored, adapter));
    }
    
    /**
     * test the OR predicate collection constructor. Boring as it is, is it complete?
     *
     */
    @Test
    public void testOrCollectionConstructor() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        List<HighlightPredicate> containsOneTrue = new ArrayList<HighlightPredicate>();
        containsOneTrue.add(HighlightPredicate.ALWAYS);
        HighlightPredicate oneTrue = new OrHighlightPredicate(containsOneTrue);
        assertTrue(oneTrue.isHighlighted(allColored, adapter));
        
        List<HighlightPredicate> containsOneFalse = new ArrayList<HighlightPredicate>();
        containsOneFalse.add(HighlightPredicate.NEVER);
        HighlightPredicate oneFalse = new OrHighlightPredicate(containsOneFalse);
        assertFalse(oneFalse.isHighlighted(allColored, adapter));
        
        List<HighlightPredicate> containsOneFalseOneTrue = new ArrayList<HighlightPredicate>();
        containsOneFalseOneTrue.add(HighlightPredicate.NEVER);
        containsOneFalseOneTrue.add(HighlightPredicate.ALWAYS);
        HighlightPredicate oneFalseOneTrue = new OrHighlightPredicate(containsOneFalseOneTrue);
        assertTrue(oneFalseOneTrue.isHighlighted(allColored, adapter));

        List<HighlightPredicate> containsOneTrueOneFalse = new ArrayList<HighlightPredicate>();
        containsOneTrueOneFalse.add(HighlightPredicate.ALWAYS);
        containsOneTrueOneFalse.add(HighlightPredicate.NEVER);
        HighlightPredicate oneTrueOneFalse = new OrHighlightPredicate(containsOneTrueOneFalse);
        assertTrue(oneTrueOneFalse.isHighlighted(allColored, adapter));
    }
    
    /**
     * Issue #520-swingx: OrPredicate must throw if any of the parameters
     *   is null.
     *
     */
    @Test
    public void testOrThrowsOnNullPredicates() {
        try {
            new OrHighlightPredicate((HighlightPredicate[]) null);
            fail("orPredicate constructor must throw NullPointerException on null predicate");
            
        } catch (NullPointerException ex) {
            // do nothing - the doc'ed exception
        } catch (Exception ex) {
            fail("unexpected exception: " + ex);
        }

        try {
            new OrHighlightPredicate(HighlightPredicate.ALWAYS, null);
            fail("orPredicate constructor must throw NullPointerException on null predicate");
            
        } catch (NullPointerException ex) {
            // do nothing - the doc'ed exception
        } catch (Exception ex) {
            fail("unexpected exception: " + ex);
        }
            

        try {
            new OrHighlightPredicate((HighlightPredicate) null);
            fail("orPredicate constructor must throw NullPointerException on null predicate");
            
        } catch (NullPointerException ex) {
            // do nothing - the doc'ed exception
        } catch (Exception ex) {
            fail("unexpected exception: " + ex);
        }
            
        try {
            new OrHighlightPredicate((Collection<HighlightPredicate>) null);
            fail("orPredicate constructor must throw NullPointerException on null predicate");
            
        } catch (NullPointerException ex) {
            // do nothing - the doc'ed exception
        } catch (Exception ex) {
            fail("unexpected exception: " + ex);
        }
    }

    /**
     * Issue #520-swingx: OrPredicate must throw if any of the parameters
     *   is null.
     *
     */
    @Test
    public void testAndThrowsOnNullPredicates() {
        try {
            new AndHighlightPredicate((HighlightPredicate[]) null);
            fail("AndPredicate constructAnd must throw NullPointerException on null predicate");
            
        } catch (NullPointerException ex) {
            // do nothing - the doc'ed exception
        } catch (Exception ex) {
            fail("unexpected exception: " + ex);
        }

        try {
            new AndHighlightPredicate(HighlightPredicate.ALWAYS, null);
            fail("AndPredicate constructAnd must throw NullPointerException on null predicate");
            
        } catch (NullPointerException ex) {
            // do nothing - the doc'ed exception
        } catch (Exception ex) {
            fail("unexpected exception: " + ex);
        }
            

        try {
            new AndHighlightPredicate((HighlightPredicate) null);
            fail("AndPredicate constructAnd must throw NullPointerException on null predicate");
            
        } catch (NullPointerException ex) {
            // do nothing - the doc'ed exception
        } catch (Exception ex) {
            fail("unexpected exception: " + ex);
        }

        try {
            new AndHighlightPredicate((Collection<HighlightPredicate>) null);
            fail("orPredicate constructor must throw NullPointerException on null predicate");
            
        } catch (NullPointerException ex) {
            // do nothing - the doc'ed exception
        } catch (Exception ex) {
            fail("unexpected exception: " + ex);
        }

    }

    /**
     * test access the contained predicates
     */
    @Test
    public void testAndProperty() {
        List<HighlightPredicate> inputPredicates = new ArrayList<HighlightPredicate>();
        inputPredicates.add(HighlightPredicate.NEVER);
        inputPredicates.add(new IdentifierHighlightPredicate("t"));
        AndHighlightPredicate predicate = new AndHighlightPredicate(inputPredicates);
        HighlightPredicate[] predicates = predicate.getHighlightPredicates();
        assertEquals(inputPredicates.size(), predicates.length);
        for (int i = 0; i < predicates.length; i++) {
            assertSame(inputPredicates.get(i), predicates[i]);
        }
    }
    
    /**
     * test that getPredicates return empty array if nothing contained.
     */
    @Test
    public void testAndEmptyProperty() {
        AndHighlightPredicate predicate = new AndHighlightPredicate();
        HighlightPredicate[] predicates = predicate.getHighlightPredicates();
        assertNotNull("array must not be null", predicates);
        assertEquals(0, predicates.length);
    }
    
    /**
     * test that empty array doesn't highlight. 
     */
    @Test
    public void testAndEmpty() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        HighlightPredicate emptyArray = new AndHighlightPredicate();
        assertFalse(emptyArray.isHighlighted(allColored, adapter));
        HighlightPredicate emptyList = new AndHighlightPredicate(new ArrayList<HighlightPredicate>());
        assertFalse(emptyList.isHighlighted(allColored, adapter));
    }

    /**
     * test the AND predicate array constructor. Boring as it is, is it complete?
     *
     */
    @Test
    public void testAnd() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        HighlightPredicate oneTrue = new AndHighlightPredicate(HighlightPredicate.ALWAYS);
        assertTrue(oneTrue.isHighlighted(allColored, adapter));
        HighlightPredicate oneFalse = new AndHighlightPredicate(HighlightPredicate.NEVER);
        assertFalse(oneFalse.isHighlighted(allColored, adapter));
        HighlightPredicate oneFalseOneTrue = new AndHighlightPredicate(
                HighlightPredicate.NEVER, HighlightPredicate.ALWAYS);
        assertFalse(oneFalseOneTrue.isHighlighted(allColored, adapter));
        HighlightPredicate oneTrueOneFalse = new AndHighlightPredicate(
                HighlightPredicate.ALWAYS, HighlightPredicate.NEVER);
        assertFalse(oneTrueOneFalse.isHighlighted(allColored, adapter));
    }

    /**
     * test the AND predicate collection constructor. Boring as it is, is it complete?
     *
     */
    @Test
    public void testAndCollectionConstructor() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        List<HighlightPredicate> containsOneTrue = new ArrayList<HighlightPredicate>();
        containsOneTrue.add(HighlightPredicate.ALWAYS);
        HighlightPredicate oneTrue = new AndHighlightPredicate(containsOneTrue);
        assertTrue(oneTrue.isHighlighted(allColored, adapter));
        
        List<HighlightPredicate> containsOneFalse = new ArrayList<HighlightPredicate>();
        containsOneFalse.add(HighlightPredicate.NEVER);
        HighlightPredicate oneFalse = new AndHighlightPredicate(containsOneFalse);
        assertFalse(oneFalse.isHighlighted(allColored, adapter));
        
        List<HighlightPredicate> containsOneFalseOneTrue = new ArrayList<HighlightPredicate>();
        containsOneFalseOneTrue.add(HighlightPredicate.NEVER);
        containsOneFalseOneTrue.add(HighlightPredicate.ALWAYS);
        HighlightPredicate oneFalseOneTrue = new AndHighlightPredicate(containsOneFalseOneTrue);
        assertFalse(oneFalseOneTrue.isHighlighted(allColored, adapter));
        
        List<HighlightPredicate> containsOneTrueOneFalse = new ArrayList<HighlightPredicate>();
        containsOneTrueOneFalse.add(HighlightPredicate.ALWAYS);
        containsOneTrueOneFalse.add(HighlightPredicate.NEVER);
        HighlightPredicate oneTrueOneFalse = new AndHighlightPredicate(containsOneTrueOneFalse);
        assertFalse(oneTrueOneFalse.isHighlighted(allColored, adapter));
    }
    

    /**
     * test ROLLOVER_CELL
     *
     */
    @Test
    public void testRolloverCell() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        // rollover and adapter at 0, 0
        int row = 0; 
        int col = 0;
        allColored.putClientProperty(RolloverProducer.ROLLOVER_KEY, new Point(row, col));
        assertTrue(HighlightPredicate.ROLLOVER_CELL.isHighlighted(allColored, adapter));
        // move adapter row in same row
        adapter.row = 3;
        assertFalse(HighlightPredicate.ROLLOVER_CELL.isHighlighted(allColored, adapter));
        // move adapter row 
        adapter.column = 1;
        assertFalse(HighlightPredicate.ROLLOVER_CELL.isHighlighted(allColored, adapter));
    }
    
    /**
     * test ROLLOVER_COLUMN
     *
     */
    @Test
    public void testRolloverColumn() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        // rollover and adapter at 0, 0
        int row = 0; 
        int col = 0;
        allColored.putClientProperty(RolloverProducer.ROLLOVER_KEY, new Point(row, col));
        assertTrue(HighlightPredicate.ROLLOVER_COLUMN.isHighlighted(allColored, adapter));
        // move adapter row in same row
        adapter.row = 3;
        assertTrue(HighlightPredicate.ROLLOVER_COLUMN.isHighlighted(allColored, adapter));
        // move adapter row 
        adapter.column = 1;
        assertFalse(HighlightPredicate.ROLLOVER_COLUMN.isHighlighted(allColored, adapter));
    }
    
    /**
     * test ROLLOVER_ROW
     *
     */
    @Test
    public void testRolloverRow() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        // rollover and adapter at 0, 0
        int row = 0; 
        int col = 0;
        allColored.putClientProperty(RolloverProducer.ROLLOVER_KEY, new Point(row, col));
        assertTrue(HighlightPredicate.ROLLOVER_ROW.isHighlighted(allColored, adapter));
        // move adapter column in same row
        adapter.column = 3;
        assertTrue(HighlightPredicate.ROLLOVER_ROW.isHighlighted(allColored, adapter));
        // move adapter row 
        adapter.row = 1;
        assertFalse(HighlightPredicate.ROLLOVER_ROW.isHighlighted(allColored, adapter));
    }
    
    /**
     * Issue #513-swingx: no rollover highlight for disabled component
     * 
     */
    @Test
    public void testRolloverRowDisabledComponent() {
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        // rollover and adapter at 0, 0
        int row = 0; 
        int col = 0;
        allColored.putClientProperty(RolloverProducer.ROLLOVER_KEY, new Point(row, col));
        // sanity
        assertTrue(HighlightPredicate.ROLLOVER_ROW.isHighlighted(allColored, adapter));
        allColored.setEnabled(false);
        assertFalse(HighlightPredicate.ROLLOVER_ROW.isHighlighted(allColored, adapter));
    }

    /**
     * test the BIG_DECIMAL_NEGATIVE predicate.
     *
     */
    @Test
    public void testBigDecimalNegative() {
        ComponentAdapter negative = createBigDecimalComponentAdapter(new JLabel("-50.00"));
        assertTrue(HighlightPredicate.BIG_DECIMAL_NEGATIVE.isHighlighted(negative.getComponent(), negative));
        ComponentAdapter positive = createBigDecimalComponentAdapter(new JLabel("50.00"));
        assertFalse(HighlightPredicate.BIG_DECIMAL_NEGATIVE.isHighlighted(positive.getComponent(), positive));
        ComponentAdapter zero = createBigDecimalComponentAdapter(new JLabel(BigDecimal.ZERO.toString()));
        // sanity
        assertEquals(BigDecimal.ZERO, zero.getValue());
        assertFalse(HighlightPredicate.BIG_DECIMAL_NEGATIVE.isHighlighted(zero.getComponent(), zero));
        
    }

//---------------- special predicates
    /**
     * test doc'ed behaviour
     */
    @Test
    public void testRowGroupConstructor() {
        try {
            new RowGroupHighlightPredicate(0);
            fail("RowGroupHighlight must throw IllegalArgumentException for lines < 1");
        } catch (IllegalArgumentException ex) {
            // expected behaviour
        } 
    }
    
    @Test
    public void testRowGroupProperty() {
        int lines = 5;
        RowGroupHighlightPredicate predicate = new RowGroupHighlightPredicate(5);
        assertEquals(lines, predicate.getLinesPerGroup());
    }
    
    /**
     * test equals predicate with null value.
     */
    @Test
    public void testEqualsNull() {
        HighlightPredicate predicate = new EqualsHighlightPredicate();
        allColored.setText(null);
        assertNull(allColored.getText());
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertTrue(predicate.isHighlighted(allColored, adapter));
        String text = "test";
        allColored.setText(text);
        assertEquals(text, allColored.getText());
        assertFalse(predicate.isHighlighted(allColored, adapter));
    }
    
    /**
     * test equals predicate with not null value.
     *
     */
    @Test
    public void testEqualsNotNull() {
        HighlightPredicate predicate = new EqualsHighlightPredicate(allColored
                .getText());
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertTrue(predicate.isHighlighted(allColored, adapter));
        allColored.setText(null);
        assertFalse(predicate.isHighlighted(allColored, adapter));
    }
    
    /**
     * test equals predicate with not null value.
     *
     */
    @Test
    public void testEqualProperty() {
        Object text = new Object();
        EqualsHighlightPredicate predicate = new EqualsHighlightPredicate(text);
        assertEquals(text, predicate.getCompareValue());
    }
    
    @Test
    public void testColumnProperty() {
        int[] columns = new int[] {2, 7};
        ColumnHighlightPredicate predicate = new ColumnHighlightPredicate(columns);
        Integer[] output = predicate.getColumns();
        assertEquals(columns.length, output.length);
        for (int i = 0; i < output.length; i++) {
            assertEquals(columns[i], output[i].intValue());
        }
    }

    @Test
    public void testColumnEmptyProperty() {
        ColumnHighlightPredicate predicate = new ColumnHighlightPredicate();
        Integer[] output = predicate.getColumns();
        assertEquals("output must be empty array", 0, output.length);
    }

    @Test
    public void testColumn() {
        HighlightPredicate predicate = new ColumnHighlightPredicate(1);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("column 0 must not be highlighted", predicate.isHighlighted(allColored, adapter));
        adapter.column = 1;
        assertTrue("column 1 must be highlighted", predicate.isHighlighted(allColored, adapter));
    }


    @Test
    public void testDepthProperty() {
        int[] columns = new int[] {2, 7};
        DepthHighlightPredicate predicate = new DepthHighlightPredicate(columns);
        Integer[] output = predicate.getDepths();
        assertEquals(columns.length, output.length);
        for (int i = 0; i < output.length; i++) {
            assertEquals(columns[i], output[i].intValue());
        }
    }

    @Test
    public void testDepthEmptyProperty() {
        DepthHighlightPredicate predicate = new DepthHighlightPredicate();
        Integer[] output = predicate.getDepths();
        assertEquals("output must be empty array", 0, output.length);
    }

    @Test
    public void testIdentifierProperty() {
        Object[] identifiers = new Object[] { "one", "two" };
        IdentifierHighlightPredicate predicate = new IdentifierHighlightPredicate(identifiers);
        Object[] output = predicate.getIdentifiers();
        assertEquals(identifiers.length, output.length);
        for (int i = 0; i < output.length; i++) {
            assertEquals(identifiers[i], output[i]);
        }
    }

    @Test
    public void testIdentifierEmptyProperty() {
        IdentifierHighlightPredicate predicate = new IdentifierHighlightPredicate();
        Object[] output = predicate.getIdentifiers();
        assertEquals("output must be empty array", 0, output.length);
    }

    @Test
    public void testIdentifierDefault() {
        HighlightPredicate predicate = new IdentifierHighlightPredicate(ComponentAdapter.DEFAULT_COLUMN_IDENTIFIER);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertTrue("default (single) column must be highlighted", predicate.isHighlighted(allColored, adapter));
    }

    @Test
    public void testIdentifierFalse() {
        HighlightPredicate predicate = new IdentifierHighlightPredicate("unknown");
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("unknown identifier must not highlight", predicate.isHighlighted(allColored, adapter));
    }

//--------------------- TypeHighlightPredicate
 
    @Test (expected = NullPointerException.class)
    public void testTypeNull() {
        new TypeHighlightPredicate(null);
    }
    

    @Test
    public void testTypeProperty() {
        Class<?> clazz = String.class;
        TypeHighlightPredicate predicate = new TypeHighlightPredicate(clazz);
        assertEquals(clazz, predicate.getType());
    }
    
    @Test
    public void testTypeExact() {
        HighlightPredicate predicate = new TypeHighlightPredicate(String.class);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertTrue("string class must be highlighted", predicate.isHighlighted(allColored, adapter));
    }
    
    @Test
    public void testTypeSubclass() {
        HighlightPredicate predicate = new TypeHighlightPredicate();
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertTrue("string class must be highlighted", predicate.isHighlighted(allColored, adapter));
    }
    
    @Test
    public void testTypeFalse() {
        HighlightPredicate predicate = new TypeHighlightPredicate(Integer.class);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("string class must be highlighted", predicate.isHighlighted(allColored, adapter));
    }
    
//----------------------- ColumnTypePredicate
    
    @Test (expected = NullPointerException.class)
    public void testColumnTypeNull() {
        new ColumnTypeHighlightPredicate(null);
    }
    
    @Test
    public void testColumnTypeProperty() {
        Class<?> clazz = String.class;
        ColumnTypeHighlightPredicate predicate = new ColumnTypeHighlightPredicate(clazz);
        assertEquals(clazz, predicate.getType());
    }
    
    @Test
    public void testColumnTypeExact() {
        HighlightPredicate predicate = new ColumnTypeHighlightPredicate(String.class);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertTrue("string class must be highlighted", predicate.isHighlighted(allColored, adapter));
    }

    @Test
    public void testColumnTypeSubclass() {
        HighlightPredicate predicate = new ColumnTypeHighlightPredicate();
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertTrue("string class must be highlighted", predicate.isHighlighted(allColored, adapter));
    }

    @Test
    public void testColumnTypeFalse() {
        HighlightPredicate predicate = new ColumnTypeHighlightPredicate(Integer.class);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("string class must be highlighted", predicate.isHighlighted(allColored, adapter));
    }
    
// ------ stand-alone predicates    
    
    
    /**
     * Issue #1317-swingx: PatternPredicate causes exception with testColumn -1 (ALL)
     * 
     */
    @Test
    public void testPatternPredicateAllColumns() {
        JXTable table = new JXTable(new AncientSwingTeam());
        PatternPredicate predicate = new PatternPredicate(".*e.*");
        table.addHighlighter(new ColorHighlighter(predicate, Color.BLUE, null));
        for (int i = 0; i < table.getRowCount(); i++) {
            for (int j = 0; j < table.getColumnCount(); j++) {
                TableCellRenderer renderer = table.getCellRenderer(i, j);
                table.prepareRenderer(renderer, i, j);
            }
        }
    }



    @Test
    public void testPattern() {
        // start with "t"
        Pattern pattern = Pattern.compile("^t", 0);
        int testColumn = 0;
        int decorateColumn = 0;
        HighlightPredicate predicate = new PatternPredicate(pattern, testColumn, decorateColumn);
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        assertEquals("predicate must have same result as matcher", pattern.matcher(allColored.getText()).find(), 
                  predicate.isHighlighted(allColored, adapter));
    }
    
    @Test
    public void testPatternWithString() {
        // start with "t"
        String regex = "^t";
        int testColumn = 0;
        int decorateColumn = 0;
        PatternPredicate predicate = new PatternPredicate(regex, testColumn, decorateColumn);
        Pattern pattern = Pattern.compile(regex);
        assertEquals(pattern.pattern(), predicate.getPattern().pattern());
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        assertEquals("predicate must have same result as matcher", pattern.matcher(allColored.getText()).find(), 
                  predicate.isHighlighted(allColored, adapter));
    }
    
    @Test
    public void testPatternTwoParamConstructorWithString() {
        // start with "t"
        String regex = "^t";
        int testColumn = 0;
        HighlightPredicate predicate = new PatternPredicate(regex, testColumn);
        Pattern pattern = Pattern.compile(regex);
        ComponentAdapter adapter = createComponentAdapter(allColored, true);
        assertEquals("predicate must have same result as matcher", pattern.matcher(allColored.getText()).find(), 
                  predicate.isHighlighted(allColored, adapter));
    }
 
    @Test
    public void testSearchHighlightConstructorOne() {
        Pattern pattern = Pattern.compile("^t");
        SearchPredicate predicate = new SearchPredicate(pattern);
        assertEquals(pattern, predicate.getPattern());
        assertEquals(SearchPredicate.ALL, predicate.getHighlightColumn());
        assertEquals(SearchPredicate.ALL, predicate.getHighlightRow());
    }

    @Test
    public void testSearchHighlightConstructorTwo() {
        Pattern pattern = Pattern.compile("^t");
        int column = 10;
        SearchPredicate predicate = new SearchPredicate(pattern, column);
        assertEquals(pattern, predicate.getPattern());
        assertEquals(column, predicate.getHighlightColumn());
        assertEquals(SearchPredicate.ALL, predicate.getHighlightRow());
    }
    
    @Test
    public void testSearchHighlightConstructorFull() {
        Pattern pattern = Pattern.compile("^t");
        int row = 5;
        int column = 10;
        SearchPredicate predicate = new SearchPredicate(pattern, row, column);
        assertEquals(pattern, predicate.getPattern());
        assertEquals(column, predicate.getHighlightColumn());
        assertEquals(row, predicate.getHighlightRow());
    }
    /**
     * test match in all cells.
     *
     */
    @Test
    public void testSearchHighlightAllMatches() {
        // start with "t"
        Pattern pattern = Pattern.compile("^t");
        HighlightPredicate predicate = new SearchPredicate(pattern);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertEquals("predicate must have same result as matcher", pattern.matcher(allColored.getText()).find(), 
                  predicate.isHighlighted(allColored, adapter));
        adapter.row = 5;
        adapter.column = 10;
        assertEquals("predicate must have same result as matcher", pattern.matcher(allColored.getText()).find(), 
                predicate.isHighlighted(allColored, adapter));
    }
    
    /**
     * test match limited by column.
     *
     */
    @Test
    public void testSearchHighlightColumn() {
        // start with "t"
        Pattern pattern = Pattern.compile("^t");
        int column = 2;
        HighlightPredicate predicate = new SearchPredicate(pattern, column);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("predicate must not match", 
                  predicate.isHighlighted(allColored, adapter));
        adapter.column = column;
        assertTrue("predicate must match", 
                predicate.isHighlighted(allColored, adapter));
    }
    
    /**
     * test match limited by row.
     *
     */
    @Test
    public void testSearchHighlightRow() {
        // start with "t"
        Pattern pattern = Pattern.compile("^t");
        int row = 2;
        HighlightPredicate predicate = new SearchPredicate(pattern, row, SearchPredicate.ALL);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("predicate must not match", 
                  predicate.isHighlighted(allColored, adapter));
        adapter.row = row;
        assertTrue("predicate must match", 
                predicate.isHighlighted(allColored, adapter));
    }
    
    /**
     * test match limited by row and column.
     *
     */
    @Test
    public void testSearchHighlightRowAndColumn() {
        // start with "t"
        Pattern pattern = Pattern.compile("^t");
        int row = 2;
        int column = 2;
        HighlightPredicate predicate = new SearchPredicate(pattern, row, column);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("predicate must not match", 
                  predicate.isHighlighted(allColored, adapter));
        adapter.row = row;
        adapter.column = column;
        assertTrue("predicate must match", 
                predicate.isHighlighted(allColored, adapter));
    }
    
    /**
     * test match in all cells using regex constructor.
     *
     */
    @Test
    public void testSearchHighlightAllMatchesWithString() {
        // start with "t"
        String regex = "^t";
        HighlightPredicate predicate = new SearchPredicate(regex);
        Pattern pattern = Pattern.compile(regex);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertEquals("predicate must have same result as matcher", pattern.matcher(allColored.getText()).find(), 
                  predicate.isHighlighted(allColored, adapter));
        adapter.row = 5;
        adapter.column = 10;
        assertEquals("predicate must have same result as matcher", pattern.matcher(allColored.getText()).find(), 
                predicate.isHighlighted(allColored, adapter));
    }
    
    /**
     * test match limited by column using regex constructor.
     *
     */
    @Test
    public void testSearchHighlightColumnWithString() {
        // start with "t"
        String regex = "^t";
        int column = 2;
        HighlightPredicate predicate = new SearchPredicate(regex, column);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("predicate must not match", 
                  predicate.isHighlighted(allColored, adapter));
        adapter.column = column;
        assertTrue("predicate must match", 
                predicate.isHighlighted(allColored, adapter));
    }
    
    /**
     * test match limited by row using regex constructor.
     *
     */
    @Test
    public void testSearchHighlightRowWithString() {
        // start with "t"
        String regex = "^t";
        int row = 2;
        HighlightPredicate predicate = new SearchPredicate(regex, row, SearchPredicate.ALL);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertFalse("predicate must not match", 
                  predicate.isHighlighted(allColored, adapter));
        adapter.row = row;
        assertTrue("predicate must match", 
                predicate.isHighlighted(allColored, adapter));
    }

    @Test
    public void testSearchHighlightNullString() {
        // start with "t"
        String regex = null;
        HighlightPredicate predicate = new SearchPredicate(regex);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertEquals("null regex must be no match", false, 
                  predicate.isHighlighted(allColored, adapter));
    }
    
    @Test
    public void testSearchHighlightEmptyString() {
        // start with "t"
        String regex = "";
        HighlightPredicate predicate = new SearchPredicate(regex);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertEquals("empty regex must be no match", false, 
                  predicate.isHighlighted(allColored, adapter));
    }
    
    @Test
    public void testSearchHighlightNullPattern() {
        Pattern pattern = null;
        HighlightPredicate predicate = new SearchPredicate(pattern);
        ComponentAdapter adapter = createComponentAdapter(allColored, false);
        assertEquals("null pattern must be no match", false, 
                  predicate.isHighlighted(allColored, adapter));
    }
    
    
    // --------------------- factory methods
    /**
     * Creates and returns a ComponentAdapter on the given 
     * label with the specified selection state and non-editable.
     * 
     * @param label the adapter's component
     * @param selected the adapter's selected property
     * @return a ComponentAdapter of the label with the given properties.
     */
    protected ComponentAdapter createComponentAdapter(final JLabel label, final boolean selected) {
        return createComponentAdapter(label, selected, false);
    }

    /**
     * Creates and returns a ComponentAdapter on the given 
     * label with the specified selection and editable state. IsLeaf returns
     * the same value as selected. HasFocus returns selected && editable.
     * 
     * @param label the adapter's component
     * @param selected the adapter's selected property
     * @param editable the adapter's editable property
     * @return a ComponentAdapter of the label with the given properties.
     */
    protected ComponentAdapter createComponentAdapter(final JLabel label,
            final boolean selected, final boolean editable) {
        ComponentAdapter adapter = new ComponentAdapter(label) {

            @Override
            public Object getValueAt(int row, int column) {
                return label.getText();
            }

            @Override
            public Object getFilteredValueAt(int row, int column) {
                return getValueAt(row, column);
            }

            
            @Override
            public Object getValue() {
                return getValueAt(row, column);
            }

            @Override
            public boolean isCellEditable(int row, int column) {
                return isEditable();
            }

            @Override
            public boolean hasFocus() {
                return isSelected() && isEditable();
            }
            
            @Override
            public boolean isEditable() {
                return editable;
            }

            @Override
            public boolean isSelected() {
                return selected;
            }

            
            @Override
            public boolean isLeaf() {
                return isSelected();
            }

            @Override
            public String getColumnName(int columnIndex) {
                return null;
            }

            /** 
             * @inherited <p>
             */
            @Override
            public Class<?> getColumnClass(int column) {
                return String.class;
            }

            
        };
        return adapter;
    }
    
    /**
     * Creates and returns a ComponentAdapter on the given 
     * label. The labels text is parsed as BigDecimal.
     * 
     * @param label
     * @return
     */
    protected ComponentAdapter createBigDecimalComponentAdapter(final JLabel label) {
        ComponentAdapter adapter = new ComponentAdapter(label) {

            @Override
            public Object getValueAt(int row, int column) {
                return new BigDecimal(label.getText());
            }

            @Override
            public Object getFilteredValueAt(int row, int column) {
                return getValueAt(row, column);
            }

            @Override
            public Object getValue() {
                return getValueAt(row, column);
            }

            @Override
            public boolean isCellEditable(int row, int column) {
                // TODO Auto-generated method stub
                return false;
            }

            @Override
            public boolean hasFocus() {
                // TODO Auto-generated method stub
                return false;
            }
            
            @Override
            public boolean isEditable() {
                return false;
            }

            @Override
            public boolean isSelected() {
                return false;
            }

            @Override
            public String getColumnName(int columnIndex) {
                return null;
            }

            
        };
        return adapter;
    }
}
