Subversion Repositories DevTools

Rev

Rev 7169 | Rev 7201 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7169 Rev 7186
Line 1... Line 1...
1 
package com.erggroup.buildtool.utf;
 1 
package com.erggroup.buildtool.utf;
2 
 
 2 
 
3 
 
 3 
 
4 
import java.sql.SQLException;
 4 
import java.sql.SQLException;
5 
import java.util.ArrayList;
 - 
 
6 
import java.util.Iterator;
 5 
import java.util.Iterator;
7 
 
 6 
 
8 
import com.erggroup.buildtool.ripple.BuildFile;
 7 
import com.erggroup.buildtool.ripple.BuildFile;
9 
import com.erggroup.buildtool.ripple.BuildFile.BuildFileState;
 8 
import com.erggroup.buildtool.ripple.BuildFile.BuildFileState;
10 
import com.erggroup.buildtool.ripple.BuildStandard;
 9 
import com.erggroup.buildtool.ripple.BuildStandard;
11 
import com.erggroup.buildtool.ripple.ReleaseManager;
 10 
import com.erggroup.buildtool.ripple.ReleaseManager;
12 
import com.erggroup.buildtool.ripple.Package;
 11 
import com.erggroup.buildtool.ripple.Package;
- 
 
 12 
import com.erggroup.buildtool.ripple.PackageCollection;
13 
import com.erggroup.buildtool.ripple.PlanControl;
 13 
import com.erggroup.buildtool.ripple.PlanControl;
14 
import com.erggroup.buildtool.ripple.RippleEngine;
 14 
import com.erggroup.buildtool.ripple.RippleEngine;
15 
import org.slf4j.Logger;
 15 
import org.slf4j.Logger;
16 
import org.slf4j.LoggerFactory;
 16 
import org.slf4j.LoggerFactory;
17 
import org.junit.AfterClass;
 17 
import org.junit.AfterClass;
Line 26... Line 26...
26 
/**
 26 
/**
27 
 * container of Build Daemon test methods
 27 
 * container of Build Daemon test methods
28 
 */
 28 
 */
29 
public class DaemonRippleTestCase
 29 
