Subversion Repositories DevTools

Rev

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