Subversion Repositories DevTools

package com.erggroup.buildtool.utf;


import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

import com.erggroup.buildtool.ripple.BuildFile;
import com.erggroup.buildtool.ripple.BuildFile.BuildFileState;
import com.erggroup.buildtool.ripple.BuildStandard;
import com.erggroup.buildtool.ripple.ReleaseManager;
import com.erggroup.buildtool.ripple.Package;
import com.erggroup.buildtool.ripple.RippleEngine;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.JUnitCore;

import static org.junit.Assert.*;

/**
 * container of Build Daemon test methods
 */
public class DaemonRippleTestCase
{
    private static final Logger mLogger = LoggerFactory.getLogger(DaemonRippleTestCase.class);
    myReleaseManager            releaseManager = null;
    RippleEngine                rippleEngine   = null;
    ArrayList<Package> testPackageCollection   = new ArrayList<Package>();
    
    /**
     * Init the package set
     */
    public void initTestPackages(String setName)
    {
        
        /*    A basic set of packages
         *    All buildable
         */
         Package  p1 = createPackage(1, setName + "1");
         Package  p2 = createPackage(2, setName + "2");
         Package  p3 = createPackage(3, setName + "3");
         Package  p4 = createPackage(4, setName + "4");
         Package  p5 = createPackage(5, setName + "5");
         Package  p6 = createPackage(6, setName + "6");
         Package  p7 = createPackage(7, setName + "7");
         
         testPackageCollection.add(p1);
         testPackageCollection.add(p2);
         testPackageCollection.add(p3);
         testPackageCollection.add(p4);
         testPackageCollection.add(p5);
         testPackageCollection.add(p6);
         testPackageCollection.add(p7);
         
         p2.addDependency(p1);
         p3.addDependency(p1);
         p4.addDependency(p2).addDependency(p3);
         p5.addDependency(p2).addDependency(p4);
         p6.addDependency(p3).addDependency(p4);
         p7.addDependency(p5).addDependency(p6);
    
    }

    /** Create a WIP for a package in the Release
     * This will mark it as directlyPlanned
     * @param newPvId
     * @param alias
     */
    private Package createWip(int newPvId, String alias) {

        Package wip = ReleaseManager.NULL_PACKAGE;

        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
        {
            Package p = it.next();

            if ( p.mAlias.compareTo( alias ) == 0 )
            {
                wip = new Package(newPvId, p);
                wip.mDirectlyPlanned = true;
                testPackageCollection.add(wip);
                break;
            }
        }
        return wip;
    }
    
    /** Create a TEST for a package in the Release
     * This will mark it as test package
     * @param newPvId <0 - use PVID of the base package
     * @param alias
     */
    private Package createTest(int newPvId, String alias) {

        Package wip = ReleaseManager.NULL_PACKAGE;

        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
        {
            Package p = it.next();

            if ( p.mAlias.compareTo( alias ) == 0 )
            {
                if (newPvId < 0 )
                    newPvId = p.mId;
                wip = new Package(newPvId, p);
                wip.mTestBuildInstruction = 1;
                testPackageCollection.add(wip);
                break;
            }
        }
        return wip;
    }
    
    /** Create a RippleRequest for a package in the Release
     * This will mark it as ripple request
     * @param alias
     */
    private Package requestRipple(String alias) {

        Package wip = ReleaseManager.NULL_PACKAGE;

        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
        {
            Package p = it.next();

            if ( p.mAlias.compareTo( alias ) == 0 )
            {
                wip = new Package(p.mId, p);
                wip.mForcedRippleInstruction = 1;
                testPackageCollection.add(wip);
                break;
            }
        }
        return wip;
    }
    
    /** Create a basic package
     * 
     */
    private Package createPackage(int idx, String pName) {
        Package  p = new Package(idx, idx * 100, pName, "1.0.0000", ".cr", pName + ".cr" , "CC::/vob/"+pName+".WIP", 'b', 'P');
        BuildStandard bs = new BuildStandard(rippleEngine, "Linux", "Java 1.6");
        p.mBuildStandardCollection.add(bs);
        p.mBuildTime = 100;
        return p;
    }
    
    /** Update build time for a package
     * 
     *  @param alias
     *  @param buildTime - Set a new build time
     */
    private Package setBuildTime(String alias, int buildTime) {

        Package wip = ReleaseManager.NULL_PACKAGE;

        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
        {
            Package p = it.next();

            if ( p.mAlias.compareTo( alias ) == 0 )
            {
                p.mBuildTime = buildTime;
                break;
            }
        }
        return wip;
    }
    
    /** Setup a package so that it will be detected as being rippled
     *      Change its pvid so that consumers will see that they need to be rippled
     */
    private Package ripplePackage(String alias) {

        Package wip = ReleaseManager.NULL_PACKAGE;

        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
        {
            Package p = it.next();

            if ( p.mAlias.compareTo( alias ) == 0 )
            {
                p.mId += 10000;
                break;
            }
        }
        return wip;
    }

    
       
