Subversion Repositories DevTools

Rev

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