Subversion Repositories DevTools

Rev

Rev 7231 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
7079 dpurdie 1 
package com.erggroup.buildtool.utf;
2 
 
3 
 
4 
import java.sql.SQLException;
7282 dpurdie 5 
import java.util.ArrayList;
7079 dpurdie 6 
import java.util.Iterator;
7282 dpurdie 7 
import java.util.List;
7079 dpurdie 8 
 
7282 dpurdie 9 
import com.erggroup.buildtool.ripple.BuildExclusion;
7079 dpurdie 10 
import com.erggroup.buildtool.ripple.BuildFile;
11 
import com.erggroup.buildtool.ripple.BuildFile.BuildFileState;
12 
import com.erggroup.buildtool.ripple.BuildStandard;
13 
import com.erggroup.buildtool.ripple.ReleaseManager;
14 
import com.erggroup.buildtool.ripple.Package;
7186 dpurdie 15 
import com.erggroup.buildtool.ripple.PackageCollection;
7169 dpurdie 16 
import com.erggroup.buildtool.ripple.PlanControl;
7079 dpurdie 17 
import com.erggroup.buildtool.ripple.RippleEngine;
18 
import org.slf4j.Logger;
19 
import org.slf4j.LoggerFactory;
20 
import org.junit.AfterClass;
21 
import org.junit.BeforeClass;
22 
import org.junit.After;
23 
import org.junit.Before;
24 
import org.junit.Test;
25 
import org.junit.runner.JUnitCore;
26 
 
27 
import static org.junit.Assert.*;
28 
 
29 
/**
30 
 * container of Build Daemon test methods
31 
 */
