Subversion Repositories DevTools

package com.erggroup.buildtool.utf;


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

import com.erggroup.buildtool.ripple.BuildExclusion;
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.PackageCollection;
import com.erggroup.buildtool.ripple.PlanControl;
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;
        PackageCollection testPackageCollection         = new PackageCollection();
        PackageCollection testPackageCollectionTest     = new PackageCollection();
        PackageCollection testPackageCollectionWip      = new PackageCollection();
        PackageCollection testPackageCollectionRipple   = new PackageCollection();
        ArrayList<BuildExclusion> mBuildExclusionCollection = new ArrayList<BuildExclusion>();
                
        /**
         * Init the package set
         */
        public void initTestPackages(String setName, int basePvid)
        {

                /*    A basic set of packages
                 *    All buildable
                 */
                Package  p1 = createPackage(basePvid + 1, setName + "1");
                Package  p2 = createPackage(basePvid + 2, setName + "2");
                Package  p3 = createPackage(basePvid + 3, setName + "3");
                Package  p4 = createPackage(basePvid + 4, setName + "4");
                Package  p5 = createPackage(basePvid + 5, setName + "5");
                Package  p6 = createPackage(basePvid + 6, setName + "6");
                Package  p7 = createPackage(basePvid + 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);

        }

        /** Locate a package by its alias
         * 
         * @param alias    Alias to locate
         * @return         The package. May be null if not found
         */
        private Package getPackage(String alias)
        {
            return testPackageCollection.contains(alias);
        }
        
        /** 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 = testPackageCollection.contains(alias);
                if (wip == null)
                {
                        wip = ReleaseManager.NULL_PACKAGE;
                }
                else
                {
                        wip = new Package(newPvId, wip);
                        wip.mDirectlyPlanned = true;
                        testPackageCollectionWip.add(wip);
                }

                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 = testPackageCollection.contains(alias);
                if (wip == null)
                {
                        wip = ReleaseManager.NULL_PACKAGE;
                }
                else
                {
                        if (newPvId < 0 )
                                newPvId = wip.mId;
                        wip = new Package(newPvId, wip);
                        wip.mTestBuildInstruction = 1;
                        testPackageCollectionTest.add(wip);
                }

                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 = testPackageCollection.contains(alias);
                if (wip == null)
                {
                        wip = ReleaseManager.NULL_PACKAGE;
                }
                else
                {
                        wip = new Package(wip.mId, wip);
                        wip.mForcedRippleInstruction = 1;
                        testPackageCollectionRipple.add(wip);
                }

                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;
        }

        /** Create a buildExclusion and add to the list for Release Manager
         * 
         *    @param  identifier - pvid of the package being excluded
         *    @param  rootIdentifier  - pvid of the root package causing the exclusion. May be -1
         *    @param  rootCause - Short (< 50 Char) string explaining the cause
         *    @param  testBuildInstruction - Indicates a text build instruction
         *    @return The entry that was created
         */
        private BuildExclusion createBuildExclusion (int identifier, int rootIdentifier, String rootCause, int testBuildInstruction )
        {
            BuildExclusion be = new BuildExclusion(identifier, rootIdentifier, rootCause, testBuildInstruction);
            mBuildExclusionCollection.add(be);
            return be;
        }


        /** 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, PackageCollection 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, PackageCollection packageCollection, int baseline) throws SQLException, Exception
                {
                        //    Filter for the packages that are WIPs
                        for (Iterator<Package> it = testPackageCollectionWip.iterator(); it.hasNext(); )
                        {
                                Package p = it.next();
                                p.mIsNotReleased = true;
                                p.mDirectlyPlanned = true;
                                p.mBuildReason = BuildReason.NewVersion;
                                packageCollection.add(p);
                        }

                }

                @Override
                public void queryTest(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
                {
                        //    Filter for the packages that are TEST builds
                        for (Iterator<Package> it = testPackageCollectionTest.iterator(); it.hasNext(); )
                        {
                                Package p = it.next();
                                p.mIsNotReleased = true;
                                p.mDirectlyPlanned = false;
                                p.mBuildReason = BuildReason.Test;
                                packageCollection.add(p);
                        }
                }

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

                @Override
                public void queryPlanControl(int mRtagId, PlanControl mPlanControl) throws Exception
                {
                        mPlanControl.setThreshold(20);
                }
                
            @Override
            public void queryBuildExclusions(List<BuildExclusion> buildExclusionCollection, int baseline) throws SQLException, Exception
            {
                buildExclusionCollection.addAll(mBuildExclusionCollection);
            }

        }


        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", 0);

                        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", 0);

                        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", 0);

                        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", 0);

                        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", 0);

                        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", 0);

                        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", 0);

                        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();

                        rippleEngine.planRelease(false);
                }
                catch (Exception e)
                {
                        mLogger.error("Exception in UTF: {}", e.getMessage());
                }

                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
                        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(4000, "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(5, "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";

                        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", 0);

                        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", 0);
                        initTestPackages("z", 100);
                        setBuildTime("z4.cr", 200);

                        createWip(2000, "p1.cr");
                        createWip(3000, "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(5, "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(5, "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");

                        testPackageCollection.add(p1);
                        testPackageCollection.add(p2);
                        testPackageCollection.add(p3);

                        p2.addDependency(p1);
                        p3.addDependency(p2);

                        // Mark as a WIP
                        Package  p4 = createPackage(4, "p4");
                        testPackageCollectionWip.add(p4);
                        //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);
        }
        
        /**
     *  Create two sets of packages
     *  The first will be a WIP
     *  
     *  The second will contain a Ripple and a WIP
     *  
     *  Configure such that the a basic and a Full plan are calculated
     *  
     *  Ensure that the Full plan does not include the WIP of that will have been processed by the basic plan 
     */
    @Test
    public void RippleTest_17()
    {
        String tName = "ripple17";
        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(p3);
            p5.addDependency(p4);
            p6.addDependency(p5);
            
            ripplePackage("p1.cr");
            createWip(9999, "p3.cr");
            
            // A second set of packages
            
            Package  z1 = createPackage(11, "z1");
            Package  z2 = createPackage(12, "z2");
            Package  z3 = createPackage(13, "z3");
            Package  z4 = createPackage(14, "z4");
            Package  z5 = createPackage(15, "z5");
            Package  z6 = createPackage(16, "z6");

            testPackageCollection.add(z1);
            testPackageCollection.add(z2);
            testPackageCollection.add(z3);
            testPackageCollection.add(z4);
            testPackageCollection.add(z5);
            testPackageCollection.add(z6);

            z2.addDependency(z1);
            z3.addDependency(z2);
            z4.addDependency(z3);
            z5.addDependency(z4);
            z6.addDependency(z5);
            
            createWip(8888, "z1.cr");

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

        checkBuildFile(tName);
    }
    
    /**
     *  Create one sets of packages
     *  Configure such that a WIP and a natural ripple exist on the same package
     *  
     *  Ensure that the WIP is processed 
     */
    @Test
    public void RippleTest_18()
    {
        String tName = "ripple18";
        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(p3);
            p5.addDependency(p4);
            p6.addDependency(p5);
            
            ripplePackage("p1.cr");                 // Mark p1 as having been built. thus p2 will need to be rippled.
            createWip(9999, "p2.cr");               // Also have a WIP on p2


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

        checkBuildFile(tName);
    }
    
    /**
     *  Create one sets of packages
     *  Configure with  WIP and a NaturalRipple such that we will have a basicPlan followed by a modified full plan
     *  
     *  Ensure the the dependency version numbers are that of the WIP which will part of the follow-on plan 
     */
    @Test
    public void RippleTest_19()
    {
        String tName = "ripple19";
        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(p3);
            p5.addDependency(p4);
            p6.addDependency(p5);
            
            ripplePackage("p2.cr");                             // Mark p2 as having been built. thus p3 will need to be rippled.
            Package pwip = createWip(9999, "p1.cr");            // Also have a WIP on p1
            pwip.mVersion = "22.22.22";
            pwip.mNextVersion = "33.33.33";

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

        checkBuildFile(tName);
    }
    
    /**
     *  Create a mesh of packages
     *  Mark one as having an advisory ripple
     *  
     *  Ripple the one at the bottom
     *  Ensure the plan does not include those downstream of the advisory ripple
     *  Also don't expect the SDK or Pegged package to be built
     */
    @Test
    public void RippleTest_20()
    {
        String tName = "ripple20";
        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");

            Package  p31 = createPackage(7, "p31");
            Package  p32 = createPackage(8, "p32");
            Package  p33 = createPackage(9, "p33");

            
            testPackageCollection.add(p1);
            testPackageCollection.add(p2);
            testPackageCollection.add(p3);
            testPackageCollection.add(p4);
            testPackageCollection.add(p5);
            testPackageCollection.add(p6);
            
            testPackageCollection.add(p31);
            testPackageCollection.add(p32);
            testPackageCollection.add(p33);

            p2.addDependency(p1);
            p3.addDependency(p2);
            p4.addDependency(p3);
            p5.addDependency(p4);
            p6.addDependency(p5);
            
            p31.addDependency(p2);
            p32.addDependency(p2);
            p33.addDependency(p2);
            
            ripplePackage("p1.cr");                 // Mark p1 as having been built. thus p2 will need to be rippled.
            p3.mAdvisoryRipple = true;              // Expect ripples to stop here
            p32.mIsSdk = true;
            p33.mIsPegged = true;
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);

    }
    
    /**
     *  Create a mesh of packages
     *  Ripple the one at the bottom - which is marked as an advisory Ripple
     *  
     *  Expect on the rippled package to be built
     */
    @Test
    public void RippleTest_21()
    {
        String tName = "ripple21";
        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", 0);
            Package p1 = getPackage ("p1.cr");
            p1.mAdvisoryRipple = true;

            createWip(2000, "p1.cr");
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }

    /**
     *  Create a mesh of packages
     *  Mark bottom as being rippled - so that it will build
     *  Create a WIP for the package
     *  Create a Build Exclusion for the WIP - it failed to build
     *  
     *  Expect nothing to build
     *  
     */
    @Test
    public void RippleTest_22()
    {
        String tName = "ripple22";
        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");
            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(p3);
            p5.addDependency(p4);            
            
            ripplePackage("p1.cr");
            Package p2Wip = createWip(2000, "p2.cr");
            createBuildExclusion(p2Wip.mId, -1, null, 0);
            
            // Force some output
            requestRipple("p6.cr");
            
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        checkBuildFile(tName);
    }
}