public class DaemonRippleTestCase
30 
{
 30 
{
31 
    private static final Logger mLogger = LoggerFactory.getLogger(DaemonRippleTestCase.class);
 31 
	private static final Logger mLogger = LoggerFactory.getLogger(DaemonRippleTestCase.class);
32 
    myReleaseManager            releaseManager = null;
 32 
	myReleaseManager            releaseManager = null;
33 
    RippleEngine                rippleEngine   = null;
 33 
	RippleEngine                rippleEngine   = null;
34 
    ArrayList<Package> testPackageCollection   = new ArrayList<Package>();
 34 
	PackageCollection testPackageCollection         = new PackageCollection();
35
- 
 
36 
    /**
 - 
 
37 
     * Init the package set
 - 
 
38 
     */
 - 
 
39 
    public void initTestPackages(String setName)
 - 
 
40 
    {
 - 
 
41
- 
 
42 
        /*    A basic set of packages
 - 
 
43 
         *    All buildable
 - 
 
44 
         */
 - 
 
45 
         Package  p1 = createPackage(1, setName + "1");
 - 
 
46 
         Package  p2 = createPackage(2, setName + "2");
 - 
 
47 
         Package  p3 = createPackage(3, setName + "3");
 - 
 
48 
         Package  p4 = createPackage(4, setName + "4");
 - 
 
49 
         Package  p5 = createPackage(5, setName + "5");
 - 
 
50 
         Package  p6 = createPackage(6, setName + "6");
 - 
 
51 
         Package  p7 = createPackage(7, setName + "7");
 - 
 
52
- 
 
53 
         testPackageCollection.add(p1);
 - 
 
54 
         testPackageCollection.add(p2);
 - 
 
55 
         testPackageCollection.add(p3);
 - 
 
56 
         testPackageCollection.add(p4);
 - 
 
57 
         testPackageCollection.add(p5);
 - 
 
58 
         testPackageCollection.add(p6);
 - 
 
59 
         testPackageCollection.add(p7);
 - 
 
60
- 
 
61 
         p2.addDependency(p1);
 - 
 
62 
         p3.addDependency(p1);
 - 
 
63 
         p4.addDependency(p2).addDependency(p3);
 - 
 
64 
         p5.addDependency(p2).addDependency(p4);
 - 
 
65 
         p6.addDependency(p3).addDependency(p4);
 - 
 
66 
         p7.addDependency(p5).addDependency(p6);
 - 
 
67
- 
 
68 
    }
 - 
 
69 
 
 - 
 
70 
    /** Create a WIP for a package in the Release
 - 
 
71 
     * This will mark it as directlyPlanned
 - 
 
72 
     * @param newPvId
 - 
 
73 
     * @param alias
 - 
 
74 
     */
 - 
 
75 
    private Package createWip(int newPvId, String alias) {
 - 
 
76 
 
 - 
 
77 
        Package wip = ReleaseManager.NULL_PACKAGE;
 - 
 
78 
 
 - 
 
79 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 35 
	PackageCollection testPackageCollectionTest     = new PackageCollection();
80 
        {
 - 
 
81 
            Package p = it.next();
 - 
 
82 
 
 - 
 
83 
            if ( p.mAlias.compareTo( alias ) == 0 )
 - 
 
84 
            {
 - 
 
85 
                wip = new Package(newPvId, p);
 - 
 
86 
                wip.mDirectlyPlanned = true;
 - 
 
87 
                testPackageCollection.add(wip);
 - 
 
88 
                break;
 - 
 
89 
            }
 - 
 
90 
        }
 - 
 
91 
        return wip;
 - 
 
92 
    }
 - 
 
93
- 
 
94 
    /** Create a TEST for a package in the Release
 - 
 
95 
     * This will mark it as test package
 - 
 
96 
     * @param newPvId <0 - use PVID of the base package
 - 
 
97 
     * @param alias
 - 
 
98 
     */
 - 
 
99 
    private Package createTest(int newPvId, String alias) {
 - 
 
100 
 
 - 
 
101 
        Package wip = ReleaseManager.NULL_PACKAGE;
 - 
 
102 
 
 - 
 
103 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 36 
	PackageCollection testPackageCollectionWip      = new PackageCollection();
104 
        {
 - 
 
105 
            Package p = it.next();
 - 
 
106 
 
 - 
 
107 
            if ( p.mAlias.compareTo( alias ) == 0 )
 - 
 
108 
            {
 - 
 
109 
                if (newPvId < 0 )
 - 
 
110 
                    newPvId = p.mId;
 - 
 
111 
                wip = new Package(newPvId, p);
 - 
 
112 
                wip.mTestBuildInstruction = 1;
 - 
 
113 
                testPackageCollection.add(wip);
 - 
 
114 
                break;
 - 
 
115 
            }
 - 
 
116 
        }
 - 
 
117 
        return wip;
 - 
 
118 
    }
 - 
 
119
- 
 
120 
    /** Create a RippleRequest for a package in the Release
 - 
 
121 
     * This will mark it as ripple request
 - 
 
122 
     * @param alias
 - 
 
123 
     */
 - 
 
124 
    private Package requestRipple(String alias) {
 - 
 
125 
 
 - 
 
126 
        Package wip = ReleaseManager.NULL_PACKAGE;
 - 
 
127 
 
 - 
 
128 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 37 
	PackageCollection testPackageCollectionRipple   = new PackageCollection();
129 
        {
 - 
 
130 
            Package p = it.next();
 - 
 
131 
 
 38 
 
132 
            if ( p.mAlias.compareTo( alias ) == 0 )
 - 
 
133 
            {
 - 
 
134 
                wip = new Package(p.mId, p);
 - 
 
135 
                wip.mForcedRippleInstruction = 1;
 - 
 
136 
                testPackageCollection.add(wip);
 - 
 
137 
                break;
 - 
 
138 
            }
 - 
 
139 
        }
 - 
 
140 
        return wip;
 - 
 
141 
    }
 - 
 
142
- 
 
143 
    /** Create a basic package
 - 
 
144 
     *
- 
 
145 
     */
 - 
 
146 
    private Package createPackage(int idx, String pName) {
 - 
 
147 
        Package  p = new Package(idx, idx * 100, pName, "1.0.0000", ".cr", pName + ".cr" , "CC::/vob/"+pName+".WIP", 'b', 'P');
 - 
 
148 
        BuildStandard bs = new BuildStandard(rippleEngine, "Linux", "Java 1.6");
 - 
 
149 
        p.mBuildStandardCollection.add(bs);
 - 
 
150 
        p.mBuildTime = 100;
 - 
 
151 
        return p;
 - 
 
152 
    }
 - 
 
153
- 
 
154 
    /** Update build time for a package
 - 
 
155 
     *
- 
 
156 
     *  @param alias
 - 
 
157 
     *  @param buildTime - Set a new build time
 - 
 
158 
     */
 - 
 
159 
    private Package setBuildTime(String alias, int buildTime) {
 - 
 
160 
 
 - 
 
161 
        Package wip = ReleaseManager.NULL_PACKAGE;
 - 
 
162 
 
 - 
 
163 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 - 
 
164 
        {
 - 
 
165 
            Package p = it.next();
 - 
 
166 
 
 - 
 
167 
            if ( p.mAlias.compareTo( alias ) == 0 )
 - 
 
168 
            {
 - 
 
169 
                p.mBuildTime = buildTime;
 - 
 
170 
                break;
 - 
 
171 
            }
 - 
 
172 
        }
 - 
 
173 
        return wip;
 - 
 
174 
    }
 - 
 
175
- 
 
176 
    /** Setup a package so that it will be detected as being rippled
 - 
 
177 
     *      Change its pvid so that consumers will see that they need to be rippled
 - 
 
178 
     */
 - 
 
179 
    private Package ripplePackage(String alias) {
 - 
 
180 
 
 - 
 
181 
        Package wip = ReleaseManager.NULL_PACKAGE;
 - 
 
182 
 
 - 
 
183 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 - 
 
184 
        {
 - 
 
185 
            Package p = it.next();
 - 
 
186 
 
 - 
 
187 
            if ( p.mAlias.compareTo( alias ) == 0 )
 - 
 
188 
            {
 - 
 
189 
                p.mId += 10000;
 - 
 
190 
                break;
 - 
 
191 
            }
 - 
 
192 
        }
 - 
 
193 
        return wip;
 - 
 
194 
    }
 - 
 
195 
 
 - 
 
196
39 
	/**
197
- 
 
198 
    /** Subclass and override key methods so that the test can control
 - 
 
199 
     *  the data being used
 40 
	 * Init the package set
200 
     */
 41 
	 */
201 
    public class myReleaseManager extends ReleaseManagerUtf
 42 
	public void initTestPackages(String setName, int basePvid)
202 
	{
 43 
	{
- 
 
 44 
 
- 
 
 45 
		/*    A basic set of packages
- 
 
 46 
		 *    All buildable
- 
 
 47 
		 */
- 
 
 48 
		Package  p1 = createPackage(basePvid + 1, setName + "1");
- 
 
 49 
		Package  p2 = createPackage(basePvid + 2, setName + "2");
- 
 
 50 
		Package  p3 = createPackage(basePvid + 3, setName + "3");
- 
 
 51 
		Package  p4 = createPackage(basePvid + 4, setName + "4");
- 
 
 52 
		Package  p5 = createPackage(basePvid + 5, setName + "5");
- 
 
 53 
		Package  p6 = createPackage(basePvid + 6, setName + "6");
- 
 
 54 
		Package  p7 = createPackage(basePvid + 7, setName + "7");
- 
 
 55 
 
- 
 
 56 
		testPackageCollection.add(p1);
- 
 
 57 
		testPackageCollection.add(p2);
- 
 
 58 
		testPackageCollection.add(p3);
- 
 
 59 
		testPackageCollection.add(p4);
- 
 
 60 
		testPackageCollection.add(p5);
- 
 
 61 
		testPackageCollection.add(p6);
- 
 
 62 
		testPackageCollection.add(p7);
- 
 
 63 
 
- 
 
 64 
		p2.addDependency(p1);
- 
 
 65 
		p3.addDependency(p1);
- 
 
 66 
		p4.addDependency(p2).addDependency(p3);
- 
 
 67 
		p5.addDependency(p2).addDependency(p4);
- 
 
 68 
		p6.addDependency(p3).addDependency(p4);
- 
 
 69 
		p7.addDependency(p5).addDependency(p6);
- 
 
 70 
 
- 
 
 71 
	}
- 
 
 72 
 
- 
 
 73 
	/** Create a WIP for a package in the Release
- 
 
 74 
	 * This will mark it as directlyPlanned
- 
 
 75 
	 * @param newPvId
- 
 
 76 
	 * @param alias
- 
 
 77 
	 */
- 
 
 78 
	private Package createWip(int newPvId, String alias) {
- 
 
 79 
 
- 
 
 80 
		Package wip = testPackageCollection.contains(alias);
- 
 
 81 
		if (wip == null)
- 
 
 82 
		{
- 
 
 83 
			wip = ReleaseManager.NULL_PACKAGE;
- 
 
 84 
		}
- 
 
 85 
		else
- 
 
 86 
		{
- 
 
 87 
			wip = new Package(newPvId, wip);
- 
 
 88 
			wip.mDirectlyPlanned = true;
- 
 
 89 
			testPackageCollectionWip.add(wip);
- 
 
 90 
		}
- 
 
 91 
 
- 
 
 92 
		return wip;
- 
 
 93 
	}
- 
 
 94 
 
- 
 
 95 
	/** Create a TEST for a package in the Release
- 
 
 96 
	 * This will mark it as test package
- 
 
 97 
	 * @param newPvId <0 - use PVID of the base package
- 
 
 98 
	 * @param alias
- 
 
 99 
	 */
- 
 
 100 
	private Package createTest(int newPvId, String alias) {
- 
 
 101 
 
- 
 
 102 
		Package wip = testPackageCollection.contains(alias);
- 
 
 103 
		if (wip == null)
- 
 
 104 
		{
- 
 
 105 
			wip = ReleaseManager.NULL_PACKAGE;
- 
 
 106 
		}
- 
 
 107 
		else
- 
 
 108 
		{
- 
 
 109 
			if (newPvId < 0 )
- 
 
 110 
				newPvId = wip.mId;
- 
 
 111 
			wip = new Package(newPvId, wip);
- 
 
 112 
			wip.mTestBuildInstruction = 1;
- 
 
 113 
			testPackageCollectionTest.add(wip);
- 
 
 114 
		}
- 
 
 115 
 
- 
 
 116 
		return wip;
- 
 
 117 
	}
- 
 
 118 
 
- 
 
 119 
	/** Create a RippleRequest for a package in the Release
- 
 
 120 
	 * This will mark it as ripple request
- 
 
 121 
	 * @param alias
- 
 
 122 
	 */
- 
 
 123 
	private Package requestRipple(String alias) {
- 
 
 124 
 
- 
 
 125 
		Package wip = testPackageCollection.contains(alias);
- 
 
 126 
		if (wip == null)
- 
 
 127 
		{
- 
 
 128 
			wip = ReleaseManager.NULL_PACKAGE;
- 
 
 129 
		}
- 
 
 130 
		else
- 
 
 131 
		{
- 
 
 132 
			wip = new Package(wip.mId, wip);
- 
 
 133 
			wip.mForcedRippleInstruction = 1;
- 
 
 134 
			testPackageCollectionRipple.add(wip);
- 
 
 135 
		}
- 
 
 136 
 
- 
 
 137 
		return wip;
- 
 
 138 
	}
- 
 
 139 
 
- 
 
 140 
	/** Create a basic package
- 
 
 141 
	 *
- 
 
 142 
	 */
- 
 
 143 
	private Package createPackage(int idx, String pName) {
- 
 
 144 
		Package  p = new Package(idx, idx * 100, pName, "1.0.0000", ".cr", pName + ".cr" , "CC::/vob/"+pName+".WIP", 'b', 'P');
- 
 
 145 
		BuildStandard bs = new BuildStandard(rippleEngine, "Linux", "Java 1.6");
- 
 
 146 
		p.mBuildStandardCollection.add(bs);
- 
 
 147 
		p.mBuildTime = 100;
- 
 
 148 
		return p;
- 
 
 149 
	}
- 
 
 150 
 
- 
 
 151 
	/** Update build time for a package
- 
 
 152 
	 *
- 
 
 153 
	 *  @param alias
- 
 
 154 
	 *  @param buildTime - Set a new build time
- 
 
 155 
	 */
- 
 
 156 
	private Package setBuildTime(String alias, int buildTime) {
- 
 
 157 
 
- 
 
 158 
		Package wip = ReleaseManager.NULL_PACKAGE;
- 
 
 159 
 
- 
 
 160 
		for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
- 
 
 161 
		{
- 
 
 162 
			Package p = it.next();
- 
 
 163 
 
- 
 
 164 
			if ( p.mAlias.compareTo( alias ) == 0 )
- 
 
 165 
			{
- 
 
 166 
				p.mBuildTime = buildTime;
- 
 
 167 
				break;
- 
 
 168 
			}
- 
 
 169 
		}
- 
 
 170 
		return wip;
- 
 
 171 
	}
- 
 
 172 
 
- 
 
 173 
	/** Setup a package so that it will be detected as being rippled
- 
 
 174 
	 *      Change its pvid so that consumers will see that they need to be rippled
- 
 
 175 
	 */
- 
 
 176 
	private Package ripplePackage(String alias) {
- 
 
 177 
 
- 
 
 178 
		Package wip = ReleaseManager.NULL_PACKAGE;
- 
 
 179 
 
- 
 
 180 
		for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
- 
 
 181 
		{
- 
 
 182 
			Package p = it.next();
- 
 
 183 
 
- 
 
 184 
			if ( p.mAlias.compareTo( alias ) == 0 )
- 
 
 185 
			{
- 
 
 186 
				p.mId += 10000;
- 
 
 187 
				break;
- 
 
 188 
			}
- 
 
 189 
		}
- 
 
 190 
		return wip;
- 
 
 191 
	}
- 
 
 192 
 
- 
 
 193 
 
- 
 
 194 
 
- 
 
 195 
	/** Subclass and override key methods so that the test can control
- 
 
 196 
	 *  the data being used
- 
 
 197 
	 */
- 
 
 198 
	public class myReleaseManager extends ReleaseManagerUtf
- 
 
 199 
	{
203 
       public myReleaseManager(final String connectionString, final String username, final String password)
 200 
		public myReleaseManager(final String connectionString, final String username, final String password)
204 
		{
 201 
		{
205 
           super(connectionString, username, password);
 202 
			super(connectionString, username, password);
206 
           mLogger.error("Test {}", connectionString);
 203 
			mLogger.error("Test {}", connectionString);
207 
		}
 204 
		}
208 
 
 205 
 
209 
		public myReleaseManager()
 206 
		public myReleaseManager()
210 
		{
 207 
		{
211 
			super();
 208 
			super();
212 
		}
 209 
		}
213
210 
 
214 
		@Override
 211 
		@Override
215 
		public void queryPackageVersions(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
 212 
		public void queryPackageVersions(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
216 
		{
 213 
		{
217
214 
 
218 
		    //    Filter for the packages that are in the release
 215 
			//    Filter for the packages that are in the release
219 
		    for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 216 
			for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
220 
	        {
 217 
			{
221 
	            Package p = it.next();
 218 
				Package p = it.next();
222 
	            if (!p.mDirectlyPlanned && p.mTestBuildInstruction == 0 && p.mForcedRippleInstruction == 0)
 219 
				if (!p.mDirectlyPlanned && p.mTestBuildInstruction == 0 && p.mForcedRippleInstruction == 0)
223 
	            {
 220 
				{
224 
	                p.mIsNotReleased = false;
 221 
					p.mIsNotReleased = false;
225 
	                packageCollection.add(p);
 222 
					packageCollection.add(p);
226 
	            }
 223 
				}
227 
	        }
 224 
			}
228 
		}
 225 
		}
229
226 
 
230 
		@Override
 227 
		@Override
231 
        public void queryWips(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
 228 
		public void queryWips(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
232 
        {
 229 
		{
233 
            //    Filter for the packages that are WIPs
 230 
			//    Filter for the packages that are WIPs
234 
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 231 
			for (Iterator<Package> it = testPackageCollectionWip.iterator(); it.hasNext(); )
235 
            {
 232 
			{
236 
                Package p = it.next();
 233 
				Package p = it.next();
- 
 
 234 
				p.mIsNotReleased = true;
237 
                if (p.mDirectlyPlanned )
 235 
				p.mDirectlyPlanned = true;
- 
 
 236 
				p.mBuildReason = BuildReason.NewVersion;
- 
 
 237 
				packageCollection.add(p);
- 
 
 238 
			}
- 
 
 239 
 
- 
 
 240 
		}
- 
 
 241 
 
- 
 
 242 
		@Override
- 
 
 243 
		public void queryTest(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
- 
 
 244 
		{
- 
 
 245 
			//    Filter for the packages that are TEST builds
- 
 
 246 
			for (Iterator<Package> it = testPackageCollectionTest.iterator(); it.hasNext(); )
- 
 
 247 
			{
238 
                {
 248 
				Package p = it.next();
239 
                    p.mIsNotReleased = true;
 249 
				p.mIsNotReleased = true;
240 
                    p.mDirectlyPlanned = true;
 250 
				p.mDirectlyPlanned = false;
241 
                    p.mBuildReason = BuildReason.NewVersion;
 251 
				p.mBuildReason = BuildReason.Test;
242 
                    packageCollection.add(p);
 252 
				packageCollection.add(p);
243 
                }
 253 
			}
244 
            }
 254 
		}
245 
 
 255 
 
246 
        }
 - 
 
247
- 
 
248 
		@Override
 256 
		@Override
249 
        public void queryTest(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
 257 
		public void queryRipples(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
250 
        {
 258 
		{
251 
		    //    Filter for the packages that are TEST builds
 259 
			//    Filter for the packages that are forced Ripples
252 
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 260 
			for (Iterator<Package> it = testPackageCollectionRipple.iterator(); it.hasNext(); )
253 
            {
 261 
			{
254 
    		    Package p = it.next();
 262 
				Package p = it.next();
255 
                if (p.mTestBuildInstruction != 0 )
 - 
 
256 
                {
 - 
 
257 
                    p.mIsNotReleased = true;
 263 
				p.mIsNotReleased = true;
258 
                    p.mDirectlyPlanned = false;
 264 
				p.mDirectlyPlanned = false;
259 
                    p.mBuildReason = BuildReason.Test;
 265 
				p.mBuildReason = BuildReason.Forced;
260 
                    packageCollection.add(p);
 266 
				if ( p.mBuildTime == 100)
261 
                }
 267 
					p.mBuildTime = 3;
262 
            }
 268 
				packageCollection.add(p);
263 
        }
 269 
			}
264
270 
		}
- 
 
 271 
 
265 
		@Override
 272 
		@Override
266 
        public void queryRipples(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
 273 
		public void queryPlanControl(int mRtagId, PlanControl mPlanControl) throws Exception
267 
        {
 274 
		{
268 
		    //    Filter for the packages that are forced Ripples
 275 
			mPlanControl.setThreshold(20);
269 
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
 276 
		}
270 
            {
277 
 
271 
    		    Package p = it.next();
 278 
	}
272 
                if (p.mForcedRippleInstruction != 0)
 279 
 
273 
                {
 280 
 
274 
                    p.mIsNotReleased = true;
 281 
	public DaemonRippleTestCase()
275 
                    p.mDirectlyPlanned = false;
 282 
	{
276 
                    p.mBuildReason = BuildReason.Forced;
 283 
		mLogger.debug("DaemonBuildTestCase2");
277 
                    if ( p.mBuildTime == 100)
 284 
	}
278 
                        p.mBuildTime = 3;
 285 
 
279 
                    packageCollection.add(p);
 286 
	/**
280 
                }
287 
	 * Test Case main line
281 
            }
 288 
	 */
282 
        }
 289 
	public static void main(String[] args)
283
290 
	{
284 
		 @Override
 291 
		mLogger.debug("main");
285 
	    public void queryPlanControl(int mRtagId, PlanControl mPlanControl) throws Exception
 292 
		JUnitCore.main("com.erggroup.buildtool.utf.DaemonBuildTestCase2");
286 
	    {
 293 
	}
287 
		     mPlanControl.setThreshold(20);
 294 
 
288 
	    }
 295 
	/**
289
296 
	 * set up performed prior to any test method
290 
	}
 297 
	 */
291 
 
 298 
	@BeforeClass
292 
 
 299 
	public static void TestCaseSetUp()
293 
    public DaemonRippleTestCase()
 300 
	{
294 
    {
 301 
		mLogger.debug("TestCaseSetUp");
295 
        mLogger.debug("DaemonBuildTestCase2");
 302 
	}
296 
    }
 303 
 
297 
 
 304 
	/**
298 
    /**
 305 
	 * tear down performed after test methods
299 
     * Test Case main line
 306 
	 */
300 
     */
 307 
	@AfterClass
301 
    public static void main(String[] args)
 308 
	public static void TestCaseTearDown()
302 
    {
 309 
	{
303 
        mLogger.debug("main");
 310 
		mLogger.debug("TestCaseTearDown");
304 
        JUnitCore.main("com.erggroup.buildtool.utf.DaemonBuildTestCase2");
 311 
	}
305 
    }
 312 
 
306 
 
 313 
	/**
307 
    /**
 314 
	 * set up performed prior to each test method
308 
     * set up performed prior to any test method
 315 
	 */
309 
     */
 316 
	@Before
310 
    @BeforeClass
 317 
	public void TestSetUp()
311 
    public static void TestCaseSetUp()
 318 
	{
312 
    {
 319 
		mLogger.debug("TestSetUp");
313 
        mLogger.debug("TestCaseSetUp");
 320 
		System.setProperty("vix.utf.name", "DaemonBuildTestCase2");
314 
    }
 321 
		Package.mGenericMachtype = "win32";
315 
 
 322 
		Package.mGbeDpkg = ".";
316 
    /**
 323 
	}
317 
     * tear down performed after test methods
 324 
 
318 
     */
 325 
	/**
319 
    @AfterClass
 326 
	 * tear down performed after each test method
320 
    public static void TestCaseTearDown()
 327 
	 */
321 
    {
 328 
	@After
322 
        mLogger.debug("TestCaseTearDown");
 329 
	public void TestTearDown()
323 
    }
 330 
	{
324 
 
 331 
		mLogger.debug("TestTearDown");
325 
    /**
 332 
	}
326 
     * set up performed prior to each test method
 333 
 
327 
     */
 334 
	/** Check the build file contents
328 
    @Before
 335 
	 *  @param expectedName - Name of the expected output file
329 
    public void TestSetUp()
 336 
	 */
330 
    {
 337 
	private void checkBuildFile(String expectedName) {
331 
        mLogger.debug("TestSetUp");
 338 
		boolean rv;
332 
        System.setProperty("vix.utf.name", "DaemonBuildTestCase2");
 339 
		BuildFile buildFile;
333 
        Package.mGenericMachtype = "win32";
 340 
 
334 
        Package.mGbeDpkg = ".";
 341 
		buildFile = rippleEngine.getFirstBuildFileContent();
335 
    }
 342 
		assertTrue(buildFile != null);
336 
 
 343 
		assertTrue(buildFile.state != BuildFileState.Dummy);
337 
    /**
 344 
		assertTrue(buildFile.state != BuildFileState.Empty);
338 
     * tear down performed after each test method
 345 
 
339 
     */
 346 
		rv = Utilities.checkBuildfile(buildFile.content, expectedName);
340 
    @After
 347 
		assertTrue(rv);
341 
    public void TestTearDown()
 348 
	}
342 
    {
 349 
 
343 
        mLogger.debug("TestTearDown");
 350 
	/** Check the build file contents
344 
    }
 351 
	 *  @param expectedName - Name of the expected output file
345 
 
 352 
	 */
346 
    /** Check the build file contents
 353 
	private void checkBuildFileDummy(String expectedName) {
347 
     *  @param expectedName - Name of the expected output file
354 
		boolean rv;
348 
     */
 355 
		BuildFile buildFile;
349 
    private void checkBuildFile(String expectedName) {
 356 
 
350 
        boolean rv;
 357 
		buildFile = rippleEngine.getFirstBuildFileContent();
351 
        BuildFile buildFile;
 358 
		assertTrue(buildFile != null);
352
359 
		assertTrue(buildFile.state == BuildFileState.Dummy);
353 
        buildFile = rippleEngine.getFirstBuildFileContent();
 360 
		assertTrue(buildFile.state != BuildFileState.Empty);
354 
        assertTrue(buildFile != null);
 361 
 
355 
        assertTrue(buildFile.state != BuildFileState.Dummy);
 362 
		rv = Utilities.checkBuildfile(buildFile.content, expectedName);
356 
        assertTrue(buildFile.state != BuildFileState.Empty);
 363 
		assertTrue(rv);
357
364 
	}
358 
        rv = Utilities.checkBuildfile(buildFile.content, expectedName);
 365 
 
359 
        assertTrue(rv);
 366 
	/**
360 
    }
 367 
	 *  Create a mesh of packages
361
368 
	 *  Ripple the one at the bottom
362 
    /** Check the build file contents
 369 
	 */
363 
     *  @param expectedName - Name of the expected output file
370 
	@Test
364 
     */
 371 
	public void RippleTest_1()
365 
    private void checkBuildFileDummy(String expectedName) {
 372 
	{
366 
        boolean rv;
 373 
		String tName = "ripple1";
367 
        BuildFile buildFile;
 374 
		mLogger.debug("RippleTest {}", tName);
368
375 
		System.out.println("RippleTest " + tName);
369 
        buildFile = rippleEngine.getFirstBuildFileContent();
 376 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
370 
        assertTrue(buildFile != null);
 377 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
371 
        assertTrue(buildFile.state == BuildFileState.Dummy);
 378 
 
372 
        assertTrue(buildFile.state != BuildFileState.Empty);
 379 
		try
373
380 
		{
374 
        rv = Utilities.checkBuildfile(buildFile.content, expectedName);
 381 
			rippleEngine.collectMetaData();
375 
        assertTrue(rv);
 382 
 
376 
    }
 383 
			//  Generate basic test set and then tweak for this test
377 
 
 384 
			initTestPackages("p", 0);
378 
    /**
 385 
 
379 
     *  Create a mesh of packages
 386 
			createWip(2000, "p1.cr");
380 
     *  Ripple the one at the bottom
 387 
			rippleEngine.planRelease(false);
381 
     */
 388 
		}
382 
    @Test
 389 
		catch (Exception e)
383 
    public void RippleTest_1()
 390 
		{
384 
    {
 391 
		}
385 
        String tName = "ripple1";
 392 
 
386 
        mLogger.debug("RippleTest {}", tName);
 393 
		checkBuildFile(tName);
387 
        System.out.println("RippleTest " + tName);
 394 
 
388 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 395 
	}
389 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 396 
 
390
397 
	/**
391 
        try
 398 
	 *  Create a mesh of packages
392 
        {
 399 
	 *  Ripple the one not at the bottom
393 
            rippleEngine.collectMetaData();
 400 
	 */
394
401 
	@Test
395 
            //  Generate basic test set and then tweak for this test
 402 
	public void RippleTest_2()
396 
            initTestPackages("p");
 403 
	{
397
404 
		String tName = "ripple2";
398 
            createWip(2000, "p1.cr");
 405 
		mLogger.debug("RippleTest {}", tName);
399 
            rippleEngine.planRelease(false);
 406 
		System.out.println("RippleTest " + tName);
400 
        }
 407 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
401 
        catch (Exception e)
 408 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
402 
        {
 409 
 
403 
        }
 410 
		try
404 
 
 411 
		{
405 
        checkBuildFile(tName);
 412 
			rippleEngine.collectMetaData();
406
413 
 
407 
    }
 414 
			//  Generate basic test set and then tweak for this test
408
415 
			initTestPackages("p", 0);
409 
    /**
 416 
 
410 
     *  Create a mesh of packages
 417 
			createWip(2000, "p2.cr");
411 
     *  Ripple the one not at the bottom
 418 
			rippleEngine.planRelease(false);
412 
     */
 419 
		}
413 
    @Test
 420 
		catch (Exception e)
414 
    public void RippleTest_2()
 421 
		{
415 
    {
 422 
		}
416 
        String tName = "ripple2";
 423 
 
417 
        mLogger.debug("RippleTest {}", tName);
 424 
		checkBuildFile(tName);
418 
        System.out.println("RippleTest " + tName);
 425 
	}
419 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 426 
 
420 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 427 
 
421
428 
 
422 
        try
 429 
	/**
423 
        {
 430 
	 *  Create a mesh of packages
424 
            rippleEngine.collectMetaData();
 431 
	 *  Create a package that will feed into the mesh
425
432 
	 *  Mark bottom of the mesh as being rippled
426 
            //  Generate basic test set and then tweak for this test
 433 
	 *  Mark create a WIP on the package feeding the mesh such that the additional time < 20%
427 
            initTestPackages("p");
 434 
	 *
428
435 
	 */
429 
            createWip(2000, "p2.cr");
 436 
	@Test
430 
            rippleEngine.planRelease(false);
 437 
	public void RippleTest_3()
431 
        }
 438 
	{
432 
        catch (Exception e)
 439 
		String tName = "ripple3";
433 
        {
 440 
		mLogger.debug("RippleTest {}", tName);
434 
        }
 441 
		System.out.println("RippleTest " + tName);
435 
 
 442 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
436 
        checkBuildFile(tName);
 443 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
437 
    }
 444 
 
438 
 
 445 
		try
439 
 
 446 
		{
440
447 
			rippleEngine.collectMetaData();
441 
    /**
 448 
 
442 
     *  Create a mesh of packages
 449 
			//  Generate basic test set and then tweak for this test
443 
     *  Create a package that will feed into the mesh
 450 
			initTestPackages("p", 0);
444 
     *  Mark bottom of the mesh as being rippled
 451 
 
445 
     *  Mark create a WIP on the package feeding the mesh such that the additional time < 20%
 452 
			Package p1 = ripplePackage("p1.cr");
446 
     *
453 
 
447 
     */
 454 
			Package  p0 = createPackage(20, "p0");
448 
    @Test
 455 
			testPackageCollection.add(p0);
449 
    public void RippleTest_3()
 456 
			setBuildTime("p0.cr", 10);
450 
    {
 457 
			p1.addDependency(p0);
451 
        String tName = "ripple3";
 458 
			createWip(21, "p0.cr");
452 
        mLogger.debug("RippleTest {}", tName);
 459 
 
453 
        System.out.println("RippleTest " + tName);
 460 
			rippleEngine.planRelease(false);
454 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 461 
		}
455 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 462 
		catch (Exception e)
456
463 
		{
457 
        try
 464 
		}
458 
        {
 465 
 
459 
            rippleEngine.collectMetaData();
 466 
		checkBuildFile(tName);
460
467 
	}
461 
            //  Generate basic test set and then tweak for this test
 468 
 
462 
            initTestPackages("p");
 469 
	/**
463
470 
	 *  Create a mesh of packages
464 
            Package p1 = ripplePackage("p1.cr");
 471 
	 *  Create a package that will feed into the mesh
465
472 
	 *  Mark bottom of the mesh as being rippled
466 
            Package  p0 = createPackage(20, "p0");
 473 
	 *  Mark create a WIP on the package feeding the mesh such that the additional time > 20%
467 
            testPackageCollection.add(p0);
 474 
	 *
468 
            setBuildTime("p0.cr", 10);
 475 
	 */
469 
            p1.addDependency(p0);
 476 
	@Test
470 
            createWip(21, "p0.cr");
 477 
	public void RippleTest_4()
471
478 
	{
472 
            rippleEngine.planRelease(false);
 479 
		String tName = "ripple4";
473 
        }
 480 
		mLogger.debug("RippleTest {}", tName);
474 
        catch (Exception e)
 481 
		System.out.println("RippleTest " + tName);
475 
        {
 482 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
476 
        }
 483 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
477 
 
 484 
 
478 
        checkBuildFile(tName);
 485 
		try
479 
    }
 486 
		{
480
487 
			rippleEngine.collectMetaData();
481 
    /**
 488 
 
482 
     *  Create a mesh of packages
 489 
			//  Generate basic test set and then tweak for this test
483 
     *  Create a package that will feed into the mesh
 490 
			initTestPackages("p", 0);
484 
     *  Mark bottom of the mesh as being rippled
 491 
 
485 
     *  Mark create a WIP on the package feeding the mesh such that the additional time > 20%
 492 
			Package p1 = ripplePackage("p1.cr");
486 
     *
493 
 
487 
     */
 494 
			Package  p0 = createPackage(20, "p0");
488 
    @Test
 495 
			testPackageCollection.add(p0);
489 
    public void RippleTest_4()
 496 
			setBuildTime("p0.cr", 200);
490 
    {
 497 
			p1.addDependency(p0);
491 
        String tName = "ripple4";
 498 
			createWip(21, "p0.cr");
492 
        mLogger.debug("RippleTest {}", tName);
 499 
 
493 
        System.out.println("RippleTest " + tName);
 500 
			rippleEngine.planRelease(false);
494 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 501 
		}
495 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 502 
		catch (Exception e)
496
503 
		{
497 
        try
 504 
		}
498 
        {
 505 
 
499 
            rippleEngine.collectMetaData();
 506 
		checkBuildFile(tName);
500
507 
	}
501 
            //  Generate basic test set and then tweak for this test
 508 
 
502 
            initTestPackages("p");
 509 
	/**
503
510 
	 *  Create a mesh of packages
504 
            Package p1 = ripplePackage("p1.cr");
 511 
	 *  Create a package that will feed into the mesh
505
512 
	 *  Mark bottom of the mesh as being rippled
506 
            Package  p0 = createPackage(20, "p0");
 513 
	 *  Mark RippleRequest on the package feeding the mesh such that the additional time > 20%
507 
            testPackageCollection.add(p0);
 514 
	 *
508 
            setBuildTime("p0.cr", 200);
 515 
	 */
509 
            p1.addDependency(p0);
 516 
	@Test
510 
            createWip(21, "p0.cr");
 517 
	public void RippleTest_4a()
511
518 
	{
512 
            rippleEngine.planRelease(false);
 519 
		String tName = "ripple4a";
513 
        }
 520 
		mLogger.debug("RippleTest {}", tName);
514 
        catch (Exception e)
 521 
		System.out.println("RippleTest " + tName);
515 
        {
 522 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
516 
        }
 523 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
517 
 
 524 
 
518 
        checkBuildFile(tName);
 525 
		try
519 
    }
526 
		{
520
527 
			rippleEngine.collectMetaData();
521 
    /**
 528 
 
522 
     *  Create a mesh of packages
 529 
			//  Generate basic test set and then tweak for this test
523 
     *  Create a package that will feed into the mesh
 530 
			initTestPackages("p", 0);
524 
     *  Mark bottom of the mesh as being rippled
 531 
 
525 
     *  Mark RippleRequest on the package feeding the mesh such that the additional time > 20%
 532 
			Package p1 = ripplePackage("p1.cr");
526 
     *
533 
 
527 
     */
 534 
			Package  p0 = createPackage(20, "p0");
528 
    @Test
 535 
			testPackageCollection.add(p0);
529 
    public void RippleTest_4a()
 536 
			setBuildTime("p0.cr", 200);
530 
    {
 537 
			p1.addDependency(p0);
531 
        String tName = "ripple4a";
 538 
			requestRipple("p0.cr");
532 
        mLogger.debug("RippleTest {}", tName);
 539 
 
533 
        System.out.println("RippleTest " + tName);
 540 
			rippleEngine.planRelease(false);
534 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 541 
		}
535 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 542 
		catch (Exception e)
536
543 
		{
537 
        try
 544 
		}
538 
        {
 545 
 
539 
            rippleEngine.collectMetaData();
 546 
		checkBuildFile(tName);
540
547 
	}
541 
            //  Generate basic test set and then tweak for this test
 548 
 
542 
            initTestPackages("p");
 549 
 
543
550 
	/**
544 
            Package p1 = ripplePackage("p1.cr");
 551 
	 *  Create a mesh of packages
545
552 
	 *      Create a test package
546 
            Package  p0 = createPackage(20, "p0");
 553 
	 *      Create a WIP
547 
            testPackageCollection.add(p0);
 554 
	 *      Test should be built first
548 
            setBuildTime("p0.cr", 200);
 555 
	 */
549 
            p1.addDependency(p0);
 556 
	@Test
550 
            requestRipple("p0.cr");
 557 
	public void RippleTest_5()
551
558 
	{
552 
            rippleEngine.planRelease(false);
 559 
		String tName = "ripple5";
553 
        }
 560 
		mLogger.debug("RippleTest {}", tName);
554 
        catch (Exception e)
 561 
		System.out.println("RippleTest " + tName);
555 
        {
 562 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
556 
        }
 563 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
557 
 
 564 
 
558 
        checkBuildFile(tName);
 565 
		try
559 
    }
566 
		{
560
567 
			rippleEngine.collectMetaData();
561 
 
 568 
 
562 
    /**
 569 
			//  Generate basic test set and then tweak for this test
563 
     *  Create a mesh of packages
 570 
			initTestPackages("p", 0);
564 
     *      Create a test package
 571 
 
565 
     *      Create a WIP
 572 
			createWip (2000, "p1.cr");
566 
     *      Test should be built first
573 
			createTest(3333, "p5.cr");
567 
     */
 574 
			createTest(-1  , "p4.cr");
568 
    @Test
 575 
			rippleEngine.planRelease(false);
569 
    public void RippleTest_5()
 576 
		}
570 
    {
 577 
		catch (Exception e)
571 
        String tName = "ripple5";
 578 
		{
572 
        mLogger.debug("RippleTest {}", tName);
 579 
		}
573 
        System.out.println("RippleTest " + tName);
 580 
 
574 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 581 
		checkBuildFile(tName);
575 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 582 
	}
576
583 
 
577 
        try
 584 
	/**
578 
        {
 585 
	 *  Create a mesh of packages
579 
            rippleEngine.collectMetaData();
 586 
	 *  Request a ripple (daemon Instruction)
580
587 
	 */
581 
            //  Generate basic test set and then tweak for this test
 588 
	@Test
582 
            initTestPackages("p");
 589 
	public void RippleTest_6()
583
590 
	{
584 
            createWip (2000, "p1.cr");
 591 
		String tName = "ripple6";
585 
            createTest(3333, "p5.cr");
 592 
		mLogger.debug("RippleTest {}", tName);
586 
            createTest(-1  , "p4.cr");
 593 
		System.out.println("RippleTest " + tName);
587 
            rippleEngine.planRelease(false);
 594 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
588 
        }
 595 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
589 
        catch (Exception e)
 596 
 
590 
        {
 597 
		try
591 
        }
 598 
		{
592 
 
 599 
			rippleEngine.collectMetaData();
593 
        checkBuildFile(tName);
 600 
 
594 
    }
 601 
			//  Generate basic test set and then tweak for this test
595
602 
			initTestPackages("p", 0);
596 
    /**
 603 
 
597 
     *  Create a mesh of packages
 604 
			requestRipple("p5.cr");
598 
     *  Request a ripple (daemon Instruction)
 605 
			rippleEngine.planRelease(false);
599 
     */
 606 
		}
600 
    @Test
 607 
		catch (Exception e)
601 
    public void RippleTest_6()
 608 
		{
602 
    {
 609 
		}
603 
        String tName = "ripple6";
 610 
 
604 
        mLogger.debug("RippleTest {}", tName);
 611 
		checkBuildFile(tName);
605 
        System.out.println("RippleTest " + tName);
 612 
	}
606 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 613 
 
607 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 614 
	/**
608
615 
	 * Create a mesh of packages
609 
        try
 616 
	 * Create a circular dependency
610 
        {
 617 
	 * Create a WIP to 'fix' the circular dependency
611 
            rippleEngine.collectMetaData();
 618 
	 */
612
619 
	@Test
613 
            //  Generate basic test set and then tweak for this test
 620 
	public void RippleTest_7()
614 
            initTestPackages("p");
 621 
	{
615
622 
		String tName = "ripple7";
616 
            requestRipple("p5.cr");
 623 
		mLogger.debug("RippleTest {}", tName);
617 
            rippleEngine.planRelease(false);
 624 
		System.out.println("RippleTest " + tName);
618 
        }
 625 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
619 
        catch (Exception e)
 626 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
620 
        {
 627 
 
621 
        }
 628 
		try
622 
 
 629 
		{
623 
        checkBuildFile(tName);
 630 
			rippleEngine.collectMetaData();
624 
    }
 631 
 
625
632 
			//  Generate basic test set and then tweak for this test
626 
    /**
 633 
			/*    A basic set of packages
627 
     * Create a mesh of packages
 634 
			 */
628 
     * Create a circular dependency
 635 
			Package  p1 = createPackage(1, "p1");
629 
     * Create a WIP to 'fix' the circular dependency
 636 
			Package  p2 = createPackage(2, "p2");
630 
     */
 637 
			Package  p3 = createPackage(3, "p3");
631 
    @Test
 638 
			Package  p4 = createPackage(4, "p4");
632 
    public void RippleTest_7()
 639 
 
633 
    {
 640 
			testPackageCollection.add(p1);
634 
        String tName = "ripple7";
 641 
			testPackageCollection.add(p2);
635 
        mLogger.debug("RippleTest {}", tName);
 642 
			testPackageCollection.add(p3);
636 
        System.out.println("RippleTest " + tName);
 643 
			testPackageCollection.add(p4);
637 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 644 
 
638 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 645 
			// Create circular dependency
639
646 
			p2.addDependency(p1);
640 
        try
 647 
			p3.addDependency(p2);
641 
        {
 648 
			p4.addDependency(p3);
642 
            rippleEngine.collectMetaData();
 649 
			p1.addDependency(p4);
643
650 
 
644 
            //  Generate basic test set and then tweak for this test
 651 
 
645 
            /*    A basic set of packages
 652 
			Package  p1fixed = createWip(4000, "p1.cr");
646 
             */
 653 
			p1fixed.resetDependencies();
647 
             Package  p1 = createPackage(1, "p1");
 654 
 
648 
             Package  p2 = createPackage(2, "p2");
 655 
			rippleEngine.planRelease(false);
649 
             Package  p3 = createPackage(3, "p3");
 656 
		}
650 
             Package  p4 = createPackage(4, "p4");
 657 
		catch (Exception e)
651
658 
		{
652 
             testPackageCollection.add(p1);
 659 
			mLogger.error("Exception in UTF: {}", e.getMessage());
653 
             testPackageCollection.add(p2);
 660 
		}
654 
             testPackageCollection.add(p3);
 661 
 
655 
             testPackageCollection.add(p4);
 662 
		checkBuildFile(tName);
656
663 
	}
657 
             // Create circular dependency
 664 
 
658 
             p2.addDependency(p1);
 665 
	/**
659 
             p3.addDependency(p2);
 666 
	 * Create a mesh of packages
660 
             p4.addDependency(p3);
 667 
	 * Create a dependencies
661 
             p1.addDependency(p4);
 668 
	 * Create a WIP to 'create' a circular dependency
662
669 
	 *
663
670 
	 * Should detect that added package will create issue
664 
             Package  p1fixed = createWip(4000, "p1.cr");
 671 
	 *
665 
             p1fixed.resetDependencies();
 672 
	 */
666 
             testPackageCollection.add(p1fixed);
 673 
	@Test
667
674 
	public void RippleTest_8()
668 
 
 675 
	{
669 
            rippleEngine.planRelease(false);
 676 
		String tName = "ripple8";
670 
        }
 677 
		mLogger.debug("RippleTest {}", tName);
671 
        catch (Exception e)
 678 
		System.out.println("RippleTest " + tName);
672 
        {
 679 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
673 
        }
 680 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
674 
 
 681 
 
675 
        checkBuildFile(tName);
 682 
		try
676 
    }
 683 
		{
677
684 
			rippleEngine.collectMetaData();
678 
    /**
 685 
 
679 
     * Create a mesh of packages
 686 
			//  Generate basic test set and then tweak for this test
680 
     * Create a dependencies
 687 
			Package  p1 = createPackage(1, "p1");
681 
     * Create a WIP to 'create' a circular dependency
 688 
			Package  p2 = createPackage(2, "p2");
682 
     *
689 
			Package  p3 = createPackage(3, "p3");
683 
     * Should detect that added package will create issue
 690 
			Package  p4 = createPackage(4, "p4");
684 
     *
691 
 
685 
     */
 692 
			testPackageCollection.add(p1);
686 
    @Test
 693 
			testPackageCollection.add(p2);
687 
    public void RippleTest_8()
 694 
			testPackageCollection.add(p3);
688 
    {
 695 
			testPackageCollection.add(p4);
689 
        String tName = "ripple8";
 696 
 
690 
        mLogger.debug("RippleTest {}", tName);
 697 
			// Create dependency
691 
        System.out.println("RippleTest " + tName);
 698 
			p2.addDependency(p1);
692 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 699 
			p3.addDependency(p2);
693 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 700 
			p4.addDependency(p3);
694
701 
 
695 
        try
 702 
			Package  p1Broken = createWip(4000, "p1.cr");
696 
        {
 703 
			p1Broken.resetDependencies().addDependency(p4);
697 
            rippleEngine.collectMetaData();
 704 
 
698
705 
			// Create a ripple, so we get some output
699 
            //  Generate basic test set and then tweak for this test
 706 
			Package  p5 = createPackage(5, "p5");
700 
            /*    A basic set of packages
 707 
			testPackageCollection.add(p5);
701 
             */
 708 
			requestRipple("p5.cr");
702 
             Package  p1 = createPackage(1, "p1");
 709 
 
703 
             Package  p2 = createPackage(2, "p2");
 710 
			rippleEngine.planRelease(false);
704 
             Package  p3 = createPackage(3, "p3");
 711 
		}
705 
             Package  p4 = createPackage(4, "p4");
 712 
		catch (Exception e)
706
713 
		{
707 
             testPackageCollection.add(p1);
 714 
		}
708 
             testPackageCollection.add(p2);
 715 
 
709 
             testPackageCollection.add(p3);
 716 
		checkBuildFile(tName);
710 
             testPackageCollection.add(p4);
 717 
	}
711
718 
 
712 
             // Create dependency
 719 
	/**
713 
             p2.addDependency(p1);
 720 
	 * Create a WIP that will fail applyPV
714 
             p3.addDependency(p2);
 721 
	 *      Expect it to be rejected
715 
             p4.addDependency(p3);
 722 
	 *      Expect an email
716
723 
	 */
717 
             Package  p1Broken = createWip(400, "p1.cr");
 724 
	@Test
718 
             p1Broken.resetDependencies().addDependency(p4);
 725 
	public void RippleTest_9()
719
726 
	{
720 
          // Create a ripple, so we get some output
 727 
		String tName = "ripple9";
721 
             Package  p5 = createPackage(5, "p5");
 728 
		mLogger.debug("RippleTest {}", tName);
722 
             testPackageCollection.add(p5);
 729 
		System.out.println("RippleTest " + tName);
723 
             requestRipple("p5.cr");
 730 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
724 
 
 731 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
725 
            rippleEngine.planRelease(false);
 732 
 
726 
        }
 733 
		try
727 
        catch (Exception e)
 734 
		{
728 
        {
 735 
			rippleEngine.collectMetaData();
729 
        }
 736 
 
730 
 
 737 
			//  Generate basic test set and then tweak for this test
731 
        checkBuildFile(tName);
 738 
			/*    A basic set of packages
732 
    }
 739 
			 */
733
740 
			Package  p1 = createPackage(1, "p1");
734 
    /**
 741 
			Package  p2 = createPackage(2, "p2");
735 
     * Create a WIP that will fail applyPV
 742 
			Package  p3 = createPackage(3, "p3");
736 
     *      Expect it to be rejected
 743 
			Package  p4 = createPackage(4, "p4");
737 
     *      Expect an email
 744 
 
738 
     */
 745 
			testPackageCollection.add(p1);
739 
    @Test
 746 
			testPackageCollection.add(p2);
740 
    public void RippleTest_9()
 747 
			testPackageCollection.add(p3);
741 
    {
 748 
			testPackageCollection.add(p4);
742 
        String tName = "ripple9";
 749 
 
743 
        mLogger.debug("RippleTest {}", tName);
 750 
			p2.addDependency(p1);
744 
        System.out.println("RippleTest " + tName);
 751 
 
745 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 752 
			Package  p1Broken = createWip(4000, "p1.cr");
746 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 753 
			p1Broken.mVersion = "BadVersion";
747
754 
 
748 
        try
 755 
			rippleEngine.planRelease(false);
749 
        {
 756 
		}
750 
            rippleEngine.collectMetaData();
 757 
		catch (Exception e)
751
758 
		{
752 
            //  Generate basic test set and then tweak for this test
 759 
		}
753 
            /*    A basic set of packages
 760 
 
754 
             */
 761 
		checkBuildFileDummy(tName);
755 
             Package  p1 = createPackage(1, "p1");
 762 
	}
756 
             Package  p2 = createPackage(2, "p2");
 763 
 
757 
             Package  p3 = createPackage(3, "p3");
 764 
	/**
758 
             Package  p4 = createPackage(4, "p4");
 765 
	 * Create a few WIP that will fail applyPV and one that will succeed
759
766 
	 *      Expect it to be rejected
760 
             testPackageCollection.add(p1);
 767 
	 */
761 
             testPackageCollection.add(p2);
 768 
	@Test
762 
             testPackageCollection.add(p3);
 769 
	public void RippleTest_9a()
763 
             testPackageCollection.add(p4);
 770 
	{
764
771 
		String tName = "ripple9a";
765 
             p2.addDependency(p1);
 772 
		mLogger.debug("RippleTest {}", tName);
766
773 
		System.out.println("RippleTest " + tName);
767 
             Package  p1Broken = createWip(4000, "p1.cr");
 774 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
768 
             p1Broken.mVersion = "BadVersion";
 775 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
769
776 
 
770 
            rippleEngine.planRelease(false);
 777 
		try
771 
        }
 778 
		{
772 
        catch (Exception e)
 779 
			rippleEngine.collectMetaData();
773 
        {
 780 
 
774 
        }
 781 
			//  Generate basic test set and then tweak for this test
775 
 
 782 
			/*    A basic set of packages
776 
        checkBuildFileDummy(tName);
 783 
			 */
777 
    }
 784 
			Package  p1 = createPackage(1, "p1");
778
785 
			Package  p2 = createPackage(2, "p2");
779 
    /**
 786 
			Package  p3 = createPackage(3, "p3");
780 
     * Create a few WIP that will fail applyPV and one that will succeed
 787 
			Package  p4 = createPackage(4, "p4");
781 
     *      Expect it to be rejected
 788 
			Package  p5 = createPackage(5, "p5");
782 
     */
 789 
 
783 
    @Test
 790 
			testPackageCollection.add(p1);
784 
    public void RippleTest_9a()
 791 
			testPackageCollection.add(p2);
785 
    {
 792 
			testPackageCollection.add(p3);
786 
        String tName = "ripple9a";
 793 
			testPackageCollection.add(p4);
787 
        mLogger.debug("RippleTest {}", tName);
 794 
			testPackageCollection.add(p5);
788 
        System.out.println("RippleTest " + tName);
 795 
 
789 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 796 
			p5.addDependency(p2);
790 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 797 
 
791
798 
			Package  p1Broken = createWip(4001, "p1.cr");
792 
        try
 799 
			p1Broken.mVersion = "BadVersion";
793 
        {
 800 
 
794 
            rippleEngine.collectMetaData();
 801 
			Package  p2Broken = createWip(4002, "p2.cr");
795
802 
			p2Broken.mVersion = "BadVersion";
796 
            //  Generate basic test set and then tweak for this test
 803 
 
797 
            /*    A basic set of packages
 804 
			Package  p3Broken = createWip(4003, "p3.cr");
798 
             */
 805 
			p3Broken.mVersion = "BadVersion";
799 
             Package  p1 = createPackage(1, "p1");
 806 
 
800 
             Package  p2 = createPackage(2, "p2");
 807 
			createWip(4004, "p4.cr");
801 
             Package  p3 = createPackage(3, "p3");
 808 
 
802 
             Package  p4 = createPackage(4, "p4");
 809 
			rippleEngine.planRelease(false);
803 
             Package  p5 = createPackage(4, "p5");
 810 
		}
804
811 
		catch (Exception e)
805 
             testPackageCollection.add(p1);
 812 
		{
806 
             testPackageCollection.add(p2);
 813 
		}
807 
             testPackageCollection.add(p3);
 814 
 
808 
             testPackageCollection.add(p4);
 815 
		checkBuildFile(tName);
809 
             testPackageCollection.add(p5);
 816 
	}
810
817 
 
811 
             p5.addDependency(p2);
 818 
	/**
812
819 
	 * Create a few WIP that will fail applyPV and one that will succeed
813 
             Package  p1Broken = createWip(4001, "p1.cr");
 820 
	 *      Expect it to be rejected
814 
             p1Broken.mVersion = "BadVersion";
 821 
	 */
815 
 
 822 
	@Test
816 
             Package  p2Broken = createWip(4002, "p2.cr");
 823 
	public void RippleTest_9b()
817 
             p2Broken.mVersion = "BadVersion";
 824 
	{
818 
 
 825 
		String tName = "ripple9b";
819 
             Package  p3Broken = createWip(4003, "p3.cr");
 826 
		mLogger.debug("RippleTest {}", tName);
820 
             p3Broken.mVersion = "BadVersion";
 827 
		System.out.println("RippleTest " + tName);
821
828 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
822 
             createWip(4004, "p4.cr");
 829 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
823 
 
 830 
 
824 
            rippleEngine.planRelease(false);
 831 
		try
825 
        }
 832 
		{
826 
        catch (Exception e)
 833 
			rippleEngine.collectMetaData();
827 
        {
 834 
 
828 
        }
 835 
			//  Generate basic test set and then tweak for this test
829 
 
 836 
			/*    A basic set of packages
830 
        checkBuildFile(tName);
 837 
			 */
831 
    }
 838 
			Package  p1 = createPackage(1, "p1");
832
839 
			Package  p2 = createPackage(2, "p2");
833 
    /**
 840 
			Package  p3 = createPackage(3, "p3");
834 
     * Create a few WIP that will fail applyPV and one that will succeed
 841 
			Package  p4 = createPackage(4, "p4");
835 
     *      Expect it to be rejected
 842 
			Package  p5 = createPackage(5, "p5");
836 
     */
 843 
 
837 
    @Test
 844 
			testPackageCollection.add(p1);
838 
    public void RippleTest_9b()
 845 
			testPackageCollection.add(p2);
839 
    {
 846 
			testPackageCollection.add(p3);
840 
        String tName = "ripple9b";
 847 
			testPackageCollection.add(p4);
841 
        mLogger.debug("RippleTest {}", tName);
 848 
			testPackageCollection.add(p5);
842 
        System.out.println("RippleTest " + tName);
 849 
 
843 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 850 
			p2.addDependency(p1);
844 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 851 
			p3.addDependency(p2);
845
852 
			p4.addDependency(p3);
846 
        try
 853 
 
847 
        {
 854 
			p2.mVersion = "BadVersion";
848 
            rippleEngine.collectMetaData();
 855 
			ripplePackage("p1.cr");
849
856 
			requestRipple("p5.cr").mBuildTime = 1000;
850 
            //  Generate basic test set and then tweak for this test
 857 
 
851 
            /*    A basic set of packages
 858 
			rippleEngine.planRelease(false);
852 
             */
 859 
		}
853 
             Package  p1 = createPackage(1, "p1");
 860 
		catch (Exception e)
854 
             Package  p2 = createPackage(2, "p2");
 861 
		{
855 
             Package  p3 = createPackage(3, "p3");
 862 
		}
856 
             Package  p4 = createPackage(4, "p4");
 863 
 
857 
             Package  p5 = createPackage(5, "p5");
 864 
		checkBuildFile(tName);
858
865 
	}
859 
             testPackageCollection.add(p1);
 866 
 
860 
             testPackageCollection.add(p2);
 867 
 
861 
             testPackageCollection.add(p3);
 868 
	/**
862 
             testPackageCollection.add(p4);
 869 
	 *  Create a mesh of packages
863 
             testPackageCollection.add(p5);
 870 
	 *  Mark bottom as being rippled
864 
 
 871 
	 *
865 
             p2.addDependency(p1);
 872 
	 *  Expect a single plan with the next two two candidate packages
866 
             p3.addDependency(p2);
 873 
	 */
867 
             p4.addDependency(p3);
 874 
	@Test
868
875 
	public void RippleTest_10()
869 
             p2.mVersion = "BadVersion";
 876 
	{
870 
             ripplePackage("p1.cr");
 877 
		String tName = "ripple10";
871 
             requestRipple("p5.cr").mBuildTime = 1000;
 878 
		mLogger.debug("RippleTest {}", tName);
872 
 
 879 
		System.out.println("RippleTest " + tName);
873 
            rippleEngine.planRelease(false);
 880 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
874 
        }
 881 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
875 
        catch (Exception e)
 882 
 
876 
        {
 883 
		try
877 
        }
 884 
		{
878 
 
 885 
			rippleEngine.collectMetaData();
879 
        checkBuildFile(tName);
 886 
 
880 
    }
 887 
			//  Generate basic test set and then tweak for this test
881
888 
			initTestPackages("p", 0);
882
889 
 
883 
    /**
 890 
			ripplePackage("p1.cr");
884 
     *  Create a mesh of packages
 891 
			rippleEngine.planRelease(false);
885 
     *  Mark bottom as being rippled
 892 
		}
886 
     *
893 
		catch (Exception e)
887 
     *  Expect a single plan with the next two two candidate packages
 894 
		{
888 
     */
 895 
		}
889 
    @Test
 896 
 
890 
    public void RippleTest_10()
 897 
		checkBuildFile(tName);
891 
    {
 898 
	}
892 
        String tName = "ripple10";
 899 
 
893 
        mLogger.debug("RippleTest {}", tName);
 900 
	/**
894 
        System.out.println("RippleTest " + tName);
 901 
	 *  Create two meshes of packages
895 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 902 
	 *  Create a ripple in both
896 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 903 
	 */
897
904 
	@Test
898 
        try
 905 
	public void RippleTest_11()
899 
        {
 906 
	{
900 
            rippleEngine.collectMetaData();
 907 
		String tName = "ripple11";
901
908 
		mLogger.debug("RippleTest {}", tName);
902 
            //  Generate basic test set and then tweak for this test
 909 
		System.out.println("RippleTest " + tName);
903 
            initTestPackages("p");
 910 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
904
911 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
905 
            ripplePackage("p1.cr");
 912 
 
906 
            rippleEngine.planRelease(false);
 913 
		try
907 
        }
 914 
		{
908 
        catch (Exception e)
 915 
			rippleEngine.collectMetaData();
909 
        {
 916 
 
910 
        }
 917 
			//  Generate basic test set and then tweak for this test
911 
 
 918 
			initTestPackages("p", 0);
912 
        checkBuildFile(tName);
 919 
			initTestPackages("z", 100);
913 
    }
 920 
			setBuildTime("z4.cr", 200);
914
921 
 
915 
    /**
 922 
			createWip(2000, "p1.cr");
916 
     *  Create two meshes of packages
 923 
			createWip(3000, "z1.cr");
917 
     *  Create a ripple in both
 924 
 
918 
     */
 925 
			rippleEngine.planRelease(false);
919 
    @Test
 926 
		}
920 
    public void RippleTest_11()
 927 
		catch (Exception e)
921 
    {
 928 
		{
922 
        String tName = "ripple11";
 929 
		}
923 
        mLogger.debug("RippleTest {}", tName);
 930 
 
924 
        System.out.println("RippleTest " + tName);
 931 
		checkBuildFile(tName);
925 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 932 
	}
926 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 933 
 
927
934 
	/**
928 
        try
 935 
	 *  Create a simple dependency chain
929 
        {
 936 
	 *  Mark one of the packages as an SDK
930 
            rippleEngine.collectMetaData();
 937 
	 *  Ensure that a ripple will not affect the SDK package
931
938 
	 *
932 
            //  Generate basic test set and then tweak for this test
 939 
	 */
933 
            initTestPackages("p");
 940 
	@Test
934 
            initTestPackages("z");
 941 
	public void RippleTest_12()
935 
            setBuildTime("z4.cr", 200);
 942 
	{
936
943 
		String tName = "ripple12";
937 
            createWip(2000, "p1.cr");
 944 
		mLogger.debug("RippleTest {}", tName);
938 
            createWip(2000, "z1.cr");
 945 
		System.out.println("RippleTest " + tName);
939
946 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
940 
            rippleEngine.planRelease(false);
 947 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
941 
        }
 948 
 
942 
        catch (Exception e)
 949 
		try
943 
        {
 950 
		{
944 
        }
 951 
			rippleEngine.collectMetaData();
945 
 
 952 
 
946 
        checkBuildFile(tName);
 953 
			/*    A basic set of packages
947 
    }
 954 
			 */
948
955 
			Package  p1 = createPackage(1, "p1");
949 
    /**
 956 
			Package  p2 = createPackage(2, "p2");
950 
     *  Create a simple dependency chain
 957 
			Package  p3 = createPackage(3, "p3");
951 
     *  Mark one of the packages as an SDK
 958 
			Package  p4 = createPackage(4, "p4");
952 
     *  Ensure that a ripple will not affect the SDK package
 959 
			Package  p5 = createPackage(5, "p5");
953 
     *
960 
 
954 
     */
 961 
			testPackageCollection.add(p1);
955 
    @Test
 962 
			testPackageCollection.add(p2);
956 
    public void RippleTest_12()
 963 
			testPackageCollection.add(p3);
957 
    {
 964 
			testPackageCollection.add(p4);
958 
        String tName = "ripple12";
 965 
			testPackageCollection.add(p5);
959 
        mLogger.debug("RippleTest {}", tName);
 966 
 
960 
        System.out.println("RippleTest " + tName);
 967 
			p2.addDependency(p1);
961 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 968 
			p3.addDependency(p1);
962 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 969 
			p4.addDependency(p3).addDependency(p2);
963
970 
			p5.addDependency(p3);
964 
        try
 971 
 
965 
        {
 972 
			// Mark SDK
966 
            rippleEngine.collectMetaData();
 973 
			p3.mIsSdk = true;
967
974 
 
968 
            /*    A basic set of packages
 975 
			// Create a ripple, so we get some output
969 
             */
 976 
			requestRipple("p1.cr");
970 
             Package  p1 = createPackage(1, "p1");
 977 
 
971 
             Package  p2 = createPackage(2, "p2");
 978 
			rippleEngine.planRelease(false);
972 
             Package  p3 = createPackage(3, "p3");
 979 
		}
973 
             Package  p4 = createPackage(4, "p4");
 980 
		catch (Exception e)
974 
             Package  p5 = createPackage(4, "p5");
 981 
		{
975
982 
		}
976 
             testPackageCollection.add(p1);
 983 
 
977 
             testPackageCollection.add(p2);
 984 
		checkBuildFile(tName);
978 
             testPackageCollection.add(p3);
 985 
	}
979 
             testPackageCollection.add(p4);
 986 
 
980 
             testPackageCollection.add(p5);
 987 
	/**
981 
 
 988 
	 *  Create a simple dependency chain
982 
             p2.addDependency(p1);
 989 
	 *  Mark one of the packages as having a rippleStop
983 
             p3.addDependency(p1);
 990 
	 *  Create a ripple
984 
             p4.addDependency(p3).addDependency(p2);
 991 
	 *
985 
             p5.addDependency(p3);
 992 
	 *  Ensure that a ripple will not propagate through the ripple stop
986
993 
	 *
987 
             // Mark SDK
 994 
	 */
988 
             p3.mIsSdk = true;
 995 
	@Test
989
996 
	public void RippleTest_13()
990 
             // Create a ripple, so we get some output
 997 
	{
991 
             requestRipple("p1.cr");
 998 
		String tName = "ripple13";
992
999 
		mLogger.debug("RippleTest {}", tName);
993 
            rippleEngine.planRelease(false);
 1000 
		System.out.println("RippleTest " + tName);
994 
        }
 1001 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
995 
        catch (Exception e)
 1002 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
996 
        {
 1003 
 
997 
        }
 1004 
		try
998 
 
 1005 
		{
999 
        checkBuildFile(tName);
 1006 
			rippleEngine.collectMetaData();
1000 
    }
 1007 
 
1001
1008 
			/*    A basic set of packages
1002 
    /**
 1009 
			 */
1003 
     *  Create a simple dependency chain
 1010 
			Package  p1 = createPackage(1, "p1");
1004 
     *  Mark one of the packages as having a rippleStop
 1011 
			Package  p2 = createPackage(2, "p2");
1005 
     *  Create a ripple
 1012 
			Package  p3 = createPackage(3, "p3");
1006 
     *
1013 
			Package  p4 = createPackage(4, "p4");
1007 
     *  Ensure that a ripple will not propagate through the ripple stop
1014 
			Package  p5 = createPackage(5, "p5");
1008 
     *
1015 
 
1009 
     */
 1016 
			testPackageCollection.add(p1);
1010 
    @Test
 1017 
			testPackageCollection.add(p2);
1011 
    public void RippleTest_13()
 1018 
			testPackageCollection.add(p3);
1012 
    {
 1019 
			testPackageCollection.add(p4);
1013 
        String tName = "ripple13";
 1020 
			testPackageCollection.add(p5);
1014 
        mLogger.debug("RippleTest {}", tName);
 1021 
 
1015 
        System.out.println("RippleTest " + tName);
 1022 
			p2.addDependency(p1);
1016 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 1023 
			p3.addDependency(p1);
1017 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 1024 
			p4.addDependency(p3).addDependency(p2);
1018
1025 
			p5.addDependency(p3);
1019 
        try
 1026 
 
1020 
        {
 1027 
			// Mark SDK
1021 
            rippleEngine.collectMetaData();
 1028 
			p3.mRippleStop = 's';
1022
1029 
 
1023 
            /*    A basic set of packages
 1030 
			// Create a ripple, so we get some output
1024 
             */
 1031 
			requestRipple("p1.cr");
1025 
             Package  p1 = createPackage(1, "p1");
 1032 
 
1026 
             Package  p2 = createPackage(2, "p2");
 1033 
			rippleEngine.planRelease(false);
1027 
             Package  p3 = createPackage(3, "p3");
 1034 
		}
1028 
             Package  p4 = createPackage(4, "p4");
 1035 
		catch (Exception e)
1029 
             Package  p5 = createPackage(4, "p5");
 1036 
		{
1030
1037 
		}
1031 
             testPackageCollection.add(p1);
 - 
 
1032 
             testPackageCollection.add(p2);
 - 
 
1033 
             testPackageCollection.add(p3);
 - 
 
1034 
             testPackageCollection.add(p4);
 - 
 
1035 
             testPackageCollection.add(p5);
 - 
 
1036 
 
 - 
 
1037 
             p2.addDependency(p1);
 - 
 
1038 
             p3.addDependency(p1);
 - 
 
1039 
             p4.addDependency(p3).addDependency(p2);
 - 
 
1040 
             p5.addDependency(p3);
 - 
 
1041
- 
 
1042 
             // Mark SDK
 - 
 
1043 
             p3.mRippleStop = 's';
 - 
 
1044
- 
 
1045 
             // Create a ripple, so we get some output
 - 
 
1046 
             requestRipple("p1.cr");
 - 
 
1047
- 
 
1048 
            rippleEngine.planRelease(false);
 - 
 
1049 
        }
 - 
 
1050 
        catch (Exception e)
 - 
 
1051 
        {
 - 
 
1052 
        }
 - 
 
1053 
 
 - 
 
1054 
        checkBuildFile(tName);
 - 
 
1055 
    }
- 
 
1056
- 
 
1057 
    /**
 - 
 
1058 
     *  Create a simple dependency chain
 - 
 
1059 
     *  Create a WIP that is not already in the release
 - 
 
1060 
     *
 - 
 
1061 
     *  Ensure the WIP is included into the build set
 - 
 
1062 
     *
- 
 
1063 
     */
 - 
 
1064 
    @Test
 - 
 
1065 
    public void RippleTest_14()
 - 
 
1066 
    {
 - 
 
1067 
        String tName = "ripple14";
 - 
 
1068 
        mLogger.debug("RippleTest {}", tName);
 - 
 
1069 
        System.out.println("RippleTest " + tName);
 - 
 
1070 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 - 
 
1071 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 - 
 
1072
- 
 
1073 
        try
 - 
 
1074 
        {
 - 
 
1075 
            rippleEngine.collectMetaData();
 - 
 
1076
- 
 
1077 
            /*    A basic set of packages
 - 
 
1078 
             */
 - 
 
1079 
             Package  p1 = createPackage(1, "p1");
 - 
 
1080 
             Package  p2 = createPackage(2, "p2");
 - 
 
1081 
             Package  p3 = createPackage(3, "p3");
 - 
 
1082 
             Package  p4 = createPackage(4, "p4");
 - 
 
1083
- 
 
1084 
             testPackageCollection.add(p1);
 - 
 
1085 
             testPackageCollection.add(p2);
 - 
 
1086 
             testPackageCollection.add(p3);
 - 
 
1087 
             testPackageCollection.add(p4);
 - 
 
1088 
 
 - 
 
1089 
             p2.addDependency(p1);
 - 
 
1090 
             p3.addDependency(p2);
 - 
 
1091
- 
 
1092 
             // Mark as a WIP
 - 
 
1093 
             p4.mDirectlyPlanned = true;
 - 
 
1094
- 
 
1095
- 
 
1096 
            rippleEngine.planRelease(false);
 - 
 
1097 
        }
 - 
 
1098 
        catch (Exception e)
 - 
 
1099 
        {
 - 
 
1100 
        }
 - 
 
1101 
 
 - 
 
1102 
        checkBuildFile(tName);
 - 
 
1103 
    }
 - 
 
1104
- 
 
1105 
    /**
 - 
 
1106 
     *  Create a simple dependency chain
 - 
 
1107 
     *  Create a package that will be excluded
 - 
 
1108 
     *
 - 
 
1109 
     *  Ensure the upstream packages show up in the excluded list
 - 
 
1110 
     *
- 
 
1111 
     */
 - 
 
1112 
    @Test
 - 
 
1113 
    public void RippleTest_15()
 - 
 
1114 
    {
 - 
 
1115 
        String tName = "ripple15";
 - 
 
1116 
        mLogger.debug("RippleTest {}", tName);
 - 
 
1117 
        System.out.println("RippleTest " + tName);
 - 
 
1118 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 - 
 
1119 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 - 
 
1120
- 
 
1121 
        try
 - 
 
1122 
        {
 - 
 
1123 
            rippleEngine.collectMetaData();
 - 
 
1124
- 
 
1125 
            /*    A basic set of packages
 - 
 
1126 
             */
 - 
 
1127 
             Package  p1 = createPackage(1, "p1");
 - 
 
1128 
             Package  p2 = createPackage(2, "p2");
 - 
 
1129 
             Package  p3 = createPackage(3, "p3");
 - 
 
1130 
             Package  p4 = createPackage(4, "p4");
 - 
 
1131 
             Package  p5 = createPackage(5, "p5");
 - 
 
1132 
             Package  p6 = createPackage(6, "p6");
 - 
 
1133
- 
 
1134 
             testPackageCollection.add(p1);
 - 
 
1135 
             testPackageCollection.add(p2);
 - 
 
1136 
             testPackageCollection.add(p3);
 - 
 
1137 
             testPackageCollection.add(p4);
 - 
 
1138 
             testPackageCollection.add(p5);
 - 
 
1139 
             testPackageCollection.add(p6);
 - 
 
1140 
 
 - 
 
1141 
             p2.addDependency(p1);
 - 
 
1142 
             p3.addDependency(p2);
 - 
 
1143 
             p4.addDependency(p2);
 - 
 
1144 
             p5.addDependency(p4);
 - 
 
1145
- 
 
1146 
             p2.mVersion = "BadVersion";
 - 
 
1147 
             ripplePackage("p1.cr");
 - 
 
1148
- 
 
1149 
             // Create a ripple, so we get some output
 - 
 
1150 
 
 - 
 
1151 
             //requestRipple("p6.cr");
 - 
 
1152
- 
 
1153 
            rippleEngine.planRelease(false);
 - 
 
1154 
        }
 - 
 
1155 
        catch (Exception e)
 - 
 
1156 
        {
 - 
 
1157 
        }
 - 
 
1158 
 
 - 
 
1159 
        checkBuildFileDummy(tName);
 - 
 
1160 
    }
 - 
 
1161
- 
 
1162 
    /**
 - 
 
1163 
     *  Create a simple dependency chain
 - 
 
1164 
     *
- 
 
1165 
     *  Ensure that the build level is correctly calculated
 - 
 
1166 
     *  Should be able to build ALL the packages at the same level in any order
 - 
 
1167 
     *
- 
 
1168 
     */
 - 
 
1169 
    @Test
 - 
 
1170 
    public void RippleTest_16()
 - 
 
1171 
    {
 - 
 
1172 
        String tName = "ripple16";
 - 
 
1173 
        mLogger.debug("RippleTest {}", tName);
 - 
 
1174 
        System.out.println("RippleTest " + tName);
 - 
 
1175 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
 - 
 
1176 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
 - 
 
1177
- 
 
1178 
        try
 - 
 
1179 
        {
 - 
 
1180 
            rippleEngine.collectMetaData();
 - 
 
1181
- 
 
1182 
            /*    A basic set of packages
 - 
 
1183 
             */
 - 
 
1184 
             Package  p1 = createPackage(1, "p1");
 - 
 
1185 
             Package  p2 = createPackage(2, "p2");
 - 
 
1186 
             Package  p3 = createPackage(3, "p3");
 - 
 
1187 
             Package  p4 = createPackage(4, "p4");
 - 
 
1188 
             Package  p5 = createPackage(5, "p5");
 - 
 
1189 
             Package  p6 = createPackage(6, "p6");
 - 
 
1190
- 
 
1191 
             testPackageCollection.add(p1);
 - 
 
1192 
             testPackageCollection.add(p2);
 - 
 
1193 
             testPackageCollection.add(p3);
 - 
 
1194 
             testPackageCollection.add(p4);
 - 
 
1195 
             testPackageCollection.add(p5);
 - 
 
1196 
             testPackageCollection.add(p6);
 - 
 
1197 
 
 - 
 
1198 
             p2.addDependency(p1);
 - 
 
1199 
             p3.addDependency(p1);
 - 
 
1200 
             p4.addDependency(p1);
 - 
 
1201 
             p5.addDependency(p2);
 - 
 
1202
- 
 
1203 
             // Create a ripple, so we get some output
 - 
 
1204 
             requestRipple("p1.cr");
 - 
 
1205
- 
 
1206 
            rippleEngine.planRelease(false);
 - 
 
1207 
        }
 - 
 
1208 
        catch (Exception e)
 - 
 
1209 
        {
 - 
 
1210 
        }
 - 
 
1211 
 
 1038 
 
- 
 
 1039 
		checkBuildFile(tName);
- 
 
 1040 
	}
- 
 
 1041 
 
- 
 
 1042 
	/**
- 
 
 1043 
	 *  Create a simple dependency chain
- 
 
 1044 
	 *  Create a WIP that is not already in the release
- 
 
 1045 
	 *
- 
 
 1046 
	 *  Ensure the WIP is included into the build set
- 
 
 1047 
	 *
- 
 
 1048 
	 */
- 
 
 1049 
	@Test
- 
 
 1050 
	public void RippleTest_14()
- 
 
 1051 
	{
- 
 
 1052 
		String tName = "ripple14";
- 
 
 1053 
		mLogger.debug("RippleTest {}", tName);
- 
 
 1054 
		System.out.println("RippleTest " + tName);
- 
 
 1055 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
- 
 
 1056 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
- 
 
 1057 
 
- 
 
 1058 
		try
- 
 
 1059 
		{
- 
 
 1060 
			rippleEngine.collectMetaData();
- 
 
 1061 
 
- 
 
 1062 
			/*    A basic set of packages
- 
 
 1063 
			 */
- 
 
 1064 
			Package  p1 = createPackage(1, "p1");
- 
 
 1065 
			Package  p2 = createPackage(2, "p2");
- 
 
 1066 
			Package  p3 = createPackage(3, "p3");
- 
 
 1067 
 
- 
 
 1068 
			testPackageCollection.add(p1);
- 
 
 1069 
			testPackageCollection.add(p2);
- 
 
 1070 
			testPackageCollection.add(p3);
- 
 
 1071 
 
- 
 
 1072 
			p2.addDependency(p1);
- 
 
 1073 
			p3.addDependency(p2);
- 
 
 1074 
 
- 
 
 1075 
			// Mark as a WIP
- 
 
 1076 
			Package  p4 = createPackage(4, "p4");
- 
 
 1077 
			testPackageCollectionWip.add(p4);
- 
 
 1078 
			//p4.mDirectlyPlanned = true;
- 
 
 1079 
 
- 
 
 1080 
 
- 
 
 1081 
			rippleEngine.planRelease(false);
- 
 
 1082 
		}
- 
 
 1083 
		catch (Exception e)
- 
 
 1084 
		{
- 
 
 1085 
		}
- 
 
 1086 
 
1212 
        checkBuildFile(tName);
 1087 
		checkBuildFile(tName);
- 
 
 1088 
	}
- 
 
 1089 
 
- 
 
 1090 
	/**
- 
 
 1091 
	 *  Create a simple dependency chain
- 
 
 1092 
	 *  Create a package that will be excluded
- 
 
 1093 
	 *
- 
 
 1094 
	 *  Ensure the upstream packages show up in the excluded list
- 
 
 1095 
	 *
- 
 
 1096 
	 */
- 
 
 1097 
	@Test
- 
 
 1098 
	public void RippleTest_15()
- 
 
 1099 
	{
- 
 
 1100 
		String tName = "ripple15";
- 
 
 1101 
		mLogger.debug("RippleTest {}", tName);
- 
 
 1102 
		System.out.println("RippleTest " + tName);
- 
 
 1103 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
- 
 
 1104 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
- 
 
 1105 
 
- 
 
 1106 
		try
- 
 
 1107 
		{
- 
 
 1108 
			rippleEngine.collectMetaData();
- 
 
 1109 
 
- 
 
 1110 
			/*    A basic set of packages
- 
 
 1111 
			 */
- 
 
 1112 
			Package  p1 = createPackage(1, "p1");
- 
 
 1113 
			Package  p2 = createPackage(2, "p2");
- 
 
 1114 
			Package  p3 = createPackage(3, "p3");
- 
 
 1115 
			Package  p4 = createPackage(4, "p4");
- 
 
 1116 
			Package  p5 = createPackage(5, "p5");
- 
 
 1117 
			Package  p6 = createPackage(6, "p6");
- 
 
 1118 
 
- 
 
 1119 
			testPackageCollection.add(p1);
- 
 
 1120 
			testPackageCollection.add(p2);
- 
 
 1121 
			testPackageCollection.add(p3);
- 
 
 1122 
			testPackageCollection.add(p4);
- 
 
 1123 
			testPackageCollection.add(p5);
- 
 
 1124 
			testPackageCollection.add(p6);
- 
 
 1125 
 
- 
 
 1126 
			p2.addDependency(p1);
- 
 
 1127 
			p3.addDependency(p2);
- 
 
 1128 
			p4.addDependency(p2);
- 
 
 1129 
			p5.addDependency(p4);
- 
 
 1130 
 
- 
 
 1131 
			p2.mVersion = "BadVersion";
- 
 
 1132 
			ripplePackage("p1.cr");
- 
 
 1133 
 
- 
 
 1134 
			// Create a ripple, so we get some output
- 
 
 1135 
 
- 
 
 1136 
			//requestRipple("p6.cr");
- 
 
 1137 
 
- 
 
 1138 
			rippleEngine.planRelease(false);
- 
 
 1139 
		}
- 
 
 1140 
		catch (Exception e)
- 
 
 1141 
		{
- 
 
 1142 
		}
- 
 
 1143 
 
- 
 
 1144 
		checkBuildFileDummy(tName);
- 
 
 1145 
	}
- 
 
 1146 
 
- 
 
 1147 
	/**
- 
 
 1148 
	 *  Create a simple dependency chain
- 
 
 1149 
	 *
- 
 
 1150 
	 *  Ensure that the build level is correctly calculated
- 
 
 1151 
	 *  Should be able to build ALL the packages at the same level in any order
1213 
    }
 1152 
	 *
- 
 
 1153 
	 */
- 
 
 1154 
	@Test
- 
 
 1155 
	public void RippleTest_16()
- 
 
 1156 
	{
- 
 
 1157 
		String tName = "ripple16";
- 
 
 1158 
		mLogger.debug("RippleTest {}", tName);
- 
 
 1159 
		System.out.println("RippleTest " + tName);
- 
 
 1160 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
- 
 
 1161 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
- 
 
 1162 
 
- 
 
 1163 
		try
- 
 
 1164 
		{
- 
 
 1165 
			rippleEngine.collectMetaData();
- 
 
 1166 
 
- 
 
 1167 
			/*    A basic set of packages
- 
 
 1168 
			 */
- 
 
 1169 
			Package  p1 = createPackage(1, "p1");
- 
 
 1170 
			Package  p2 = createPackage(2, "p2");
- 
 
 1171 
			Package  p3 = createPackage(3, "p3");
- 
 
 1172 
			Package  p4 = createPackage(4, "p4");
- 
 
 1173 
			Package  p5 = createPackage(5, "p5");
- 
 
 1174 
			Package  p6 = createPackage(6, "p6");
- 
 
 1175 
 
- 
 
 1176 
			testPackageCollection.add(p1);
- 
 
 1177 
			testPackageCollection.add(p2);
- 
 
 1178 
			testPackageCollection.add(p3);
- 
 
 1179 
			testPackageCollection.add(p4);
- 
 
 1180 
			testPackageCollection.add(p5);
- 
 
 1181 
			testPackageCollection.add(p6);
- 
 
 1182 
 
- 
 
 1183 
			p2.addDependency(p1);
- 
 
 1184 
			p3.addDependency(p1);
- 
 
 1185 
			p4.addDependency(p1);
- 
 
 1186 
			p5.addDependency(p2);
- 
 
 1187 
 
- 
 
 1188 
			// Create a ripple, so we get some output
- 
 
 1189 
			requestRipple("p1.cr");
- 
 
 1190 
 
- 
 
 1191 
			rippleEngine.planRelease(false);
- 
 
 1192 
		}
- 
 
 1193 
		catch (Exception e)
- 
 
 1194 
		{
- 
 
 1195 
		}
- 
 
 1196 
 
- 
 
 1197 
		checkBuildFile(tName);
- 
 
 1198 
	}
1214 
 
 1199 
 
1215 
}
 1200 
}