001package org.apache.maven.lifecycle; 002 003/* 004 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license 005 * agreements. See the NOTICE file distributed with this work for additional information regarding 006 * copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance with the License. You may obtain a 008 * copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software distributed under the License 013 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 014 * or implied. See the License for the specific language governing permissions and limitations under 015 * the License. 016 */ 017 018import java.io.File; 019import java.util.ArrayList; 020import java.util.Arrays; 021import java.util.Collections; 022import java.util.List; 023 024import org.apache.maven.AbstractCoreMavenComponentTestCase; 025import org.apache.maven.exception.ExceptionHandler; 026import org.apache.maven.execution.MavenSession; 027import org.apache.maven.execution.MojoExecutionEvent; 028import org.apache.maven.execution.MojoExecutionListener; 029import org.apache.maven.execution.ProjectDependencyGraph; 030import org.apache.maven.execution.ProjectExecutionEvent; 031import org.apache.maven.execution.ProjectExecutionListener; 032import org.apache.maven.lifecycle.internal.DefaultLifecycleTaskSegmentCalculator; 033import org.apache.maven.lifecycle.internal.ExecutionPlanItem; 034import org.apache.maven.lifecycle.internal.LifecycleExecutionPlanCalculator; 035import org.apache.maven.lifecycle.internal.LifecycleTask; 036import org.apache.maven.lifecycle.internal.LifecycleTaskSegmentCalculator; 037import org.apache.maven.lifecycle.internal.MojoDescriptorCreator; 038import org.apache.maven.lifecycle.internal.TaskSegment; 039import org.apache.maven.model.Plugin; 040import org.apache.maven.plugin.MojoExecution; 041import org.apache.maven.plugin.MojoExecutionException; 042import org.apache.maven.plugin.MojoNotFoundException; 043import org.apache.maven.plugin.descriptor.MojoDescriptor; 044import org.apache.maven.project.MavenProject; 045import org.codehaus.plexus.component.annotations.Requirement; 046import org.codehaus.plexus.util.xml.Xpp3Dom; 047 048public class LifecycleExecutorTest 049 extends AbstractCoreMavenComponentTestCase 050{ 051 @Requirement 052 private DefaultLifecycleExecutor lifecycleExecutor; 053 054 @Requirement 055 private DefaultLifecycleTaskSegmentCalculator lifeCycleTaskSegmentCalculator; 056 057 @Requirement 058 private LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator; 059 060 @Requirement 061 private MojoDescriptorCreator mojoDescriptorCreator; 062 063 064 protected void setUp() 065 throws Exception 066 { 067 super.setUp(); 068 lifecycleExecutor = (DefaultLifecycleExecutor) lookup( LifecycleExecutor.class ); 069 lifeCycleTaskSegmentCalculator = 070 (DefaultLifecycleTaskSegmentCalculator) lookup( LifecycleTaskSegmentCalculator.class ); 071 lifeCycleExecutionPlanCalculator = lookup( LifecycleExecutionPlanCalculator.class ); 072 mojoDescriptorCreator = lookup( MojoDescriptorCreator.class ); 073 lookup( ExceptionHandler.class ); 074 } 075 076 @Override 077 protected void tearDown() 078 throws Exception 079 { 080 lifecycleExecutor = null; 081 super.tearDown(); 082 } 083 084 protected String getProjectsDirectory() 085 { 086 return "src/test/projects/lifecycle-executor"; 087 } 088 089 // ----------------------------------------------------------------------------------------------- 090 // Tests which exercise the lifecycle executor when it is dealing with default lifecycle phases. 091 // ----------------------------------------------------------------------------------------------- 092 093 public void testCalculationOfBuildPlanWithIndividualTaskWherePluginIsSpecifiedInThePom() 094 throws Exception 095 { 096 // We are doing something like "mvn resources:resources" where no version is specified but this 097 // project we are working on has the version specified in the POM so the version should come from there. 098 File pom = getProject( "project-basic" ); 099 MavenSession session = createMavenSession( pom ); 100 assertEquals( "project-basic", session.getCurrentProject().getArtifactId() ); 101 assertEquals( "1.0", session.getCurrentProject().getVersion() ); 102 List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "resources:resources" ) ); 103 assertEquals( 1, executionPlan.size() ); 104 MojoExecution mojoExecution = executionPlan.get( 0 ); 105 assertNotNull( mojoExecution ); 106 assertEquals( "org.apache.maven.plugins", 107 mojoExecution.getMojoDescriptor().getPluginDescriptor().getGroupId() ); 108 assertEquals( "maven-resources-plugin", 109 mojoExecution.getMojoDescriptor().getPluginDescriptor().getArtifactId() ); 110 assertEquals( "0.1", mojoExecution.getMojoDescriptor().getPluginDescriptor().getVersion() ); 111 } 112 113 public void testCalculationOfBuildPlanWithIndividualTaskOfTheCleanLifecycle() 114 throws Exception 115 { 116 // We are doing something like "mvn clean:clean" where no version is specified but this 117 // project we are working on has the version specified in the POM so the version should come from there. 118 File pom = getProject( "project-basic" ); 119 MavenSession session = createMavenSession( pom ); 120 assertEquals( "project-basic", session.getCurrentProject().getArtifactId() ); 121 assertEquals( "1.0", session.getCurrentProject().getVersion() ); 122 List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "clean" ) ); 123 assertEquals( 1, executionPlan.size() ); 124 MojoExecution mojoExecution = executionPlan.get( 0 ); 125 assertNotNull( mojoExecution ); 126 assertEquals( "org.apache.maven.plugins", 127 mojoExecution.getMojoDescriptor().getPluginDescriptor().getGroupId() ); 128 assertEquals( "maven-clean-plugin", mojoExecution.getMojoDescriptor().getPluginDescriptor().getArtifactId() ); 129 assertEquals( "0.1", mojoExecution.getMojoDescriptor().getPluginDescriptor().getVersion() ); 130 } 131 132 public void testCalculationOfBuildPlanWithIndividualTaskOfTheCleanCleanGoal() 133 throws Exception 134 { 135 // We are doing something like "mvn clean:clean" where no version is specified but this 136 // project we are working on has the version specified in the POM so the version should come from there. 137 File pom = getProject( "project-basic" ); 138 MavenSession session = createMavenSession( pom ); 139 assertEquals( "project-basic", session.getCurrentProject().getArtifactId() ); 140 assertEquals( "1.0", session.getCurrentProject().getVersion() ); 141 List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "clean:clean" ) ); 142 assertEquals( 1, executionPlan.size() ); 143 MojoExecution mojoExecution = executionPlan.get( 0 ); 144 assertNotNull( mojoExecution ); 145 assertEquals( "org.apache.maven.plugins", 146 mojoExecution.getMojoDescriptor().getPluginDescriptor().getGroupId() ); 147 assertEquals( "maven-clean-plugin", mojoExecution.getMojoDescriptor().getPluginDescriptor().getArtifactId() ); 148 assertEquals( "0.1", mojoExecution.getMojoDescriptor().getPluginDescriptor().getVersion() ); 149 } 150 151 List<MojoExecution> getExecutions( MavenExecutionPlan mavenExecutionPlan ) 152 { 153 List<MojoExecution> result = new ArrayList<MojoExecution>(); 154 for ( ExecutionPlanItem executionPlanItem : mavenExecutionPlan ) 155 { 156 result.add( executionPlanItem.getMojoExecution() ); 157 } 158 return result; 159 } 160 161 // We need to take in multiple lifecycles 162 public void testCalculationOfBuildPlanTasksOfTheCleanLifecycleAndTheInstallLifecycle() 163 throws Exception 164 { 165 File pom = getProject( "project-with-additional-lifecycle-elements" ); 166 MavenSession session = createMavenSession( pom ); 167 assertEquals( "project-with-additional-lifecycle-elements", session.getCurrentProject().getArtifactId() ); 168 assertEquals( "1.0", session.getCurrentProject().getVersion() ); 169 List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "clean", "install" ) ); 170 171 //[01] clean:clean 172 //[02] resources:resources 173 //[03] compiler:compile 174 //[04] it:generate-metadata 175 //[05] resources:testResources 176 //[06] compiler:testCompile 177 //[07] it:generate-test-metadata 178 //[08] surefire:test 179 //[09] jar:jar 180 //[10] install:install 181 // 182 assertEquals( 10, executionPlan.size() ); 183 184 assertEquals( "clean:clean", executionPlan.get( 0 ).getMojoDescriptor().getFullGoalName() ); 185 assertEquals( "resources:resources", executionPlan.get( 1 ).getMojoDescriptor().getFullGoalName() ); 186 assertEquals( "compiler:compile", executionPlan.get( 2 ).getMojoDescriptor().getFullGoalName() ); 187 assertEquals( "it:generate-metadata", executionPlan.get( 3 ).getMojoDescriptor().getFullGoalName() ); 188 assertEquals( "resources:testResources", executionPlan.get( 4 ).getMojoDescriptor().getFullGoalName() ); 189 assertEquals( "compiler:testCompile", executionPlan.get( 5 ).getMojoDescriptor().getFullGoalName() ); 190 assertEquals( "it:generate-test-metadata", executionPlan.get( 6 ).getMojoDescriptor().getFullGoalName() ); 191 assertEquals( "surefire:test", executionPlan.get( 7 ).getMojoDescriptor().getFullGoalName() ); 192 assertEquals( "jar:jar", executionPlan.get( 8 ).getMojoDescriptor().getFullGoalName() ); 193 assertEquals( "install:install", executionPlan.get( 9 ).getMojoDescriptor().getFullGoalName() ); 194 } 195 196 // We need to take in multiple lifecycles 197 public void testCalculationOfBuildPlanWithMultipleExecutionsOfModello() 198 throws Exception 199 { 200 File pom = getProject( "project-with-multiple-executions" ); 201 MavenSession session = createMavenSession( pom ); 202 assertEquals( "project-with-multiple-executions", session.getCurrentProject().getArtifactId() ); 203 assertEquals( "1.0.1", session.getCurrentProject().getVersion() ); 204 205 MavenExecutionPlan plan = calculateExecutionPlan( session, "clean", "install" ); 206 207 List<MojoExecution> executions = getExecutions( plan ); 208 209 //[01] clean:clean 210 //[02] modello:xpp3-writer 211 //[03] modello:java 212 //[04] modello:xpp3-reader 213 //[05] modello:xpp3-writer 214 //[06] modello:java 215 //[07] modello:xpp3-reader 216 //[08] plugin:descriptor 217 //[09] resources:resources 218 //[10] compiler:compile 219 //[11] resources:testResources 220 //[12] compiler:testCompile 221 //[13] surefire:test 222 //[14] jar:jar 223 //[15] plugin:addPluginArtifactMetadata 224 //[16] install:install 225 // 226 227 assertEquals( 16, executions.size() ); 228 229 assertEquals( "clean:clean", executions.get( 0 ).getMojoDescriptor().getFullGoalName() ); 230 assertEquals( "it:xpp3-writer", executions.get( 1 ).getMojoDescriptor().getFullGoalName() ); 231 assertEquals( "it:java", executions.get( 2 ).getMojoDescriptor().getFullGoalName() ); 232 assertEquals( "it:xpp3-reader", executions.get( 3 ).getMojoDescriptor().getFullGoalName() ); 233 assertEquals( "it:xpp3-writer", executions.get( 4 ).getMojoDescriptor().getFullGoalName() ); 234 assertEquals( "it:java", executions.get( 5 ).getMojoDescriptor().getFullGoalName() ); 235 assertEquals( "it:xpp3-reader", executions.get( 6 ).getMojoDescriptor().getFullGoalName() ); 236 assertEquals( "resources:resources", executions.get( 7 ).getMojoDescriptor().getFullGoalName() ); 237 assertEquals( "compiler:compile", executions.get( 8 ).getMojoDescriptor().getFullGoalName() ); 238 assertEquals( "plugin:descriptor", executions.get( 9 ).getMojoDescriptor().getFullGoalName() ); 239 assertEquals( "resources:testResources", executions.get( 10 ).getMojoDescriptor().getFullGoalName() ); 240 assertEquals( "compiler:testCompile", executions.get( 11 ).getMojoDescriptor().getFullGoalName() ); 241 assertEquals( "surefire:test", executions.get( 12 ).getMojoDescriptor().getFullGoalName() ); 242 assertEquals( "jar:jar", executions.get( 13 ).getMojoDescriptor().getFullGoalName() ); 243 assertEquals( "plugin:addPluginArtifactMetadata", executions.get( 14 ).getMojoDescriptor().getFullGoalName() ); 244 assertEquals( "install:install", executions.get( 15 ).getMojoDescriptor().getFullGoalName() ); 245 246 assertEquals( "src/main/mdo/remote-resources.mdo", 247 new MojoExecutionXPathContainer( executions.get( 1 ) ).getValue( 248 "configuration/models[1]/model" ) ); 249 assertEquals( "src/main/mdo/supplemental-model.mdo", 250 new MojoExecutionXPathContainer( executions.get( 4 ) ).getValue( 251 "configuration/models[1]/model" ) ); 252 } 253 254 public void testLifecycleQueryingUsingADefaultLifecyclePhase() 255 throws Exception 256 { 257 File pom = getProject( "project-with-additional-lifecycle-elements" ); 258 MavenSession session = createMavenSession( pom ); 259 assertEquals( "project-with-additional-lifecycle-elements", session.getCurrentProject().getArtifactId() ); 260 assertEquals( "1.0", session.getCurrentProject().getVersion() ); 261 List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "package" ) ); 262 263 //[01] resources:resources 264 //[02] compiler:compile 265 //[03] it:generate-metadata 266 //[04] resources:testResources 267 //[05] compiler:testCompile 268 //[06] plexus-component-metadata:generate-test-metadata 269 //[07] surefire:test 270 //[08] jar:jar 271 // 272 assertEquals( 8, executionPlan.size() ); 273 274 assertEquals( "resources:resources", executionPlan.get( 0 ).getMojoDescriptor().getFullGoalName() ); 275 assertEquals( "compiler:compile", executionPlan.get( 1 ).getMojoDescriptor().getFullGoalName() ); 276 assertEquals( "it:generate-metadata", executionPlan.get( 2 ).getMojoDescriptor().getFullGoalName() ); 277 assertEquals( "resources:testResources", executionPlan.get( 3 ).getMojoDescriptor().getFullGoalName() ); 278 assertEquals( "compiler:testCompile", executionPlan.get( 4 ).getMojoDescriptor().getFullGoalName() ); 279 assertEquals( "it:generate-test-metadata", executionPlan.get( 5 ).getMojoDescriptor().getFullGoalName() ); 280 assertEquals( "surefire:test", executionPlan.get( 6 ).getMojoDescriptor().getFullGoalName() ); 281 assertEquals( "jar:jar", executionPlan.get( 7 ).getMojoDescriptor().getFullGoalName() ); 282 } 283 284 public void testLifecyclePluginsRetrievalForDefaultLifecycle() 285 throws Exception 286 { 287 List<Plugin> plugins = 288 new ArrayList<Plugin>( lifecycleExecutor.getPluginsBoundByDefaultToAllLifecycles( "jar" ) ); 289 290 assertEquals( 8, plugins.size() ); 291 } 292 293 public void testPluginConfigurationCreation() 294 throws Exception 295 { 296 File pom = getProject( "project-with-additional-lifecycle-elements" ); 297 MavenSession session = createMavenSession( pom ); 298 MojoDescriptor mojoDescriptor = 299 mojoDescriptorCreator.getMojoDescriptor( "org.apache.maven.its.plugins:maven-it-plugin:0.1:java", session, 300 session.getCurrentProject() ); 301 Xpp3Dom dom = MojoDescriptorCreator.convert( mojoDescriptor ); 302 System.out.println( dom ); 303 } 304 305 MavenExecutionPlan calculateExecutionPlan( MavenSession session, String... tasks ) 306 throws Exception 307 { 308 List<TaskSegment> taskSegments = 309 lifeCycleTaskSegmentCalculator.calculateTaskSegments( session, Arrays.asList( tasks ) ); 310 311 TaskSegment mergedSegment = new TaskSegment( false ); 312 313 for ( TaskSegment taskSegment : taskSegments ) 314 { 315 mergedSegment.getTasks().addAll( taskSegment.getTasks() ); 316 } 317 318 return lifeCycleExecutionPlanCalculator.calculateExecutionPlan( session, session.getCurrentProject(), 319 mergedSegment.getTasks() ); 320 } 321 322 public void testInvalidGoalName() 323 throws Exception 324 { 325 File pom = getProject( "project-basic" ); 326 MavenSession session = createMavenSession( pom ); 327 try 328 { 329 getExecutions( calculateExecutionPlan( session, "resources:" ) ); 330 fail( "expected a MojoNotFoundException" ); 331 } 332 catch ( MojoNotFoundException e ) 333 { 334 assertEquals( "", e.getGoal() ); 335 } 336 337 try 338 { 339 getExecutions( calculateExecutionPlan( session, "org.apache.maven.plugins:maven-resources-plugin:0.1:resources:toomany" ) ); 340 fail( "expected a MojoNotFoundException" ); 341 } 342 catch ( MojoNotFoundException e ) 343 { 344 assertEquals( "resources:toomany", e.getGoal() ); 345 } 346 } 347 348 349 public void testPluginPrefixRetrieval() 350 throws Exception 351 { 352 File pom = getProject( "project-basic" ); 353 MavenSession session = createMavenSession( pom ); 354 Plugin plugin = mojoDescriptorCreator.findPluginForPrefix( "resources", session ); 355 assertEquals( "org.apache.maven.plugins", plugin.getGroupId() ); 356 assertEquals( "maven-resources-plugin", plugin.getArtifactId() ); 357 } 358 359 // Prefixes 360 361 public void testFindingPluginPrefixforCleanClean() 362 throws Exception 363 { 364 File pom = getProject( "project-basic" ); 365 MavenSession session = createMavenSession( pom ); 366 Plugin plugin = mojoDescriptorCreator.findPluginForPrefix( "clean", session ); 367 assertNotNull( plugin ); 368 } 369 370 public void testSetupMojoExecution() 371 throws Exception 372 { 373 File pom = getProject( "mojo-configuration" ); 374 375 MavenSession session = createMavenSession( pom ); 376 377 LifecycleTask task = new LifecycleTask( "generate-sources" ); 378 MavenExecutionPlan executionPlan = 379 lifeCycleExecutionPlanCalculator.calculateExecutionPlan( session, session.getCurrentProject(), 380 Arrays.asList( (Object) task ), false ); 381 382 MojoExecution execution = executionPlan.getMojoExecutions().get(0); 383 assertEquals(execution.toString(), "maven-it-plugin", execution.getArtifactId()); 384 assertNull(execution.getConfiguration()); 385 386 lifeCycleExecutionPlanCalculator.setupMojoExecution( session, session.getCurrentProject(), execution ); 387 assertNotNull(execution.getConfiguration()); 388 assertEquals("1.0", execution.getConfiguration().getChild( "version" ).getAttribute( "default-value" )); 389 } 390 391 public void testExecutionListeners() 392 throws Exception 393 { 394 final File pom = getProject( "project-basic" ); 395 final MavenSession session = createMavenSession( pom ); 396 session.setProjectDependencyGraph( new ProjectDependencyGraph() 397 { 398 public List<MavenProject> getUpstreamProjects( MavenProject project, boolean transitive ) 399 { 400 return Collections.emptyList(); 401 } 402 403 public List<MavenProject> getSortedProjects() 404 { 405 return Collections.singletonList( session.getCurrentProject() ); 406 } 407 408 public List<MavenProject> getDownstreamProjects( MavenProject project, boolean transitive ) 409 { 410 return Collections.emptyList(); 411 } 412 413 public java.util.List<MavenProject> getAllSortedProjects() 414 { 415 return Collections.emptyList(); 416 } 417 } ); 418 419 final List<String> log = new ArrayList<String>(); 420 421 MojoExecutionListener mojoListener = new MojoExecutionListener() 422 { 423 public void beforeMojoExecution( MojoExecutionEvent event ) 424 throws MojoExecutionException 425 { 426 assertNotNull( event.getSession() ); 427 assertNotNull( event.getProject() ); 428 assertNotNull( event.getExecution() ); 429 assertNotNull( event.getMojo() ); 430 assertNull( event.getCause() ); 431 432 log.add( "beforeMojoExecution " + event.getProject().getArtifactId() + ":" 433 + event.getExecution().getExecutionId() ); 434 } 435 436 public void afterMojoExecutionSuccess( MojoExecutionEvent event ) 437 throws MojoExecutionException 438 { 439 assertNotNull( event.getSession() ); 440 assertNotNull( event.getProject() ); 441 assertNotNull( event.getExecution() ); 442 assertNotNull( event.getMojo() ); 443 assertNull( event.getCause() ); 444 445 log.add( "afterMojoExecutionSuccess " + event.getProject().getArtifactId() + ":" 446 + event.getExecution().getExecutionId() ); 447 } 448 449 public void afterExecutionFailure( MojoExecutionEvent event ) 450 { 451 assertNotNull( event.getSession() ); 452 assertNotNull( event.getProject() ); 453 assertNotNull( event.getExecution() ); 454 assertNotNull( event.getMojo() ); 455 assertNotNull( event.getCause() ); 456 457 log.add( "afterExecutionFailure " + event.getProject().getArtifactId() + ":" 458 + event.getExecution().getExecutionId() ); 459 } 460 }; 461 ProjectExecutionListener projectListener = new ProjectExecutionListener() 462 { 463 public void beforeProjectExecution( ProjectExecutionEvent event ) 464 throws LifecycleExecutionException 465 { 466 assertNotNull( event.getSession() ); 467 assertNotNull( event.getProject() ); 468 assertNull( event.getExecutionPlan() ); 469 assertNull( event.getCause() ); 470 471 log.add( "beforeProjectExecution " + event.getProject().getArtifactId() ); 472 } 473 474 public void beforeProjectLifecycleExecution( ProjectExecutionEvent event ) 475 throws LifecycleExecutionException 476 { 477 assertNotNull( event.getSession() ); 478 assertNotNull( event.getProject() ); 479 assertNotNull( event.getExecutionPlan() ); 480 assertNull( event.getCause() ); 481 482 log.add( "beforeProjectLifecycleExecution " + event.getProject().getArtifactId() ); 483 } 484 485 public void afterProjectExecutionSuccess( ProjectExecutionEvent event ) 486 throws LifecycleExecutionException 487 { 488 assertNotNull( event.getSession() ); 489 assertNotNull( event.getProject() ); 490 assertNotNull( event.getExecutionPlan() ); 491 assertNull( event.getCause() ); 492 493 log.add( "afterProjectExecutionSuccess " + event.getProject().getArtifactId() ); 494 } 495 496 public void afterProjectExecutionFailure( ProjectExecutionEvent event ) 497 { 498 assertNotNull( event.getSession() ); 499 assertNotNull( event.getProject() ); 500 assertNull( event.getExecutionPlan() ); 501 assertNotNull( event.getCause() ); 502 503 log.add( "afterProjectExecutionFailure " + event.getProject().getArtifactId() ); 504 } 505 }; 506 lookup( DelegatingProjectExecutionListener.class ).addProjectExecutionListener( projectListener ); 507 lookup( DelegatingMojoExecutionListener.class ).addMojoExecutionListener( mojoListener ); 508 509 try 510 { 511 lifecycleExecutor.execute( session ); 512 } 513 finally 514 { 515 lookup( DelegatingProjectExecutionListener.class ).removeProjectExecutionListener( projectListener ); 516 lookup( DelegatingMojoExecutionListener.class ).removeMojoExecutionListener( mojoListener ); 517 } 518 519 List<String> expectedLog = Arrays.asList( "beforeProjectExecution project-basic", // 520 "beforeProjectLifecycleExecution project-basic", // 521 "beforeMojoExecution project-basic:default-resources", // 522 "afterMojoExecutionSuccess project-basic:default-resources", // 523 "beforeMojoExecution project-basic:default-compile", // 524 "afterMojoExecutionSuccess project-basic:default-compile", // 525 "beforeMojoExecution project-basic:default-testResources", // 526 "afterMojoExecutionSuccess project-basic:default-testResources", // 527 "beforeMojoExecution project-basic:default-testCompile", // 528 "afterMojoExecutionSuccess project-basic:default-testCompile", // 529 "beforeMojoExecution project-basic:default-test", // 530 "afterMojoExecutionSuccess project-basic:default-test", // 531 "beforeMojoExecution project-basic:default-jar", // 532 "afterMojoExecutionSuccess project-basic:default-jar", // 533 "afterProjectExecutionSuccess project-basic" // 534 ); 535 536 assertEventLog( expectedLog, log ); 537 } 538 539 private static void assertEventLog( List<String> expectedList, List<String> actualList ) 540 { 541 assertEquals( toString( expectedList ), toString( actualList ) ); 542 } 543 544 private static String toString( List<String> lines ) 545 { 546 StringBuilder sb = new StringBuilder(); 547 for ( String line : lines ) 548 { 549 sb.append( line ).append( '\n' ); 550 } 551 return sb.toString(); 552 } 553}