Subversion Repositories DevTools

package com.erggroup.buildtool.utf;

import java.sql.SQLException;

import java.util.ArrayList;

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.Ripple;

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

    }

    /**

     *  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 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(400, "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(400, "p1.cr");

             p1Broken.mVersion = "BadVersion";

             // Create a ripple, so we get some output

             requestRipple("p4.cr");

            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(4, "p5");

             Package  p6 = createPackage(4, "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)

        {

        }

        checkBuildFile(tName);

    }

}