32 
public class DaemonRippleTestCase
33 
{
7186 dpurdie 34 
	private static final Logger mLogger = LoggerFactory.getLogger(DaemonRippleTestCase.class);
35 
	myReleaseManager            releaseManager = null;
36 
	RippleEngine                rippleEngine   = null;
37 
	PackageCollection testPackageCollection         = new PackageCollection();
38 
	PackageCollection testPackageCollectionTest     = new PackageCollection();
39 
	PackageCollection testPackageCollectionWip      = new PackageCollection();
40 
	PackageCollection testPackageCollectionRipple   = new PackageCollection();
7282 dpurdie 41 
	ArrayList<BuildExclusion> mBuildExclusionCollection = new ArrayList<BuildExclusion>();
42 
 
7186 dpurdie 43 
	/**
44 
	 * Init the package set
45 
	 */
46 
	public void initTestPackages(String setName, int basePvid)
47 
	{
7079 dpurdie 48 
 
7186 dpurdie 49 
		/*    A basic set of packages
50 
		 *    All buildable
51 
		 */
52 
		Package  p1 = createPackage(basePvid + 1, setName + "1");
53 
		Package  p2 = createPackage(basePvid + 2, setName + "2");
54 
		Package  p3 = createPackage(basePvid + 3, setName + "3");
55 
		Package  p4 = createPackage(basePvid + 4, setName + "4");
56 
		Package  p5 = createPackage(basePvid + 5, setName + "5");
57 
		Package  p6 = createPackage(basePvid + 6, setName + "6");
58 
		Package  p7 = createPackage(basePvid + 7, setName + "7");
7079 dpurdie 59 
 
7186 dpurdie 60 
		testPackageCollection.add(p1);
61 
		testPackageCollection.add(p2);
62 
		testPackageCollection.add(p3);
63 
		testPackageCollection.add(p4);
64 
		testPackageCollection.add(p5);
65 
		testPackageCollection.add(p6);
66 
		testPackageCollection.add(p7);
7079 dpurdie 67 
 
7186 dpurdie 68 
		p2.addDependency(p1);
69 
		p3.addDependency(p1);
70 
		p4.addDependency(p2).addDependency(p3);
71 
		p5.addDependency(p2).addDependency(p4);
72 
		p6.addDependency(p3).addDependency(p4);
73 
		p7.addDependency(p5).addDependency(p6);
7079 dpurdie 74 
 
7186 dpurdie 75 
	}
7079 dpurdie 76 
 
7231 dpurdie 77 
	/** Locate a package by its alias
78 
	 *
79 
	 * @param alias    Alias to locate
80 
	 * @return         The package. May be null if not found
81 
	 */
82 
	private Package getPackage(String alias)
83 
	{
84 
	    return testPackageCollection.contains(alias);
85 
	}
86 
 
7186 dpurdie 87 
	/** Create a WIP for a package in the Release
88 
	 * This will mark it as directlyPlanned
89 
	 * @param newPvId
90 
	 * @param alias
91 
	 */
92 
	private Package createWip(int newPvId, String alias) {
7079 dpurdie 93 
 
7186 dpurdie 94 
		Package wip = testPackageCollection.contains(alias);
95 
		if (wip == null)
96 
		{
97 
			wip = ReleaseManager.NULL_PACKAGE;
98 
		}
99 
		else
100 
		{
101 
			wip = new Package(newPvId, wip);
102 
			wip.mDirectlyPlanned = true;
103 
			testPackageCollectionWip.add(wip);
104 
		}
7079 dpurdie 105 
 
7186 dpurdie 106 
		return wip;
107 
	}
7079 dpurdie 108 
 
7186 dpurdie 109 
	/** Create a TEST for a package in the Release
110 
	 * This will mark it as test package
111 
	 * @param newPvId <0 - use PVID of the base package
112 
	 * @param alias
113 
	 */
114 
	private Package createTest(int newPvId, String alias) {
7079 dpurdie 115 
 
7186 dpurdie 116 
		Package wip = testPackageCollection.contains(alias);
117 
		if (wip == null)
118 
		{
119 
			wip = ReleaseManager.NULL_PACKAGE;
120 
		}
121 
		else
122 
		{
123 
			if (newPvId < 0 )
124 
				newPvId = wip.mId;
125 
			wip = new Package(newPvId, wip);
126 
			wip.mTestBuildInstruction = 1;
127 
			testPackageCollectionTest.add(wip);
128 
		}
7079 dpurdie 129 
 
7186 dpurdie 130 
		return wip;
131 
	}
7079 dpurdie 132 
 
7186 dpurdie 133 
	/** Create a RippleRequest for a package in the Release
134 
	 * This will mark it as ripple request
135 
	 * @param alias
136 
	 */
137 
	private Package requestRipple(String alias) {
7079 dpurdie 138 
 
7186 dpurdie 139 
		Package wip = testPackageCollection.contains(alias);
140 
		if (wip == null)
141 
		{
142 
			wip = ReleaseManager.NULL_PACKAGE;
143 
		}
144 
		else
145 
		{
146 
			wip = new Package(wip.mId, wip);
147 
			wip.mForcedRippleInstruction = 1;
148 
			testPackageCollectionRipple.add(wip);
149 
		}
7079 dpurdie 150 
 
7186 dpurdie 151 
		return wip;
152 
	}
7079 dpurdie 153 
 
7186 dpurdie 154 
	/** Create a basic package
155 
	 *
156 
	 */
157 
	private Package createPackage(int idx, String pName) {
158 
		Package  p = new Package(idx, idx * 100, pName, "1.0.0000", ".cr", pName + ".cr" , "CC::/vob/"+pName+".WIP", 'b', 'P');
159 
		BuildStandard bs = new BuildStandard(rippleEngine, "Linux", "Java 1.6");
160 
		p.mBuildStandardCollection.add(bs);
161 
		p.mBuildTime = 100;
162 
		return p;
163 
	}
7079 dpurdie 164 
 
7186 dpurdie 165 
	/** Update build time for a package
166 
	 *
167 
	 *  @param alias
168 
	 *  @param buildTime - Set a new build time
169 
	 */
170 
	private Package setBuildTime(String alias, int buildTime) {
7079 dpurdie 171 
 
7186 dpurdie 172 
		Package wip = ReleaseManager.NULL_PACKAGE;
173 
 
174 
		for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
175 
		{
176 
			Package p = it.next();
177 
 
178 
			if ( p.mAlias.compareTo( alias ) == 0 )
179 
			{
180 
				p.mBuildTime = buildTime;
181 
				break;
182 
			}
183 
		}
184 
		return wip;
185 
	}
186 
 
187 
	/** Setup a package so that it will be detected as being rippled
188 
	 *      Change its pvid so that consumers will see that they need to be rippled
189 
	 */
190 
	private Package ripplePackage(String alias) {
191 
 
192 
		Package wip = ReleaseManager.NULL_PACKAGE;
193 
 
194 
		for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
195 
		{
196 
			Package p = it.next();
197 
 
198 
			if ( p.mAlias.compareTo( alias ) == 0 )
199 
			{
200 
				p.mId += 10000;
201 
				break;
202 
			}
203 
		}
204 
		return wip;
205 
	}
206 
 
7282 dpurdie 207 
	/** Create a buildExclusion and add to the list for Release Manager
208 
	 *
209 
	 *    @param  identifier - pvid of the package being excluded
210 
	 *    @param  rootIdentifier  - pvid of the root package causing the exclusion. May be -1
211 
	 *    @param  rootCause - Short (< 50 Char) string explaining the cause
212 
	 *    @param  testBuildInstruction - Indicates a text build instruction
213 
	 *    @return The entry that was created
214 
	 */
215 
	private BuildExclusion createBuildExclusion (int identifier, int rootIdentifier, String rootCause, int testBuildInstruction )
216 
	{
217 
	    BuildExclusion be = new BuildExclusion(identifier, rootIdentifier, rootCause, testBuildInstruction);
218 
	    mBuildExclusionCollection.add(be);
219 
	    return be;
220 
	}
7186 dpurdie 221 
 
222 
 
223 
	/** Subclass and override key methods so that the test can control
224 
	 *  the data being used
225 
	 */
226 
	public class myReleaseManager extends ReleaseManagerUtf
7079 dpurdie 227 
	{
7186 dpurdie 228 
		public myReleaseManager(final String connectionString, final String username, final String password)
7079 dpurdie 229 
		{
7186 dpurdie 230 
			super(connectionString, username, password);
231 
			mLogger.error("Test {}", connectionString);
7079 dpurdie 232 
		}
233 
 
234 
		public myReleaseManager()
235 
		{
236 
			super();
237 
		}
7186 dpurdie 238 
 
7079 dpurdie 239 
		@Override
7186 dpurdie 240 
		public void queryPackageVersions(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
7079 dpurdie 241 
		{
7186 dpurdie 242 
 
243 
			//    Filter for the packages that are in the release
244 
			for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
245 
			{
246 
				Package p = it.next();
247 
				if (!p.mDirectlyPlanned && p.mTestBuildInstruction == 0 && p.mForcedRippleInstruction == 0)
248 
				{
249 
					p.mIsNotReleased = false;
250 
					packageCollection.add(p);
251 
				}
252 
			}
7079 dpurdie 253 
		}
7186 dpurdie 254 
 
7079 dpurdie 255 
		@Override
7186 dpurdie 256 
		public void queryWips(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
257 
		{
258 
			//    Filter for the packages that are WIPs
259 
			for (Iterator<Package> it = testPackageCollectionWip.iterator(); it.hasNext(); )
260 
			{
261 
				Package p = it.next();
262 
				p.mIsNotReleased = true;
263 
				p.mDirectlyPlanned = true;
264 
				p.mBuildReason = BuildReason.NewVersion;
265 
				packageCollection.add(p);
266 
			}
7079 dpurdie 267 
 
7186 dpurdie 268 
		}
269 
 
7079 dpurdie 270 
		@Override
7186 dpurdie 271 
		public void queryTest(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
272 
		{
273 
			//    Filter for the packages that are TEST builds
274 
			for (Iterator<Package> it = testPackageCollectionTest.iterator(); it.hasNext(); )
275 
			{
276 
				Package p = it.next();
277 
				p.mIsNotReleased = true;
278 
				p.mDirectlyPlanned = false;
279 
				p.mBuildReason = BuildReason.Test;
280 
				packageCollection.add(p);
281 
			}
282 
		}
283 
 
7079 dpurdie 284 
		@Override
7186 dpurdie 285 
		public void queryRipples(RippleEngine rippleEngine, PackageCollection packageCollection, int baseline) throws SQLException, Exception
286 
		{
287 
			//    Filter for the packages that are forced Ripples
288 
			for (Iterator<Package> it = testPackageCollectionRipple.iterator(); it.hasNext(); )
289 
			{
290 
				Package p = it.next();
291 
				p.mIsNotReleased = true;
292 
				p.mDirectlyPlanned = false;
293 
				p.mBuildReason = BuildReason.Forced;
294 
				if ( p.mBuildTime == 100)
295 
					p.mBuildTime = 3;
296 
				packageCollection.add(p);
297 
			}
298 
		}
299 
 
300 
		@Override
301 
		public void queryPlanControl(int mRtagId, PlanControl mPlanControl) throws Exception
302 
		{
303 
			mPlanControl.setThreshold(20);
304 
		}
7282 dpurdie 305 
 
306 
	    @Override
307 
	    public void queryBuildExclusions(List<BuildExclusion> buildExclusionCollection, int baseline) throws SQLException, Exception
308 
	    {
309 
	        buildExclusionCollection.addAll(mBuildExclusionCollection);
310 
	    }
7186 dpurdie 311 
 
7079 dpurdie 312 
	}
313 
 
314 
 
7186 dpurdie 315 
	public DaemonRippleTestCase()
316 
	{
317 
		mLogger.debug("DaemonBuildTestCase2");
318 
	}
7079 dpurdie 319 
 
7186 dpurdie 320 
	/**
321 
	 * Test Case main line
322 
	 */
323 
	public static void main(String[] args)
324 
	{
325 
		mLogger.debug("main");
326 
		JUnitCore.main("com.erggroup.buildtool.utf.DaemonBuildTestCase2");
327 
	}
7079 dpurdie 328 
 
7186 dpurdie 329 
	/**
330 
	 * set up performed prior to any test method
331 
	 */
332 
	@BeforeClass
333 
	public static void TestCaseSetUp()
334 
	{
335 
		mLogger.debug("TestCaseSetUp");
336 
	}
7079 dpurdie 337 
 
7186 dpurdie 338 
	/**
339 
	 * tear down performed after test methods
340 
	 */
341 
	@AfterClass
342 
	public static void TestCaseTearDown()
343 
	{
344 
		mLogger.debug("TestCaseTearDown");
345 
	}
7079 dpurdie 346 
 
7186 dpurdie 347 
	/**
348 
	 * set up performed prior to each test method
349 
	 */
350 
	@Before
351 
	public void TestSetUp()
352 
	{
353 
		mLogger.debug("TestSetUp");
354 
		System.setProperty("vix.utf.name", "DaemonBuildTestCase2");
355 
		Package.mGenericMachtype = "win32";
356 
		Package.mGbeDpkg = ".";
357 
	}
7079 dpurdie 358 
 
7186 dpurdie 359 
	/**
360 
	 * tear down performed after each test method
361 
	 */
362 
	@After
363 
	public void TestTearDown()
364 
	{
365 
		mLogger.debug("TestTearDown");
366 
	}
7079 dpurdie 367 
 
7186 dpurdie 368 
	/** Check the build file contents
369 
	 *  @param expectedName - Name of the expected output file
370 
	 */
371 
	private void checkBuildFile(String expectedName) {
372 
		boolean rv;
373 
		BuildFile buildFile;
7079 dpurdie 374 
 
7186 dpurdie 375 
		buildFile = rippleEngine.getFirstBuildFileContent();
376 
		assertTrue(buildFile != null);
377 
		assertTrue(buildFile.state != BuildFileState.Dummy);
378 
		assertTrue(buildFile.state != BuildFileState.Empty);
7079 dpurdie 379 
 
7186 dpurdie 380 
		rv = Utilities.checkBuildfile(buildFile.content, expectedName);
381 
		assertTrue(rv);
382 
	}
7079 dpurdie 383 
 
7186 dpurdie 384 
	/** Check the build file contents
385 
	 *  @param expectedName - Name of the expected output file
386 
	 */
387 
	private void checkBuildFileDummy(String expectedName) {
388 
		boolean rv;
389 
		BuildFile buildFile;
7079 dpurdie 390 
 
7186 dpurdie 391 
		buildFile = rippleEngine.getFirstBuildFileContent();
392 
		assertTrue(buildFile != null);
393 
		assertTrue(buildFile.state == BuildFileState.Dummy);
394 
		assertTrue(buildFile.state != BuildFileState.Empty);
7079 dpurdie 395 
 
7186 dpurdie 396 
		rv = Utilities.checkBuildfile(buildFile.content, expectedName);
397 
		assertTrue(rv);
398 
	}
7079 dpurdie 399 
 
7186 dpurdie 400 
	/**
401 
	 *  Create a mesh of packages
402 
	 *  Ripple the one at the bottom
403 
	 */
404 
	@Test
405 
	public void RippleTest_1()
406 
	{
407 
		String tName = "ripple1";
408 
		mLogger.debug("RippleTest {}", tName);
409 
		System.out.println("RippleTest " + tName);
410 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
411 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
7079 dpurdie 412 
 
7186 dpurdie 413 
		try
414 
		{
415 
			rippleEngine.collectMetaData();
7099 dpurdie 416 
 
7186 dpurdie 417 
			//  Generate basic test set and then tweak for this test
418 
			initTestPackages("p", 0);
7079 dpurdie 419 
 
7186 dpurdie 420 
			createWip(2000, "p1.cr");
421 
			rippleEngine.planRelease(false);
422 
		}
423 
		catch (Exception e)
424 
		{
425 
		}
7079 dpurdie 426 
 
7186 dpurdie 427 
		checkBuildFile(tName);
7079 dpurdie 428 
 
7186 dpurdie 429 
	}
7079 dpurdie 430 
 
7186 dpurdie 431 
	/**
432 
	 *  Create a mesh of packages
433 
	 *  Ripple the one not at the bottom
434 
	 */
435 
	@Test
436 
	public void RippleTest_2()
437 
	{
438 
		String tName = "ripple2";
439 
		mLogger.debug("RippleTest {}", tName);
440 
		System.out.println("RippleTest " + tName);
441 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
442 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
7079 dpurdie 443 
 
7186 dpurdie 444 
		try
445 
		{
446 
			rippleEngine.collectMetaData();
7079 dpurdie 447 
 
7186 dpurdie 448 
			//  Generate basic test set and then tweak for this test
449 
			initTestPackages("p", 0);
7079 dpurdie 450 
 
7186 dpurdie 451 
			createWip(2000, "p2.cr");
452 
			rippleEngine.planRelease(false);
453 
		}
454 
		catch (Exception e)
455 
		{
456 
		}
7079 dpurdie 457 
 
7186 dpurdie 458 
		checkBuildFile(tName);
459 
	}
7099 dpurdie 460 
 
461 
 
462 
 
7186 dpurdie 463 
	/**
464 
	 *  Create a mesh of packages
465 
	 *  Create a package that will feed into the mesh
466 
	 *  Mark bottom of the mesh as being rippled
467 
	 *  Mark create a WIP on the package feeding the mesh such that the additional time < 20%
468 
	 *
469 
	 */
470 
	@Test
471 
	public void RippleTest_3()
472 
	{
473 
		String tName = "ripple3";
474 
		mLogger.debug("RippleTest {}", tName);
475 
		System.out.println("RippleTest " + tName);
476 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
477 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
7079 dpurdie 478 
 
7186 dpurdie 479 
		try
480 
		{
481 
			rippleEngine.collectMetaData();
7099 dpurdie 482 
 
7186 dpurdie 483 
			//  Generate basic test set and then tweak for this test
484 
			initTestPackages("p", 0);
7099 dpurdie 485 
 
7186 dpurdie 486 
			Package p1 = ripplePackage("p1.cr");
7099 dpurdie 487 
 
7186 dpurdie 488 
			Package  p0 = createPackage(20, "p0");
489 
			testPackageCollection.add(p0);
490 
			setBuildTime("p0.cr", 10);
491 
			p1.addDependency(p0);
492 
			createWip(21, "p0.cr");
7079 dpurdie 493 
 
7186 dpurdie 494 
			rippleEngine.planRelease(false);
495 
		}
496 
		catch (Exception e)
497 
		{
498 
		}
7079 dpurdie 499 
 
7186 dpurdie 500 
		checkBuildFile(tName);
501 
	}
7079 dpurdie 502 
 
7186 dpurdie 503 
	/**
504 
	 *  Create a mesh of packages
505 
	 *  Create a package that will feed into the mesh
506 
	 *  Mark bottom of the mesh as being rippled
507 
	 *  Mark create a WIP on the package feeding the mesh such that the additional time > 20%
508 
	 *
509 
	 */
510 
	@Test
511 
	public void RippleTest_4()
512 
	{
513 
		String tName = "ripple4";
514 
		mLogger.debug("RippleTest {}", tName);
515 
		System.out.println("RippleTest " + tName);
516 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
517 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
7079 dpurdie 518 
 
7186 dpurdie 519 
		try
520 
		{
521 
			rippleEngine.collectMetaData();
7079 dpurdie 522 
 
7186 dpurdie 523 
			//  Generate basic test set and then tweak for this test
524 
			initTestPackages("p", 0);
7079 dpurdie 525 
 
7186 dpurdie 526 
			Package p1 = ripplePackage("p1.cr");
7079 dpurdie 527 
 
7186 dpurdie 528 
			Package  p0 = createPackage(20, "p0");
529 
			testPackageCollection.add(p0);
530 
			setBuildTime("p0.cr", 200);
531 
			p1.addDependency(p0);
532 
			createWip(21, "p0.cr");
7079 dpurdie 533 
 
7186 dpurdie 534 
			rippleEngine.planRelease(false);
535 
		}
536 
		catch (Exception e)
537 
		{
538 
		}
7079 dpurdie 539 
 
7186 dpurdie 540 
		checkBuildFile(tName);
541 
	}
7079 dpurdie 542 
 
7186 dpurdie 543 
	/**
544 
	 *  Create a mesh of packages
545 
	 *  Create a package that will feed into the mesh
546 
	 *  Mark bottom of the mesh as being rippled
547 
	 *  Mark RippleRequest on the package feeding the mesh such that the additional time > 20%
548 
	 *
549 
	 */
550 
	@Test
551 
	public void RippleTest_4a()
552 
	{
553 
		String tName = "ripple4a";
554 
		mLogger.debug("RippleTest {}", tName);
555 
		System.out.println("RippleTest " + tName);
556 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
557 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
7079 dpurdie 558 
 
7186 dpurdie 559 
		try
560 
		{
561 
			rippleEngine.collectMetaData();
7099 dpurdie 562 
 
7186 dpurdie 563 
			//  Generate basic test set and then tweak for this test
564 
			initTestPackages("p", 0);
7099 dpurdie 565 
 
7186 dpurdie 566 
			Package p1 = ripplePackage("p1.cr");
7079 dpurdie 567 
 
7186 dpurdie 568 
			Package  p0 = createPackage(20, "p0");
569 
			testPackageCollection.add(p0);
570 
			setBuildTime("p0.cr", 200);
571 
			p1.addDependency(p0);
572 
			requestRipple("p0.cr");
573 
 
574 
			rippleEngine.planRelease(false);
575 
		}
576 
		catch (Exception e)
577 
		{
578 
		}
579 
 
580 
		checkBuildFile(tName);
581 
	}
582 
 
583 
 
584 
	/**
585 
	 *  Create a mesh of packages
586 
	 *      Create a test package
587 
	 *      Create a WIP
588 
	 *      Test should be built first
589 
	 */
590 
	@Test
591 
	public void RippleTest_5()
592 
	{
593 
		String tName = "ripple5";
594 
		mLogger.debug("RippleTest {}", tName);
595 
		System.out.println("RippleTest " + tName);
596 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
597 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
598 
 
599 
		try
600 
		{
601 
			rippleEngine.collectMetaData();
602 
 
603 
			//  Generate basic test set and then tweak for this test
604 
			initTestPackages("p", 0);
605 
 
606 
			createWip (2000, "p1.cr");
607 
			createTest(3333, "p5.cr");
608 
			createTest(-1  , "p4.cr");
609 
			rippleEngine.planRelease(false);
610 
		}
611 
		catch (Exception e)
612 
		{
613 
		}
614 
 
615 
		checkBuildFile(tName);
616 
	}
617 
 
618 
	/**
619 
	 *  Create a mesh of packages
620 
	 *  Request a ripple (daemon Instruction)
621 
	 */
622 
	@Test
623 
	public void RippleTest_6()
624 
	{
625 
		String tName = "ripple6";
626 
		mLogger.debug("RippleTest {}", tName);
627 
		System.out.println("RippleTest " + tName);
628 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
629 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
630 
 
631 
		try
632 
		{
633 
			rippleEngine.collectMetaData();
634 
 
635 
			//  Generate basic test set and then tweak for this test
636 
			initTestPackages("p", 0);
637 
 
638 
			requestRipple("p5.cr");
639 
			rippleEngine.planRelease(false);
640 
		}
641 
		catch (Exception e)
642 
		{
643 
		}
644 
 
645 
		checkBuildFile(tName);
646 
	}
647 
 
648 
	/**
649 
	 * Create a mesh of packages
650 
	 * Create a circular dependency
651 
	 * Create a WIP to 'fix' the circular dependency
652 
	 */
653 
	@Test
654 
	public void RippleTest_7()
655 
	{
656 
		String tName = "ripple7";
657 
		mLogger.debug("RippleTest {}", tName);
658 
		System.out.println("RippleTest " + tName);
659 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
660 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
661 
 
662 
		try
663 
		{
664 
			rippleEngine.collectMetaData();
665 
 
666 
			//  Generate basic test set and then tweak for this test
667 
			/*    A basic set of packages
668 
			 */
669 
			Package  p1 = createPackage(1, "p1");
670 
			Package  p2 = createPackage(2, "p2");
671 
			Package  p3 = createPackage(3, "p3");
672 
			Package  p4 = createPackage(4, "p4");
673 
 
674 
			testPackageCollection.add(p1);
675 
			testPackageCollection.add(p2);
676 
			testPackageCollection.add(p3);
677 
			testPackageCollection.add(p4);
678 
 
679 
			// Create circular dependency
680 
			p2.addDependency(p1);
681 
			p3.addDependency(p2);
682 
			p4.addDependency(p3);
683 
			p1.addDependency(p4);
684 
 
685 
 
686 
			Package  p1fixed = createWip(4000, "p1.cr");
687 
			p1fixed.resetDependencies();
688 
 
689 
			rippleEngine.planRelease(false);
690 
		}
691 
		catch (Exception e)
692 
		{
693 
			mLogger.error("Exception in UTF: {}", e.getMessage());
694 
		}
695 
 
696 
		checkBuildFile(tName);
697 
	}
698 
 
699 
	/**
700 
	 * Create a mesh of packages
701 
	 * Create a dependencies
702 
	 * Create a WIP to 'create' a circular dependency
703 
	 *
704 
	 * Should detect that added package will create issue
705 
	 *
706 
	 */
707 
	@Test
708 
	public void RippleTest_8()
709 
	{
710 
		String tName = "ripple8";
711 
		mLogger.debug("RippleTest {}", tName);
712 
		System.out.println("RippleTest " + tName);
713 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
714 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
715 
 
716 
		try
717 
		{
718 
			rippleEngine.collectMetaData();
719 
 
720 
			//  Generate basic test set and then tweak for this test
721 
			Package  p1 = createPackage(1, "p1");
722 
			Package  p2 = createPackage(2, "p2");
723 
			Package  p3 = createPackage(3, "p3");
724 
			Package  p4 = createPackage(4, "p4");
725 
 
726 
			testPackageCollection.add(p1);
727 
			testPackageCollection.add(p2);
728 
			testPackageCollection.add(p3);
729 
			testPackageCollection.add(p4);
730 
 
731 
			// Create dependency
732 
			p2.addDependency(p1);
733 
			p3.addDependency(p2);
734 
			p4.addDependency(p3);
735 
 
736 
			Package  p1Broken = createWip(4000, "p1.cr");
737 
			p1Broken.resetDependencies().addDependency(p4);
738 
 
739 
			// Create a ripple, so we get some output
740 
			Package  p5 = createPackage(5, "p5");
741 
			testPackageCollection.add(p5);
742 
			requestRipple("p5.cr");
743 
 
744 
			rippleEngine.planRelease(false);
745 
		}
746 
		catch (Exception e)
747 
		{
748 
		}
749 
 
750 
		checkBuildFile(tName);
751 
	}
752 
 
753 
	/**
754 
	 * Create a WIP that will fail applyPV
755 
	 *      Expect it to be rejected
756 
	 *      Expect an email
757 
	 */
758 
	@Test
759 
	public void RippleTest_9()
760 
	{
761 
		String tName = "ripple9";
762 
		mLogger.debug("RippleTest {}", tName);
763 
		System.out.println("RippleTest " + tName);
764 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
765 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
766 
 
767 
		try
768 
		{
769 
			rippleEngine.collectMetaData();
770 
 
771 
			//  Generate basic test set and then tweak for this test
772 
			/*    A basic set of packages
773 
			 */
774 
			Package  p1 = createPackage(1, "p1");
775 
			Package  p2 = createPackage(2, "p2");
776 
			Package  p3 = createPackage(3, "p3");
777 
			Package  p4 = createPackage(4, "p4");
778 
 
779 
			testPackageCollection.add(p1);
780 
			testPackageCollection.add(p2);
781 
			testPackageCollection.add(p3);
782 
			testPackageCollection.add(p4);
783 
 
784 
			p2.addDependency(p1);
785 
 
786 
			Package  p1Broken = createWip(4000, "p1.cr");
787 
			p1Broken.mVersion = "BadVersion";
788 
 
789 
			rippleEngine.planRelease(false);
790 
		}
791 
		catch (Exception e)
792 
		{
793 
		}
794 
 
795 
		checkBuildFileDummy(tName);
796 
	}
797 
 
798 
	/**
799 
	 * Create a few WIP that will fail applyPV and one that will succeed
800 
	 *      Expect it to be rejected
801 
	 */
802 
	@Test
803 
	public void RippleTest_9a()
804 
	{
805 
		String tName = "ripple9a";
806 
		mLogger.debug("RippleTest {}", tName);
807 
		System.out.println("RippleTest " + tName);
808 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
809 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
810 
 
811 
		try
812 
		{
813 
			rippleEngine.collectMetaData();
814 
 
815 
			//  Generate basic test set and then tweak for this test
816 
			/*    A basic set of packages
817 
			 */
818 
			Package  p1 = createPackage(1, "p1");
819 
			Package  p2 = createPackage(2, "p2");
820 
			Package  p3 = createPackage(3, "p3");
821 
			Package  p4 = createPackage(4, "p4");
822 
			Package  p5 = createPackage(5, "p5");
823 
 
824 
			testPackageCollection.add(p1);
825 
			testPackageCollection.add(p2);
826 
			testPackageCollection.add(p3);
827 
			testPackageCollection.add(p4);
828 
			testPackageCollection.add(p5);
829 
 
830 
			p5.addDependency(p2);
831 
 
832 
			Package  p1Broken = createWip(4001, "p1.cr");
833 
			p1Broken.mVersion = "BadVersion";
834 
 
835 
			Package  p2Broken = createWip(4002, "p2.cr");
836 
			p2Broken.mVersion = "BadVersion";
837 
 
838 
			Package  p3Broken = createWip(4003, "p3.cr");
839 
			p3Broken.mVersion = "BadVersion";
840 
 
841 
			createWip(4004, "p4.cr");
842 
 
843 
			rippleEngine.planRelease(false);
844 
		}
845 
		catch (Exception e)
846 
		{
847 
		}
848 
 
849 
		checkBuildFile(tName);
850 
	}
851 
 
852 
	/**
853 
	 * Create a few WIP that will fail applyPV and one that will succeed
854 
	 *      Expect it to be rejected
855 
	 */
856 
	@Test
857 
	public void RippleTest_9b()
858 
	{
859 
		String tName = "ripple9b";
860 
		mLogger.debug("RippleTest {}", tName);
861 
		System.out.println("RippleTest " + tName);
862 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
863 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
864 
 
865 
		try
866 
		{
867 
			rippleEngine.collectMetaData();
868 
 
869 
			//  Generate basic test set and then tweak for this test
870 
			/*    A basic set of packages
871 
			 */
872 
			Package  p1 = createPackage(1, "p1");
873 
			Package  p2 = createPackage(2, "p2");
874 
			Package  p3 = createPackage(3, "p3");
875 
			Package  p4 = createPackage(4, "p4");
876 
			Package  p5 = createPackage(5, "p5");
877 
 
878 
			testPackageCollection.add(p1);
879 
			testPackageCollection.add(p2);
880 
			testPackageCollection.add(p3);
881 
			testPackageCollection.add(p4);
882 
			testPackageCollection.add(p5);
883 
 
884 
			p2.addDependency(p1);
885 
			p3.addDependency(p2);
886 
			p4.addDependency(p3);
887 
 
888 
			p2.mVersion = "BadVersion";
889 
			ripplePackage("p1.cr");
890 
			requestRipple("p5.cr").mBuildTime = 1000;
891 
 
892 
			rippleEngine.planRelease(false);
893 
		}
894 
		catch (Exception e)
895 
		{
896 
		}
897 
 
898 
		checkBuildFile(tName);
899 
	}
900 
 
901 
 
902 
	/**
903 
	 *  Create a mesh of packages
904 
	 *  Mark bottom as being rippled
905 
	 *
906 
	 *  Expect a single plan with the next two two candidate packages
907 
	 */
908 
	@Test
909 
	public void RippleTest_10()
910 
	{
911 
		String tName = "ripple10";
912 
		mLogger.debug("RippleTest {}", tName);
913 
		System.out.println("RippleTest " + tName);
914 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
915 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
916 
 
917 
		try
918 
		{
919 
			rippleEngine.collectMetaData();
920 
 
921 
			//  Generate basic test set and then tweak for this test
922 
			initTestPackages("p", 0);
923 
 
924 
			ripplePackage("p1.cr");
925 
			rippleEngine.planRelease(false);
926 
		}
927 
		catch (Exception e)
928 
		{
929 
		}
930 
 
931 
		checkBuildFile(tName);
932 
	}
933 
 
934 
	/**
935 
	 *  Create two meshes of packages
936 
	 *  Create a ripple in both
937 
	 */
938 
	@Test
939 
	public void RippleTest_11()
940 
	{
941 
		String tName = "ripple11";
942 
		mLogger.debug("RippleTest {}", tName);
943 
		System.out.println("RippleTest " + tName);
944 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
945 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
946 
 
947 
		try
948 
		{
949 
			rippleEngine.collectMetaData();
950 
 
951 
			//  Generate basic test set and then tweak for this test
952 
			initTestPackages("p", 0);
953 
			initTestPackages("z", 100);
954 
			setBuildTime("z4.cr", 200);
955 
 
956 
			createWip(2000, "p1.cr");
957 
			createWip(3000, "z1.cr");
958 
 
959 
			rippleEngine.planRelease(false);
960 
		}
961 
		catch (Exception e)
962 
		{
963 
		}
964 
 
965 
		checkBuildFile(tName);
966 
	}
967 
 
968 
	/**
969 
	 *  Create a simple dependency chain
970 
	 *  Mark one of the packages as an SDK
971 
	 *  Ensure that a ripple will not affect the SDK package
972 
	 *
973 
	 */
974 
	@Test
975 
	public void RippleTest_12()
976 
	{
977 
		String tName = "ripple12";
978 
		mLogger.debug("RippleTest {}", tName);
979 
		System.out.println("RippleTest " + tName);
980 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
981 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
982 
 
983 
		try
984 
		{
985 
			rippleEngine.collectMetaData();
986 
 
987 
			/*    A basic set of packages
988 
			 */
989 
			Package  p1 = createPackage(1, "p1");
990 
			Package  p2 = createPackage(2, "p2");
991 
			Package  p3 = createPackage(3, "p3");
992 
			Package  p4 = createPackage(4, "p4");
993 
			Package  p5 = createPackage(5, "p5");
994 
 
995 
			testPackageCollection.add(p1);
996 
			testPackageCollection.add(p2);
997 
			testPackageCollection.add(p3);
998 
			testPackageCollection.add(p4);
999 
			testPackageCollection.add(p5);
1000 
 
1001 
			p2.addDependency(p1);
1002 
			p3.addDependency(p1);
1003 
			p4.addDependency(p3).addDependency(p2);
1004 
			p5.addDependency(p3);
1005 
 
1006 
			// Mark SDK
1007 
			p3.mIsSdk = true;
1008 
 
1009 
			// Create a ripple, so we get some output
1010 
			requestRipple("p1.cr");
1011 
 
1012 
			rippleEngine.planRelease(false);
1013 
		}
1014 
		catch (Exception e)
1015 
		{
1016 
		}
1017 
 
1018 
		checkBuildFile(tName);
1019 
	}
1020 
 
1021 
	/**
1022 
	 *  Create a simple dependency chain
1023 
	 *  Mark one of the packages as having a rippleStop
1024 
	 *  Create a ripple
1025 
	 *
1026 
	 *  Ensure that a ripple will not propagate through the ripple stop
1027 
	 *
1028 
	 */
1029 
	@Test
1030 
	public void RippleTest_13()
1031 
	{
1032 
		String tName = "ripple13";
1033 
		mLogger.debug("RippleTest {}", tName);
1034 
		System.out.println("RippleTest " + tName);
1035 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
1036 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
1037 
 
1038 
		try
1039 
		{
1040 
			rippleEngine.collectMetaData();
1041 
 
1042 
			/*    A basic set of packages
1043 
			 */
1044 
			Package  p1 = createPackage(1, "p1");
1045 
			Package  p2 = createPackage(2, "p2");
1046 
			Package  p3 = createPackage(3, "p3");
1047 
			Package  p4 = createPackage(4, "p4");
1048 
			Package  p5 = createPackage(5, "p5");
1049 
 
1050 
			testPackageCollection.add(p1);
1051 
			testPackageCollection.add(p2);
1052 
			testPackageCollection.add(p3);
1053 
			testPackageCollection.add(p4);
1054 
			testPackageCollection.add(p5);
1055 
 
1056 
			p2.addDependency(p1);
1057 
			p3.addDependency(p1);
1058 
			p4.addDependency(p3).addDependency(p2);
1059 
			p5.addDependency(p3);
1060 
 
1061 
			// Mark SDK
1062 
			p3.mRippleStop = 's';
1063 
 
1064 
			// Create a ripple, so we get some output
1065 
			requestRipple("p1.cr");
1066 
 
1067 
			rippleEngine.planRelease(false);
1068 
		}
1069 
		catch (Exception e)
1070 
		{
1071 
		}
1072 
 
1073 
		checkBuildFile(tName);
1074 
	}
1075 
 
1076 
	/**
1077 
	 *  Create a simple dependency chain
1078 
	 *  Create a WIP that is not already in the release
1079 
	 *
1080 
	 *  Ensure the WIP is included into the build set
1081 
	 *
1082 
	 */
1083 
	@Test
1084 
	public void RippleTest_14()
1085 
	{
1086 
		String tName = "ripple14";
1087 
		mLogger.debug("RippleTest {}", tName);
1088 
		System.out.println("RippleTest " + tName);
1089 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
1090 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
1091 
 
1092 
		try
1093 
		{
1094 
			rippleEngine.collectMetaData();
1095 
 
1096 
			/*    A basic set of packages
1097 
			 */
1098 
			Package  p1 = createPackage(1, "p1");
1099 
			Package  p2 = createPackage(2, "p2");
1100 
			Package  p3 = createPackage(3, "p3");
1101 
 
1102 
			testPackageCollection.add(p1);
1103 
			testPackageCollection.add(p2);
1104 
			testPackageCollection.add(p3);
1105 
 
1106 
			p2.addDependency(p1);
1107 
			p3.addDependency(p2);
1108 
 
1109 
			// Mark as a WIP
1110 
			Package  p4 = createPackage(4, "p4");
1111 
			testPackageCollectionWip.add(p4);
1112 
			//p4.mDirectlyPlanned = true;
1113 
 
1114 
 
1115 
			rippleEngine.planRelease(false);
1116 
		}
1117 
		catch (Exception e)
1118 
		{
1119 
		}
1120 
 
1121 
		checkBuildFile(tName);
1122 
	}
1123 
 
1124 
	/**
1125 
	 *  Create a simple dependency chain
1126 
	 *  Create a package that will be excluded
1127 
	 *
1128 
	 *  Ensure the upstream packages show up in the excluded list
1129 
	 *
1130 
	 */
1131 
	@Test
1132 
	public void RippleTest_15()
1133 
	{
1134 
		String tName = "ripple15";
1135 
		mLogger.debug("RippleTest {}", tName);
1136 
		System.out.println("RippleTest " + tName);
1137 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
1138 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
1139 
 
1140 
		try
1141 
		{
1142 
			rippleEngine.collectMetaData();
1143 
 
1144 
			/*    A basic set of packages
1145 
			 */
1146 
			Package  p1 = createPackage(1, "p1");
1147 
			Package  p2 = createPackage(2, "p2");
1148 
			Package  p3 = createPackage(3, "p3");
1149 
			Package  p4 = createPackage(4, "p4");
1150 
			Package  p5 = createPackage(5, "p5");
1151 
			Package  p6 = createPackage(6, "p6");
1152 
 
1153 
			testPackageCollection.add(p1);
1154 
			testPackageCollection.add(p2);
1155 
			testPackageCollection.add(p3);
1156 
			testPackageCollection.add(p4);
1157 
			testPackageCollection.add(p5);
1158 
			testPackageCollection.add(p6);
1159 
 
1160 
			p2.addDependency(p1);
1161 
			p3.addDependency(p2);
1162 
			p4.addDependency(p2);
1163 
			p5.addDependency(p4);
1164 
 
1165 
			p2.mVersion = "BadVersion";
1166 
			ripplePackage("p1.cr");
1167 
 
1168 
			// Create a ripple, so we get some output
1169 
 
1170 
			//requestRipple("p6.cr");
1171 
 
1172 
			rippleEngine.planRelease(false);
1173 
		}
1174 
		catch (Exception e)
1175 
		{
1176 
		}
1177 
 
1178 
		checkBuildFileDummy(tName);
1179 
	}
1180 
 
1181 
	/**
1182 
	 *  Create a simple dependency chain
1183 
	 *
1184 
	 *  Ensure that the build level is correctly calculated
1185 
	 *  Should be able to build ALL the packages at the same level in any order
1186 
	 *
1187 
	 */
1188 
	@Test
1189 
	public void RippleTest_16()
1190 
	{
1191 
		String tName = "ripple16";
1192 
		mLogger.debug("RippleTest {}", tName);
1193 
		System.out.println("RippleTest " + tName);
1194 
		releaseManager = new myReleaseManager(tName, "not used", "not used");
1195 
		rippleEngine = new RippleEngine(releaseManager, 11111, true);
1196 
 
1197 
		try
1198 
		{
1199 
			rippleEngine.collectMetaData();
1200 
 
1201 
			/*    A basic set of packages
1202 
			 */
1203 
			Package  p1 = createPackage(1, "p1");
1204 
			Package  p2 = createPackage(2, "p2");
1205 
			Package  p3 = createPackage(3, "p3");
1206 
			Package  p4 = createPackage(4, "p4");
1207 
			Package  p5 = createPackage(5, "p5");
1208 
			Package  p6 = createPackage(6, "p6");
1209 
 
1210 
			testPackageCollection.add(p1);
1211 
			testPackageCollection.add(p2);
1212 
			testPackageCollection.add(p3);
1213 
			testPackageCollection.add(p4);
1214 
			testPackageCollection.add(p5);
1215 
			testPackageCollection.add(p6);
1216 
 
1217 
			p2.addDependency(p1);
1218 
			p3.addDependency(p1);
1219 
			p4.addDependency(p1);
1220 
			p5.addDependency(p2);
1221 
 
1222 
			// Create a ripple, so we get some output
1223 
			requestRipple("p1.cr");
1224 
 
1225 
			rippleEngine.planRelease(false);
1226 
		}
1227 
		catch (Exception e)
1228 
		{
1229 
		}
1230 
 
1231 
		checkBuildFile(tName);
1232 
	}
7201 dpurdie 1233 
 
7210 dpurdie 1234 
	/**
7201 dpurdie 1235 
     *  Create two sets of packages
1236 
     *  The first will be a WIP
1237 
     *
1238 
     *  The second will contain a Ripple and a WIP
1239 
     *
1240 
     *  Configure such that the a basic and a Full plan are calculated
1241 
     *
1242 
     *  Ensure that the Full plan does not include the WIP of that will have been processed by the basic plan
1243 
     */
1244 
    @Test
1245 
    public void RippleTest_17()
1246 
    {
1247 
        String tName = "ripple17";
1248 
        mLogger.debug("RippleTest {}", tName);
1249 
        System.out.println("RippleTest " + tName);
1250 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
1251 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
7186 dpurdie 1252 
 
7201 dpurdie 1253 
        try
1254 
        {
1255 
            rippleEngine.collectMetaData();
1256 
 
1257 
            /*    A basic set of packages
1258 
             */
1259 
            Package  p1 = createPackage(1, "p1");
1260 
            Package  p2 = createPackage(2, "p2");
1261 
            Package  p3 = createPackage(3, "p3");
1262 
            Package  p4 = createPackage(4, "p4");
1263 
            Package  p5 = createPackage(5, "p5");
1264 
            Package  p6 = createPackage(6, "p6");
1265 
 
1266 
            testPackageCollection.add(p1);
1267 
            testPackageCollection.add(p2);
1268 
            testPackageCollection.add(p3);
1269 
            testPackageCollection.add(p4);
1270 
            testPackageCollection.add(p5);
1271 
            testPackageCollection.add(p6);
1272 
 
1273 
            p2.addDependency(p1);
1274 
            p3.addDependency(p2);
1275 
            p4.addDependency(p3);
1276 
            p5.addDependency(p4);
1277 
            p6.addDependency(p5);
1278 
 
1279 
            ripplePackage("p1.cr");
1280 
            createWip(9999, "p3.cr");
1281 
 
1282 
            // A second set of packages
1283 
 
1284 
            Package  z1 = createPackage(11, "z1");
1285 
            Package  z2 = createPackage(12, "z2");
1286 
            Package  z3 = createPackage(13, "z3");
1287 
            Package  z4 = createPackage(14, "z4");
1288 
            Package  z5 = createPackage(15, "z5");
1289 
            Package  z6 = createPackage(16, "z6");
1290 
 
1291 
            testPackageCollection.add(z1);
1292 
            testPackageCollection.add(z2);
1293 
            testPackageCollection.add(z3);
1294 
            testPackageCollection.add(z4);
1295 
            testPackageCollection.add(z5);
1296 
            testPackageCollection.add(z6);
1297 
 
1298 
            z2.addDependency(z1);
1299 
            z3.addDependency(z2);
1300 
            z4.addDependency(z3);
1301 
            z5.addDependency(z4);
1302 
            z6.addDependency(z5);
1303 
 
1304 
            createWip(8888, "z1.cr");
1305 
 
1306 
            rippleEngine.planRelease(false);
1307 
        }
1308 
        catch (Exception e)
1309 
        {
1310 
        }
1311 
 
1312 
        checkBuildFile(tName);
7210 dpurdie 1313 
    }
1314 
 
1315 
    /**
1316 
     *  Create one sets of packages
1317 
     *  Configure such that a WIP and a natural ripple exist on the same package
1318 
     *
1319 
     *  Ensure that the WIP is processed
1320 
     */
1321 
    @Test
1322 
    public void RippleTest_18()
1323 
    {
1324 
        String tName = "ripple18";
1325 
        mLogger.debug("RippleTest {}", tName);
1326 
        System.out.println("RippleTest " + tName);
1327 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
1328 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
1329 
 
1330 
        try
1331 
        {
1332 
            rippleEngine.collectMetaData();
1333 
 
1334 
            /*    A basic set of packages
1335 
             */
1336 
            Package  p1 = createPackage(1, "p1");
1337 
            Package  p2 = createPackage(2, "p2");
1338 
            Package  p3 = createPackage(3, "p3");
1339 
            Package  p4 = createPackage(4, "p4");
1340 
            Package  p5 = createPackage(5, "p5");
1341 
            Package  p6 = createPackage(6, "p6");
1342 
 
1343 
            testPackageCollection.add(p1);
1344 
            testPackageCollection.add(p2);
1345 
            testPackageCollection.add(p3);
1346 
            testPackageCollection.add(p4);
1347 
            testPackageCollection.add(p5);
1348 
            testPackageCollection.add(p6);
1349 
 
1350 
            p2.addDependency(p1);
1351 
            p3.addDependency(p2);
1352 
            p4.addDependency(p3);
1353 
            p5.addDependency(p4);
1354 
            p6.addDependency(p5);
1355 
 
1356 
            ripplePackage("p1.cr");                 // Mark p1 as having been built. thus p2 will need to be rippled.
1357 
            createWip(9999, "p2.cr");               // Also have a WIP on p2
1358 
 
1359 
 
1360 
            rippleEngine.planRelease(false);
1361 
        }
1362 
        catch (Exception e)
1363 
        {
1364 
        }
1365 
 
1366 
        checkBuildFile(tName);
1367 
    }
1368 
 
1369 
    /**
1370 
     *  Create one sets of packages
1371 
     *  Configure with  WIP and a NaturalRipple such that we will have a basicPlan followed by a modified full plan
1372 
     *
1373 
     *  Ensure the the dependency version numbers are that of the WIP which will part of the follow-on plan
1374 
     */
1375 
    @Test
1376 
    public void RippleTest_19()
1377 
    {
1378 
        String tName = "ripple19";
1379 
        mLogger.debug("RippleTest {}", tName);
1380 
        System.out.println("RippleTest " + tName);
1381 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
1382 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
1383 
 
1384 
        try
1385 
        {
1386 
            rippleEngine.collectMetaData();
1387 
 
1388 
            /*    A basic set of packages
1389 
             */
1390 
            Package  p1 = createPackage(1, "p1");
1391 
            Package  p2 = createPackage(2, "p2");
1392 
            Package  p3 = createPackage(3, "p3");
1393 
            Package  p4 = createPackage(4, "p4");
1394 
            Package  p5 = createPackage(5, "p5");
1395 
            Package  p6 = createPackage(6, "p6");
1396 
 
1397 
            testPackageCollection.add(p1);
1398 
            testPackageCollection.add(p2);
1399 
            testPackageCollection.add(p3);
1400 
            testPackageCollection.add(p4);
1401 
            testPackageCollection.add(p5);
1402 
            testPackageCollection.add(p6);
1403 
 
1404 
            p2.addDependency(p1);
1405 
            p3.addDependency(p2);
1406 
            p4.addDependency(p3);
1407 
            p5.addDependency(p4);
1408 
            p6.addDependency(p5);
1409 
 
1410 
            ripplePackage("p2.cr");                             // Mark p2 as having been built. thus p3 will need to be rippled.
1411 
            Package pwip = createWip(9999, "p1.cr");            // Also have a WIP on p1
1412 
            pwip.mVersion = "22.22.22";
1413 
            pwip.mNextVersion = "33.33.33";
1414 
 
1415 
            rippleEngine.planRelease(false);
1416 
        }
1417 
        catch (Exception e)
1418 
        {
1419 
        }
1420 
 
1421 
        checkBuildFile(tName);
7231 dpurdie 1422 
    }
1423 
 
1424 
    /**
1425 
     *  Create a mesh of packages
1426 
     *  Mark one as having an advisory ripple
1427 
     *
1428 
     *  Ripple the one at the bottom
1429 
     *  Ensure the plan does not include those downstream of the advisory ripple
1430 
     *  Also don't expect the SDK or Pegged package to be built
1431 
     */
1432 
    @Test
1433 
    public void RippleTest_20()
1434 
    {
1435 
        String tName = "ripple20";
1436 
        mLogger.debug("RippleTest {}", tName);
1437 
        System.out.println("RippleTest " + tName);
1438 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
1439 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
7201 dpurdie 1440 
 
7231 dpurdie 1441 
        try
1442 
        {
1443 
            rippleEngine.collectMetaData();
1444 
 
1445 
            /*    A basic set of packages
1446 
             */
1447 
            Package  p1 = createPackage(1, "p1");
1448 
            Package  p2 = createPackage(2, "p2");
1449 
            Package  p3 = createPackage(3, "p3");
1450 
            Package  p4 = createPackage(4, "p4");
1451 
            Package  p5 = createPackage(5, "p5");
1452 
            Package  p6 = createPackage(6, "p6");
1453 
 
1454 
            Package  p31 = createPackage(7, "p31");
1455 
            Package  p32 = createPackage(8, "p32");
1456 
            Package  p33 = createPackage(9, "p33");
1457 
 
1458 
 
1459 
            testPackageCollection.add(p1);
1460 
            testPackageCollection.add(p2);
1461 
            testPackageCollection.add(p3);
1462 
            testPackageCollection.add(p4);
1463 
            testPackageCollection.add(p5);
1464 
            testPackageCollection.add(p6);
1465 
 
1466 
            testPackageCollection.add(p31);
1467 
            testPackageCollection.add(p32);
1468 
            testPackageCollection.add(p33);
1469 
 
1470 
            p2.addDependency(p1);
1471 
            p3.addDependency(p2);
1472 
            p4.addDependency(p3);
1473 
            p5.addDependency(p4);
1474 
            p6.addDependency(p5);
1475 
 
1476 
            p31.addDependency(p2);
1477 
            p32.addDependency(p2);
1478 
            p33.addDependency(p2);
1479 
 
1480 
            ripplePackage("p1.cr");                 // Mark p1 as having been built. thus p2 will need to be rippled.
1481 
            p3.mAdvisoryRipple = true;              // Expect ripples to stop here
1482 
            p32.mIsSdk = true;
1483 
            p33.mIsPegged = true;
1484 
 
1485 
            rippleEngine.planRelease(false);
1486 
        }
1487 
        catch (Exception e)
1488 
        {
1489 
        }
1490 
 
1491 
        checkBuildFile(tName);
1492 
 
1493 
    }
1494 
 
1495 
    /**
1496 
     *  Create a mesh of packages
1497 
     *  Ripple the one at the bottom - which is marked as an advisory Ripple
1498 
     *
1499 
     *  Expect on the rippled package to be built
1500 
     */
1501 
    @Test
1502 
    public void RippleTest_21()
1503 
    {
1504 
        String tName = "ripple21";
1505 
        mLogger.debug("RippleTest {}", tName);
1506 
        System.out.println("RippleTest " + tName);
1507 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
1508 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
1509 
 
1510 
        try
1511 
        {
1512 
            rippleEngine.collectMetaData();
1513 
 
1514 
            //  Generate basic test set and then tweak for this test
1515 
            initTestPackages("p", 0);
1516 
            Package p1 = getPackage ("p1.cr");
1517 
            p1.mAdvisoryRipple = true;
1518 
 
1519 
            createWip(2000, "p1.cr");
1520 
            rippleEngine.planRelease(false);
1521 
        }
1522 
        catch (Exception e)
1523 
        {
1524 
        }
1525 
 
1526 
        checkBuildFile(tName);
7282 dpurdie 1527 
    }
7231 dpurdie 1528 
 
7282 dpurdie 1529 
    /**
1530 
     *  Create a mesh of packages
1531 
     *  Mark bottom as being rippled - so that it will build
1532 
     *  Create a WIP for the package
1533 
     *  Create a Build Exclusion for the WIP - it failed to build
1534 
     *
1535 
     *  Expect nothing to build
1536 
     *
1537 
     */
1538 
    @Test
1539 
    public void RippleTest_22()
1540 
    {
1541 
        String tName = "ripple22";
1542 
        mLogger.debug("RippleTest {}", tName);
1543 
        System.out.println("RippleTest " + tName);
1544 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
1545 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
1546 
 
1547 
        try
1548 
        {
1549 
            rippleEngine.collectMetaData();
1550 
 
1551 
            //  Generate basic test set and then tweak for this test
1552 
            /*    A basic set of packages
1553 
             */
1554 
            Package  p1 = createPackage(1, "p1");
1555 
            Package  p2 = createPackage(2, "p2");
1556 
            Package  p3 = createPackage(3, "p3");
1557 
            Package  p4 = createPackage(4, "p4");
1558 
            Package  p5 = createPackage(5, "p5");
1559 
            Package  p6 = createPackage(6, "p6");
1560 
 
1561 
            testPackageCollection.add(p1);
1562 
            testPackageCollection.add(p2);
1563 
            testPackageCollection.add(p3);
1564 
            testPackageCollection.add(p4);
1565 
            testPackageCollection.add(p5);
1566 
            testPackageCollection.add(p6);
1567 
 
1568 
            p2.addDependency(p1);
1569 
            p3.addDependency(p2);
1570 
            p4.addDependency(p3);
1571 
            p5.addDependency(p4);
1572 
 
1573 
            ripplePackage("p1.cr");
1574 
            Package p2Wip = createWip(2000, "p2.cr");
1575 
            createBuildExclusion(p2Wip.mId, -1, null, 0);
1576 
 
1577 
            // Force some output
1578 
            requestRipple("p6.cr");
1579 
 
1580 
            rippleEngine.planRelease(false);
1581 
        }
1582 
        catch (Exception e)
1583 
        {
1584 
        }
1585 
 
1586 
        checkBuildFile(tName);
7231 dpurdie 1587 
    }
7079 dpurdie 1588 
}