/******************************************************************************
 * Copyright (c) 2005-2007 BEA Systems, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Konstantin Komissarchik
 ******************************************************************************/

package org.eclipse.wst.common.project.facet.core.tests;

import static org.eclipse.wst.common.project.facet.core.tests.support.TestUtils.asSet;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.wst.common.project.facet.core.ICategory;
import org.eclipse.wst.common.project.facet.core.IConstraint;
import org.eclipse.wst.common.project.facet.core.IGroup;
import org.eclipse.wst.common.project.facet.core.IProjectFacet;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;

/**
 * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
 */

public final class BasicTests

    extends TestCase
    
{
    private static final String PLUGIN_ID 
        = "org.eclipse.wst.common.project.facet.core.tests";
    
    public static IProjectFacet f1;
    public static IProjectFacetVersion f1v10;
    public static IProjectFacetVersion f1v12;
    public static IProjectFacetVersion f1v121;
    public static IProjectFacetVersion f1v13;
    public static IProjectFacetVersion f1v20;
    
    public static IProjectFacet f2;
    public static IProjectFacetVersion f2v35;
    public static IProjectFacetVersion f2v35a;
    public static IProjectFacetVersion f2v47;
    public static IProjectFacetVersion f2v47b;
    public static IProjectFacetVersion f2v47c;
    
    public static IProjectFacet f2ext;
    public static IProjectFacetVersion f2extv10;

    public static IProjectFacet f3a;
    public static IProjectFacetVersion f3av10;
    public static IProjectFacetVersion f3av20;

    public static IProjectFacet f3b;
    public static IProjectFacetVersion f3bv10;
    public static IProjectFacetVersion f3bv20;

    public static IProjectFacet f3c;
    public static IProjectFacetVersion f3cv10;
    public static IProjectFacetVersion f3cv20;

    static
    {
        try
        {
            f1 = ProjectFacetsManager.getProjectFacet( "facet1" );
            f1v10 = f1.getVersion( "1.0" );
            f1v12 = f1.getVersion( "1.2" );
            f1v121 = f1.getVersion( "1.2.1" );
            f1v13 = f1.getVersion( "1.3" );
            f1v20 = f1.getVersion( "2.0" );
            
            f2 = ProjectFacetsManager.getProjectFacet( "facet2" );
            f2v35 = f2.getVersion( "3.5" );
            f2v35a = f2.getVersion( "3.5#a" );
            f2v47 = f2.getVersion( "4.7" );
            f2v47b = f2.getVersion( "4.7#b" );
            f2v47c = f2.getVersion( "4.7#c" );
            
            f2ext = ProjectFacetsManager.getProjectFacet( "facet2ext" );
            f2extv10 = f2ext.getVersion( "1.0" );

            f3a = ProjectFacetsManager.getProjectFacet( "facet3a" );
            f3av10 = f3a.getVersion( "1.0" );
            f3av20 = f3a.getVersion( "2.0" );

            f3b = ProjectFacetsManager.getProjectFacet( "facet3b" );
            f3bv10 = f3b.getVersion( "1.0" );
            f3bv20 = f3b.getVersion( "2.0" );

            f3c = ProjectFacetsManager.getProjectFacet( "facet3c" );
            f3cv10 = f3c.getVersion( "1.0" );
            f3cv20 = f3c.getVersion( "2.0" );
        }
        catch( Exception e )
        {
            // Ignore failures. This api is tested explicitly.
        }
    }
    
    private BasicTests( final String name )
    {
        super( name );
    }
    
    public static Test suite()
    {
        final TestSuite suite = new TestSuite();
        
        suite.setName( "Basic Tests" );

        suite.addTest( new BasicTests( "testProjectFacetExtensionPoint" ) );
        suite.addTest( new BasicTests( "testProjectFacetVersionExtensionPoint" ) );
        suite.addTest( new BasicTests( "testCategoryExtensionPoint" ) );
        suite.addTest( new BasicTests( "testDefaultVersionComparator" ) );
        suite.addTest( new BasicTests( "testCustomVersionComparator" ) );
        suite.addTest( new BasicTests( "testVersionExpressions" ) );
        suite.addTest( new BasicTests( "testVersionExpressionsWithUnknownVersions" ) );
        suite.addTest( new BasicTests( "testConstraints" ) );
        suite.addTest( new BasicTests( "testConstraintApi" ) );
        
        return suite;
    }
    
    public void testProjectFacetExtensionPoint()
    {
        assertTrue( ProjectFacetsManager.isProjectFacetDefined( "facet1" ) );
        final IProjectFacet f1 = ProjectFacetsManager.getProjectFacet( "facet1" );
        assertTrue( ProjectFacetsManager.getProjectFacets().contains( f1 ) );
        
        assertEquals( f1.getId(), "facet1" );
        assertEquals( f1.getLabel(), "Facet 1" );
        assertEquals( f1.getDescription(), "This is the description of facet1." );
        assertEquals( f1.getPluginId(), PLUGIN_ID );
        
        assertTrue( ProjectFacetsManager.isProjectFacetDefined( "facet2" ) );
        final IProjectFacet f2 = ProjectFacetsManager.getProjectFacet( "facet2" );
        assertTrue( ProjectFacetsManager.getProjectFacets().contains( f2 ) );
        
        assertEquals( f2.getId(), "facet2" );
        assertEquals( f2.getLabel(), "facet2" );
        assertEquals( f2.getDescription(), "" );
        assertEquals( f2.getPluginId(), PLUGIN_ID );
    }
    
    public void testProjectFacetVersionExtensionPoint()
    {
        assertTrue( f1.hasVersion( "1.0" ) );
        final IProjectFacetVersion f1v10 = f1.getVersion( "1.0" );
        assertEquals( f1v10.getVersionString(), "1.0" );
        assertEquals( f1v10.getProjectFacet(), f1 );
        assertEquals( f1v10.getPluginId(), PLUGIN_ID );

        assertTrue( f1.hasVersion( "1.2" ) );
        final IProjectFacetVersion f1v12 = f1.getVersion( "1.2" );
        assertEquals( f1v12.getVersionString(), "1.2" );
        assertEquals( f1v12.getProjectFacet(), f1 );
        assertEquals( f1v12.getPluginId(), PLUGIN_ID );

        assertTrue( f1.hasVersion( "1.2.1" ) );
        final IProjectFacetVersion f1v121 = f1.getVersion( "1.2.1" );
        assertEquals( f1v121.getVersionString(), "1.2.1" );
        assertEquals( f1v121.getProjectFacet(), f1 );
        assertEquals( f1v121.getPluginId(), PLUGIN_ID );

        assertTrue( f1.hasVersion( "1.3" ) );
        final IProjectFacetVersion f1v13 = f1.getVersion( "1.3" );
        assertEquals( f1v13.getVersionString(), "1.3" );
        assertEquals( f1v13.getProjectFacet(), f1 );
        assertEquals( f1v13.getPluginId(), PLUGIN_ID );

        assertTrue( f1.hasVersion( "2.0" ) );
        final IProjectFacetVersion f1v20 = f1.getVersion( "2.0" );
        assertEquals( f1v20.getVersionString(), "2.0" );
        assertEquals( f1v20.getProjectFacet(), f1 );
        assertEquals( f1v20.getPluginId(), PLUGIN_ID );
        
        assertEquals( f1.getVersions(),
                      asSet( f1v10, f1v12, f1v121, f1v13, f1v20 ) );

        assertTrue( f2.hasVersion( "3.5" ) );
        final IProjectFacetVersion f2v35 = f2.getVersion( "3.5" );
        assertEquals( f2v35.getVersionString(), "3.5" );
        assertEquals( f2v35.getProjectFacet(), f2 );
        assertEquals( f2v35.getPluginId(), PLUGIN_ID );

        assertTrue( f2.hasVersion( "3.5#a" ) );
        final IProjectFacetVersion f2v35a = f2.getVersion( "3.5#a" );
        assertEquals( f2v35a.getVersionString(), "3.5#a" );
        assertEquals( f2v35a.getProjectFacet(), f2 );
        assertEquals( f2v35a.getPluginId(), PLUGIN_ID );
        
        assertTrue( f2.hasVersion( "4.7" ) );
        final IProjectFacetVersion f2v47 = f2.getVersion( "4.7" );
        assertEquals( f2v47.getVersionString(), "4.7" );
        assertEquals( f2v47.getProjectFacet(), f2 );
        assertEquals( f2v47.getPluginId(), PLUGIN_ID );

        assertTrue( f2.hasVersion( "4.7#b" ) );
        final IProjectFacetVersion f2v47b = f2.getVersion( "4.7#b" );
        assertEquals( f2v47b.getVersionString(), "4.7#b" );
        assertEquals( f2v47b.getProjectFacet(), f2 );
        assertEquals( f2v47b.getPluginId(), PLUGIN_ID );

        assertTrue( f2.hasVersion( "4.7#c" ) );
        final IProjectFacetVersion f2v47c = f2.getVersion( "4.7#c" );
        assertEquals( f2v47c.getVersionString(), "4.7#c" );
        assertEquals( f2v47c.getProjectFacet(), f2 );
        assertEquals( f2v47c.getPluginId(), PLUGIN_ID );
        
        assertEquals( f2.getVersions(), 
                      asSet( f2v35, f2v35a, f2v47, f2v47b, f2v47c ) );
        
        // Check for version that doesn't exist.
        
        assertFalse( f2.hasVersion( "6.9" ) );
        
        try
        {
            f2.getVersion( "6.9" );
            fail();
        }
        catch( IllegalArgumentException e ) {}
    }
    
    public void testCategoryExtensionPoint()
    {
        assertTrue( ProjectFacetsManager.isCategoryDefined( "cat1" ) );
        final ICategory cat1 = ProjectFacetsManager.getCategory( "cat1" );
        assertTrue( ProjectFacetsManager.getCategories().contains( cat1 ) );
        
        assertEquals( cat1.getId(), "cat1" );
        assertEquals( cat1.getLabel(), "Category 1" );
        assertEquals( cat1.getDescription(), "This is the category description." );
        assertEquals( cat1.getPluginId(), PLUGIN_ID );

        assertEquals( cat1.getProjectFacets(), asSet( f2, f2ext ) );
        assertEquals( f2.getCategory(), cat1 );
        assertEquals( f2ext.getCategory(), cat1 );
        
        assertTrue( ProjectFacetsManager.isCategoryDefined( "cat2" ) );
        final ICategory cat2 = ProjectFacetsManager.getCategory( "cat2" );
        assertTrue( ProjectFacetsManager.getCategories().contains( cat2 ) );
        
        assertEquals( cat2.getId(), "cat2" );
        assertEquals( cat2.getLabel(), "cat2" );
        assertEquals( cat2.getDescription(), "" );
        assertEquals( cat2.getPluginId(), PLUGIN_ID );
        
        assertEquals( cat2.getProjectFacets(), asSet( f3a, f3b, f3c ) );
        assertEquals( f3a.getCategory(), cat2 );
        assertEquals( f3b.getCategory(), cat2 );
        assertEquals( f3c.getCategory(), cat2 );
    }
    
    @SuppressWarnings( "unchecked" )
    public void testDefaultVersionComparator()
    
        throws CoreException
        
    {
        final Comparator<String> comp = f1.getVersionComparator();
        
        assertEquals( comp.getClass().getName(), 
                      "org.eclipse.wst.common.project.facet.core.DefaultVersionComparator" );
        
        assertTrue( comp.compare( "1.0", "1.2" ) < 0 );
        assertTrue( comp.compare( "1.2", "1.2.1" ) < 0 );
        assertTrue( comp.compare( "1.2.1", "2.0" ) < 0 );
        
        assertTrue( comp.compare( "1.2", "1.0" ) > 0 );
        assertTrue( comp.compare( "1.2.1", "1.2" ) > 0 );
        assertTrue( comp.compare( "2.0", "1.2.1" ) > 0 );
        
        assertTrue( comp.compare( "1.0", "1.0" ) == 0 );
        assertTrue( comp.compare( "1.2", "1.2" ) == 0 );
        assertTrue( comp.compare( "1.2.1", "1.2.1" ) == 0 );
        assertTrue( comp.compare( "2.0", "2.0" ) == 0 );
        
        assertTrue( f1v10.compareTo( f1v12 ) < 0 );
        assertTrue( f1v12.compareTo( f1v121 ) < 0 );
        assertTrue( f1v121.compareTo( f1v20 ) < 0 );
        
        assertTrue( f1v12.compareTo( f1v10 ) > 0 );
        assertTrue( f1v121.compareTo( f1v12 ) > 0 );
        assertTrue( f1v20.compareTo( f1v121 ) > 0 );
        
        assertTrue( f1v10.compareTo( f1v10 ) == 0 );
        assertTrue( f1v12.compareTo( f1v12 ) == 0 );
        assertTrue( f1v121.compareTo( f1v121 ) == 0 );
        assertTrue( f1v20.compareTo( f1v20 ) == 0 );

        assertEquals( f1.getLatestVersion(), f1v20 );
        
        final List asc = f1.getSortedVersions( true );
        
        assertEquals( asc.size(), 5 );
        assertEquals( asc.get( 0 ), f1v10 );
        assertEquals( asc.get( 1 ), f1v12 );
        assertEquals( asc.get( 2 ), f1v121 );
        assertEquals( asc.get( 3 ), f1v13 );
        assertEquals( asc.get( 4 ), f1v20 );
        
        final List desc = f1.getSortedVersions( false );
        
        assertEquals( desc.size(), 5 );
        assertEquals( desc.get( 0 ), f1v20 );
        assertEquals( desc.get( 1 ), f1v13 );
        assertEquals( desc.get( 2 ), f1v121 );
        assertEquals( desc.get( 3 ), f1v12 );
        assertEquals( desc.get( 4 ), f1v10 );
    }

    @SuppressWarnings( "unchecked" )
    public void testCustomVersionComparator()
    
        throws CoreException
        
    {
        final Comparator<String> comp = f2.getVersionComparator();
        
        assertEquals( comp.getClass().getName(), 
                      "org.eclipse.wst.common.project.facet.core.tests.support.CustomVersionComparator" );
        
        assertTrue( comp.compare( "3.5", "4.7" ) < 0 );
        assertTrue( comp.compare( "3.5", "3.5#a" ) < 0 );
        assertTrue( comp.compare( "4.7#c", "4.7#b" ) < 0 );
        
        assertTrue( comp.compare( "4.7", "3.5" ) > 0 );
        assertTrue( comp.compare( "3.5#a", "3.5" ) > 0 );
        assertTrue( comp.compare( "4.7#b", "4.7#c" ) > 0 );
        
        assertTrue( comp.compare( "3.5", "3.5" ) == 0 );
        assertTrue( comp.compare( "3.5#a", "3.5#a" ) == 0 );
        assertTrue( comp.compare( "4.7", "4.7" ) == 0 );
        assertTrue( comp.compare( "4.7#b", "4.7#b" ) == 0 );

        assertTrue( f2v35.compareTo( f2v47 ) < 0 );
        assertTrue( f2v35.compareTo( f2v35a ) < 0 );
        assertTrue( f2v47c.compareTo( f2v47b ) < 0 );
        
        assertTrue( f2v47.compareTo( f2v35 ) > 0 );
        assertTrue( f2v35a.compareTo( f2v35 ) > 0 );
        assertTrue( f2v47b.compareTo( f2v47c ) > 0 );
        
        assertTrue( f2v35.compareTo( f2v35 ) == 0 );
        assertTrue( f2v35a.compareTo( f2v35a ) == 0 );
        assertTrue( f2v47.compareTo( f2v47 ) == 0 );
        assertTrue( f2v47b.compareTo( f2v47b ) == 0 );
        
        assertEquals( f2.getLatestVersion(), f2v47b );
        
        final List asc = f2.getSortedVersions( true );
        
        assertEquals( asc.size(), 5 );
        assertEquals( asc.get( 0 ), f2v35 );
        assertEquals( asc.get( 1 ), f2v35a );
        assertEquals( asc.get( 2 ), f2v47 );
        assertEquals( asc.get( 3 ), f2v47c );
        assertEquals( asc.get( 4 ), f2v47b );
        
        final List desc = f2.getSortedVersions( false );
        
        assertEquals( desc.size(), 5 );
        assertEquals( desc.get( 0 ), f2v47b );
        assertEquals( desc.get( 1 ), f2v47c );
        assertEquals( desc.get( 2 ), f2v47 );
        assertEquals( desc.get( 3 ), f2v35a );
        assertEquals( desc.get( 4 ), f2v35 );
    }
    
    public void testVersionExpressions()
    
        throws CoreException
        
    {
        assertEquals( f1.getVersions( "1.2" ), 
                      asSet( f1v12 ) );
        
        assertEquals( f1.getVersions( "1.2,1.3" ), 
                      asSet( f1v12, f1v13 ) );
        
        assertEquals( f1.getVersions( "1.0,1.2,1.2.1,1.3,2.0" ), 
                      asSet( f1v10, f1v12, f1v121, f1v13, f1v20 ) );
        
        assertEquals( f1.getVersions( "[1.2" ),
                      asSet( f1v12, f1v121, f1v13, f1v20 ) );
        
        assertEquals( f1.getVersions( "(1.2" ),
                      asSet( f1v121, f1v13, f1v20 ) );
        
        assertEquals( f1.getVersions( "1.3]" ),
                      asSet( f1v10, f1v12, f1v121, f1v13 ) );
        
        assertEquals( f1.getVersions( "1.3)" ),
                      asSet( f1v10, f1v12, f1v121 ) );
        
        assertEquals( f1.getVersions( "[1.2-1.3]" ),
                      asSet( f1v12, f1v121, f1v13 ) );
        
        assertEquals( f1.getVersions( "[1.2-1.3)" ),
                      asSet( f1v12, f1v121 ) );
        
        assertEquals( f1.getVersions( "(1.2-1.3]" ),
                      asSet( f1v121, f1v13 ) );
        
        assertEquals( f1.getVersions( "1.0,(1.2-1.3],2.0" ),
                      asSet( f1v10, f1v121, f1v13, f1v20 ) );
    }
    
    /**
     * Tests the cases where version expressions make references to facet versions that don't
     * actually exist.
     * 
     * @throws CoreException
     */
    
    public void testVersionExpressionsWithUnknownVersions()
    
        throws CoreException
        
    {
        assertEquals( f1.getVersions( "[0.5-1.2]" ), asSet( f1v10, f1v12 ) );
        assertEquals( f1.getVersions( "[1.2.2-2.0]" ), asSet( f1v13, f1v20 ) );
        assertEquals( f1.getVersions( "[0.5-10.0)" ), asSet( f1v10, f1v12, f1v121, f1v13, f1v20 ) );
        assertEquals( f1.getVersions( "[10.0-25]" ), Collections.emptySet() );
        assertEquals( f1.getVersions( "3.0,4.5" ), Collections.emptySet() );
        assertEquals( f1.getVersions( "5.7" ), Collections.emptySet() );
    }
    
    @SuppressWarnings( "unchecked" )
    public void testConstraints()
    {
        /*
         * Version: 3.5
         * 
         * <requires facet="facet1" version="1.0"/>
         */ 

        assertFalse( f2v35.getConstraint().check( Collections.EMPTY_SET ).isOK() );
        assertTrue( f2v35.getConstraint().check( asSet( f1v10 ) ).isOK() );
        assertFalse( f2v35.getConstraint().check( asSet( f1v12 ) ).isOK() );
        assertFalse( f2v35.getConstraint().check( asSet( f1v121 ) ).isOK() );
        assertFalse( f2v35.getConstraint().check( asSet( f1v13 ) ).isOK() );
        assertFalse( f2v35.getConstraint().check( asSet( f1v20 ) ).isOK() );
        
        /*
         * Version: 3.5#a
         * 
         * <and>
         *   <requires facet="facet1" version="[1.2-1.3)"/>
         * </and>
         */
        
        assertFalse( f2v35a.getConstraint().check( Collections.EMPTY_SET  ).isOK() );
        assertFalse( f2v35a.getConstraint().check( asSet( f1v10 ) ).isOK() );
        assertTrue( f2v35a.getConstraint().check( asSet( f1v12 ) ).isOK() );
        assertTrue( f2v35a.getConstraint().check( asSet( f1v121 ) ).isOK() );
        assertFalse( f2v35a.getConstraint().check( asSet( f1v13 ) ).isOK() );
        assertFalse( f2v35a.getConstraint().check( asSet( f1v20 ) ).isOK() );
        
        /*
         * Version: 4.7
         * 
         * <or>
         *   <requires facet="facet1" version="[1.3"/>
         * </or>
         */
        
        assertFalse( f2v47.getConstraint().check( Collections.EMPTY_SET  ).isOK() );
        assertFalse( f2v47.getConstraint().check( asSet( f1v10 ) ).isOK() );
        assertFalse( f2v47.getConstraint().check( asSet( f1v12 ) ).isOK() );
        assertFalse( f2v47.getConstraint().check( asSet( f1v121 ) ).isOK() );
        assertTrue( f2v47.getConstraint().check( asSet( f1v13 ) ).isOK() );
        assertTrue( f2v47.getConstraint().check( asSet( f1v20 ) ).isOK() );
        
        /*
         * Version: 4.7#b
         * 
         * <or>
         *   <requires facet="facet1" version="1.3"/>
         *   <requires facet="facet1" version="2.0"/>
         * </or>
         */
        
        assertFalse( f2v47b.getConstraint().check( Collections.EMPTY_SET  ).isOK() );
        assertFalse( f2v47b.getConstraint().check( asSet( f1v10 ) ).isOK() );
        assertFalse( f2v47b.getConstraint().check( asSet( f1v12 ) ).isOK() );
        assertFalse( f2v47b.getConstraint().check( asSet( f1v121 ) ).isOK() );
        assertTrue( f2v47b.getConstraint().check( asSet( f1v13 ) ).isOK() );
        assertTrue( f2v47b.getConstraint().check( asSet( f1v20 ) ).isOK() );
        
        /*
         * Version: 4.7#c
         * 
         * <and>
         *   <or>
         *     <requires facet="facet1" version="1.2.1"/>
         *     <requires facet="facet1" version="1.3"/>
         *     <requires facet="facet1" version="2.0"/>
         *   </or>
         *   <conflicts facet="facet3a"/>
         *   <conflicts facet="facet3b" version="1.0"/>
         *   <conflicts group="group1"/>
         * </and>
         */
        
        assertFalse( f2v47c.getConstraint().check( Collections.EMPTY_SET  ).isOK() );
        assertFalse( f2v47c.getConstraint().check( asSet( f1v10 ) ).isOK() );
        assertFalse( f2v47c.getConstraint().check( asSet( f1v12 ) ).isOK() );
        assertTrue( f2v47c.getConstraint().check( asSet( f1v121 ) ).isOK() );
        assertTrue( f2v47c.getConstraint().check( asSet( f1v13 ) ).isOK() );
        assertTrue( f2v47c.getConstraint().check( asSet( f1v20 ) ).isOK() );
        
        assertFalse( f2v47c.getConstraint().check( asSet( f1v20, f3av10 ) ).isOK() );
        assertFalse( f2v47c.getConstraint().check( asSet( f1v20, f3av20 ) ).isOK() );
        assertFalse( f2v47c.getConstraint().check( asSet( f1v20, f3bv10 ) ).isOK() );
        assertTrue( f2v47c.getConstraint().check( asSet( f1v20, f3bv20 ) ).isOK() );
        assertFalse( f2v47c.getConstraint().check( asSet( f1v20, f3cv10 ) ).isOK() );
        assertFalse( f2v47c.getConstraint().check( asSet( f1v20, f3cv20 ) ).isOK() );
    }
    
    public void testConstraintApi()
    {
        assertEquals( IConstraint.Type.AND.name(), "and" );
        assertTrue( IConstraint.Type.valueOf( "and" ) == IConstraint.Type.AND );
        assertTrue( IConstraint.Type.valueOf( "aNd" ) == IConstraint.Type.AND );
        
        assertEquals( IConstraint.Type.OR.name(), "or" );
        assertTrue( IConstraint.Type.valueOf( "or" ) == IConstraint.Type.OR );
        assertTrue( IConstraint.Type.valueOf( "oR" ) == IConstraint.Type.OR );
        
        assertEquals( IConstraint.Type.REQUIRES.name(), "requires" );
        assertTrue( IConstraint.Type.valueOf( "requires" ) == IConstraint.Type.REQUIRES );
        assertTrue( IConstraint.Type.valueOf( "rEqUiRes" ) == IConstraint.Type.REQUIRES );
        
        assertEquals( IConstraint.Type.CONFLICTS.name(), "conflicts" );
        assertTrue( IConstraint.Type.valueOf( "conflicts" ) == IConstraint.Type.CONFLICTS );
        assertTrue( IConstraint.Type.valueOf( "cOnFlIcTs" ) == IConstraint.Type.CONFLICTS );
        
        /*
         * <and>
         *   <or>
         *     <requires facet="facet1" version="1.2.1"/>
         *     <requires facet="facet1" version="1.3"/>
         *     <requires facet="facet1" version="2.0"/>
         *   </or>
         *   <conflicts facet="facet3a"/>
         *   <conflicts facet="facet3b" version="1.0"/>
         *   <conflicts group="group1"/>
         * </and>
         */
        
        assertTrue( ProjectFacetsManager.isGroupDefined( "group1" ) );
        final IGroup g = ProjectFacetsManager.getGroup( "group1" );
        assertEquals( g.getId(), "group1" );
        assertEquals( g.getMembers(), asSet( f2v47c, f3cv10, f3cv20 ) );
        
        final IConstraint root = f2v47c.getConstraint();
        checkConstraint( root, IConstraint.Type.AND, null, null, null, null );
        
        IConstraint c1, c2;
        
        c1 = (IConstraint) root.getOperand( 0 );
        checkConstraint( c1, IConstraint.Type.OR, null, null, null );
        
        c2 = (IConstraint) c1.getOperand( 0 );
        checkConstraint( c2, IConstraint.Type.REQUIRES, f1, "1.2.1", Boolean.FALSE );
        
        c2 = (IConstraint) c1.getOperand( 1 );
        checkConstraint( c2, IConstraint.Type.REQUIRES, f1, "1.3", Boolean.FALSE );
        
        c2 = (IConstraint) c1.getOperand( 2 );
        checkConstraint( c2, IConstraint.Type.REQUIRES, f1, "2.0", Boolean.FALSE );
        
        c1 = (IConstraint) root.getOperand( 1 );
        checkConstraint( c1, IConstraint.Type.CONFLICTS, f3a, "*" );
        
        c1 = (IConstraint) root.getOperand( 2 );
        checkConstraint( c1, IConstraint.Type.CONFLICTS, f3b, "1.0" );
        
        c1 = (IConstraint) root.getOperand( 3 );
        checkConstraint( c1, IConstraint.Type.CONFLICTS, g );
    }
    
    private static void checkConstraint( final IConstraint c,
                                         final IConstraint.Type expectedType,
                                         final Object expectedOperand )
    {
        checkConstraint( c, expectedType, new Object[] { expectedOperand } );
    }

    private static void checkConstraint( final IConstraint c,
                                         final IConstraint.Type expectedType,
                                         final Object expectedOperand1,
                                         final Object expectedOperand2 )
    {
        checkConstraint( c, expectedType, 
                         new Object[] { expectedOperand1, expectedOperand2 } );
    }

    private static void checkConstraint( final IConstraint c,
                                         final IConstraint.Type expectedType,
                                         final Object expectedOperand1,
                                         final Object expectedOperand2,
                                         final Object expectedOperand3 )
    {
        checkConstraint( c, expectedType, 
                         new Object[] { expectedOperand1, expectedOperand2,
                                        expectedOperand3 } );
    }

    private static void checkConstraint( final IConstraint c,
                                         final IConstraint.Type expectedType,
                                         final Object expectedOperand1,
                                         final Object expectedOperand2,
                                         final Object expectedOperand3,
                                         final Object expectedOperand4 )
    {
        checkConstraint( c, expectedType, 
                         new Object[] { expectedOperand1, expectedOperand2,
                                        expectedOperand3, expectedOperand4 } );
    }
    
    private static void checkConstraint( final IConstraint c,
                                         final IConstraint.Type expectedType,
                                         final Object[] expectedOperands )
    {
        assertEquals( c.getType(), expectedType );

        final int count = c.getOperands().size();
        assertEquals( count, expectedOperands.length );
        
        final List<Object> list = new ArrayList<Object>();
        
        for( int i = 0; i < count; i++ )
        {
            final Object operand = c.getOperand( i );
            final Object expected = expectedOperands[ i ];
            
            if( expected != null )
            {
                if( ( expected instanceof String ) &&
                    ! ( operand instanceof String ) )
                {
                    assertEquals( operand.toString(), expected );
                }
                else
                {
                    assertEquals( operand, expected );
                }
            }
            
            list.add( c.getOperand( i ) );
        }
        
        assertEquals( c.getOperands(), list );
    }
    
}