    /** Subclass and override key methods so that the test can control
     *  the data being used
     */
    public class myReleaseManager extends ReleaseManagerUtf
        {
       public myReleaseManager(final String connectionString, final String username, final String password)
                {
           super(connectionString, username, password);
           mLogger.error("Test {}", connectionString);
                }

                public myReleaseManager()
                {
                        super();
                }
                
                @Override
                public void queryPackageVersions(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
                {
                 
                    //    Filter for the packages that are in the release
                    for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
                {
                    Package p = it.next();
                    if (!p.mDirectlyPlanned && p.mTestBuildInstruction == 0 && p.mForcedRippleInstruction == 0)
                    {
                        p.mIsNotReleased = false;
                        packageCollection.add(p);
                    }
                }
                }
                
                @Override
        public void queryWips(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
        {
            //    Filter for the packages that are WIPs
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
            {
                Package p = it.next();
                if (p.mDirectlyPlanned )
                {
                    p.mIsNotReleased = true;
                    p.mDirectlyPlanned = true;
                    p.mBuildReason = BuildReason.NewVersion;
                    packageCollection.add(p);
                }
            }

        }
                
                @Override
        public void queryTest(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
        {
                    //    Filter for the packages that are TEST builds
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
            {
                    Package p = it.next();
                if (p.mTestBuildInstruction != 0 )
                {
                    p.mIsNotReleased = true;
                    p.mDirectlyPlanned = false;
                    p.mBuildReason = BuildReason.Test;
                    packageCollection.add(p);
                }
            }
        }
                
                @Override
        public void queryRipples(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
        {
                    //    Filter for the packages that are forced Ripples
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
            {               
                    Package p = it.next();
                if (p.mForcedRippleInstruction != 0)
                {
                    p.mIsNotReleased = true;
                    p.mDirectlyPlanned = false;
                    p.mBuildReason = BuildReason.Forced;
                    if ( p.mBuildTime == 100)
                        p.mBuildTime = 3;
                    packageCollection.add(p);
                } 
            }
        }
                 
        }


    public DaemonRippleTestCase()
    {
        mLogger.debug("DaemonBuildTestCase2");
    }

    /**
     * Test Case main line
     */
    public static void main(String[] args)
    {
        mLogger.debug("main");
        JUnitCore.main("com.erggroup.buildtool.utf.DaemonBuildTestCase2");
    }

    /**
     * set up performed prior to any test method
     */
    @BeforeClass
    public static void TestCaseSetUp()
    {
        mLogger.debug("TestCaseSetUp");
    }

    /**
     * tear down performed after test methods
     */
    @AfterClass
    public static void TestCaseTearDown()
    {
        mLogger.debug("TestCaseTearDown");
    }

    /**
     * set up performed prior to each test method
     */
    @Before
    public void TestSetUp()
    {
        mLogger.debug("TestSetUp");
        System.setProperty("vix.utf.name", "DaemonBuildTestCase2");
        Package.mGenericMachtype = "win32";
        Package.mGbeDpkg = ".";
    }

    /**
     * tear down performed after each test method
     */
    @After
    public void TestTearDown()
    {
        mLogger.debug("TestTearDown");
    }

    /** Check the build file contents
     *  @param expectedName - Name of the expected output file 
     */
    private void checkBuildFile(String expectedName) {
        boolean rv;
        BuildFile buildFile;
    
        buildFile = rippleEngine.getFirstBuildFileContent();
        assertTrue(buildFile != null);
        assertTrue(buildFile.state != BuildFileState.Dummy);
        assertTrue(buildFile.state != BuildFileState.Empty);
    
        rv = Utilities.checkBuildfile(buildFile.content, expectedName);
        assertTrue(rv);
    }
    
    /** Check the build file contents
     *  @param expectedName - Name of the expected output file 
     */
    private void checkBuildFileDummy(String expectedName) {
        boolean rv;
        BuildFile buildFile;
    
        buildFile = rippleEngine.getFirstBuildFileContent();
        assertTrue(buildFile != null);
        assertTrue(buildFile.state == BuildFileState.Dummy);
        assertTrue(buildFile.state != BuildFileState.Empty);
    
        rv = Utilities.checkBuildfile(buildFile.content, expectedName);
        assertTrue(rv);
    }

    /**
     *  Create a mesh of packages
     *  Ripple the one at the bottom
     */
    @Test
    public void RippleTest_1()
    {
        String tName = "ripple1";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
            
            createWip(2000, "p1.cr");
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
       
    }
    
    /**
     *  Create a mesh of packages
     *  Ripple the one not at the bottom
     */
    @Test
    public void RippleTest_2()
    {
        String tName = "ripple2";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
            
            createWip(2000, "p2.cr");
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }


    
    /**
     *  Create a mesh of packages
     *  Create a package that will feed into the mesh
     *  Mark bottom of the mesh as being rippled
     *  Mark create a WIP on the package feeding the mesh such that the additional time < 20%
     * 
     */
    @Test
    public void RippleTest_3()
    {
        String tName = "ripple3";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
            
            Package p1 = ripplePackage("p1.cr");
            
            Package  p0 = createPackage(20, "p0");
            testPackageCollection.add(p0);
            setBuildTime("p0.cr", 10);
            p1.addDependency(p0);
            createWip(21, "p0.cr");
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     *  Create a mesh of packages
     *  Create a package that will feed into the mesh
     *  Mark bottom of the mesh as being rippled
     *  Mark create a WIP on the package feeding the mesh such that the additional time > 20%
     * 
     */
    @Test
    public void RippleTest_4()
    {
        String tName = "ripple4";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
            
            Package p1 = ripplePackage("p1.cr");
            
            Package  p0 = createPackage(20, "p0");
            testPackageCollection.add(p0);
            setBuildTime("p0.cr", 200);
            p1.addDependency(p0);
            createWip(21, "p0.cr");
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    } 
    
    /**
     *  Create a mesh of packages
     *  Create a package that will feed into the mesh
     *  Mark bottom of the mesh as being rippled
     *  Mark RippleRequest on the package feeding the mesh such that the additional time > 20%
     * 
     */
    @Test
    public void RippleTest_4a()
    {
        String tName = "ripple4a";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
            
            Package p1 = ripplePackage("p1.cr");
            
            Package  p0 = createPackage(20, "p0");
            testPackageCollection.add(p0);
            setBuildTime("p0.cr", 200);
            p1.addDependency(p0);
            requestRipple("p0.cr");
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }  
    

    /**
     *  Create a mesh of packages
     *      Create a test package
     *      Create a WIP
     *      Test should be built first          
     */
    @Test
    public void RippleTest_5()
    {
        String tName = "ripple5";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
            
            createWip (2000, "p1.cr");
            createTest(3333, "p5.cr");
            createTest(-1  , "p4.cr");
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     *  Create a mesh of packages
     *  Request a ripple (daemon Instruction)
     */
    @Test
    public void RippleTest_6()
    {
        String tName = "ripple6";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
           
            requestRipple("p5.cr");
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     * Create a mesh of packages
     * Create a circular dependency
     * Create a WIP to 'fix' the circular dependency
     */
    @Test
    public void RippleTest_7()
    {
        String tName = "ripple7";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             
             // Create circular dependency
             p2.addDependency(p1);
             p3.addDependency(p2);
             p4.addDependency(p3);
             p1.addDependency(p4);
             
             
             Package  p1fixed = createWip(4000, "p1.cr");
             p1fixed.resetDependencies();
             testPackageCollection.add(p1fixed);
             

            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     * Create a mesh of packages
     * Create a dependencies
     * Create a WIP to 'create' a circular dependency
     * 
     * Should detect that added package will create issue
     * 
     */
    @Test
    public void RippleTest_8()
    {
        String tName = "ripple8";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             
             // Create dependency
             p2.addDependency(p1);
             p3.addDependency(p2);
             p4.addDependency(p3);
             
             Package  p1Broken = createWip(400, "p1.cr");
             p1Broken.resetDependencies().addDependency(p4);
             
          // Create a ripple, so we get some output
             Package  p5 = createPackage(5, "p5");
             testPackageCollection.add(p5);
             requestRipple("p5.cr");

            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     * Create a WIP that will fail applyPV
     *      Expect it to be rejected
     *      Expect an email
     */
    @Test
    public void RippleTest_9()
    {
        String tName = "ripple9";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             
             p2.addDependency(p1);
            
             Package  p1Broken = createWip(4000, "p1.cr");
             p1Broken.mVersion = "BadVersion";
             
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFileDummy(tName);
    }
    
    /**
     * Create a few WIP that will fail applyPV and one that will succeed
     *      Expect it to be rejected
     */
    @Test
    public void RippleTest_9a()
    {
        String tName = "ripple9a";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             Package  p5 = createPackage(4, "p5");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             testPackageCollection.add(p5);
             
             p5.addDependency(p2);
             
             Package  p1Broken = createWip(4001, "p1.cr");
             p1Broken.mVersion = "BadVersion";

             Package  p2Broken = createWip(4002, "p2.cr");
             p2Broken.mVersion = "BadVersion";

             Package  p3Broken = createWip(4003, "p3.cr");
             p3Broken.mVersion = "BadVersion";
             
             Package  p4Good = createWip(4004, "p4.cr");

            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     * Create a few WIP that will fail applyPV and one that will succeed
     *      Expect it to be rejected
     */
    @Test
    public void RippleTest_9b()
    {
        String tName = "ripple9b";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             Package  p5 = createPackage(5, "p5");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             testPackageCollection.add(p5);

             p2.addDependency(p1);
             p3.addDependency(p2);
             p4.addDependency(p3);
             
             p2.mVersion = "BadVersion";
             ripplePackage("p1.cr");
             requestRipple("p5.cr").mBuildTime = 1000;

            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    
    /**
     *  Create a mesh of packages
     *  Mark bottom as being rippled
     *  
     *  Expect a single plan with the next two two candidate packages
     */
    @Test
    public void RippleTest_10()
    {
        String tName = "ripple10";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
            
            ripplePackage("p1.cr");
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     *  Create two meshes of packages
     *  Create a ripple in both
     */
    @Test
    public void RippleTest_11()
    {
        String tName = "ripple11";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages("p");
            initTestPackages("z");
            setBuildTime("z4.cr", 200);
            
            createWip(2000, "p1.cr");
            createWip(2000, "z1.cr");
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     *  Create a simple dependency chain
     *  Mark one of the packages as an SDK
     *  Ensure that a ripple will not affect the SDK package
     *  
     */
    @Test
    public void RippleTest_12()
    {
        String tName = "ripple12";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             Package  p5 = createPackage(4, "p5");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             testPackageCollection.add(p5);

             p2.addDependency(p1);
             p3.addDependency(p1);
             p4.addDependency(p3).addDependency(p2);
             p5.addDependency(p3);
             
             // Mark SDK
             p3.mIsSdk = true;
             
             // Create a ripple, so we get some output
             requestRipple("p1.cr");
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     *  Create a simple dependency chain
     *  Mark one of the packages as having a rippleStop
     *  Create a ripple
     *  
     *  Ensure that a ripple will not propagate through the ripple stop 
     *  
     */
    @Test
    public void RippleTest_13()
    {
        String tName = "ripple13";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             Package  p5 = createPackage(4, "p5");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             testPackageCollection.add(p5);

             p2.addDependency(p1);
             p3.addDependency(p1);
             p4.addDependency(p3).addDependency(p2);
             p5.addDependency(p3);
             
             // Mark SDK
             p3.mRippleStop = 's';
             
             // Create a ripple, so we get some output
             requestRipple("p1.cr");
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    } 
    
    /**
     *  Create a simple dependency chain
     *  Create a WIP that is not already in the release
     *
     *  Ensure the WIP is included into the build set
     *  
     */
    @Test
    public void RippleTest_14()
    {
        String tName = "ripple14";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);

             p2.addDependency(p1);
             p3.addDependency(p2);
             
             // Mark as a WIP
             p4.mDirectlyPlanned = true;
             
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
    
    /**
     *  Create a simple dependency chain
     *  Create a package that will be excluded
     *
     *  Ensure the upstream packages show up in the excluded list
     *  
     */
    @Test
    public void RippleTest_15()
    {
        String tName = "ripple15";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             Package  p5 = createPackage(5, "p5");
             Package  p6 = createPackage(6, "p6");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             testPackageCollection.add(p5);
             testPackageCollection.add(p6);

             p2.addDependency(p1);
             p3.addDependency(p2);
             p4.addDependency(p2);
             p5.addDependency(p4);
             
             p2.mVersion = "BadVersion";
             ripplePackage("p1.cr");
             
             // Create a ripple, so we get some output

             //requestRipple("p6.cr");
             
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFileDummy(tName);
    }
    
    /**
     *  Create a simple dependency chain
     *  
     *  Ensure that the build level is correctly calculated
     *  Should be able to build ALL the packages at the same level in any order
     *  
     */
    @Test
    public void RippleTest_16()
    {
        String tName = "ripple16";
        mLogger.debug("RippleTest {}", tName);
        System.out.println("RippleTest " + tName);
        releaseManager = new myReleaseManager(tName, "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            /*    A basic set of packages
             */
             Package  p1 = createPackage(1, "p1");
             Package  p2 = createPackage(2, "p2");
             Package  p3 = createPackage(3, "p3");
             Package  p4 = createPackage(4, "p4");
             Package  p5 = createPackage(5, "p5");
             Package  p6 = createPackage(6, "p6");
             
             testPackageCollection.add(p1);
             testPackageCollection.add(p2);
             testPackageCollection.add(p3);
             testPackageCollection.add(p4);
             testPackageCollection.add(p5);
             testPackageCollection.add(p6);

             p2.addDependency(p1);
             p3.addDependency(p1);
             p4.addDependency(p1);
             p5.addDependency(p2);
             
             // Create a ripple, so we get some output
             requestRipple("p1.cr");
             
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }

}