plugins/maven/src/test/java/org/jetbrains/idea/maven/importing/FoldersImportingTest.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.jetbrains.idea.maven.importing;
  17
  18 import com.intellij.openapi.roots.CompilerModuleExtension;
  19 import com.intellij.openapi.roots.ModuleRootManager;
  20 import com.intellij.openapi.vfs.VirtualFile;
  21 import org.jetbrains.idea.maven.MavenImportingTestCase;
  22 import org.jetbrains.idea.maven.importing.MavenDefaultModifiableModelsProvider;
  23 import org.jetbrains.idea.maven.importing.MavenRootModelAdapter;
  24 import org.jetbrains.idea.maven.indices.MavenCustomRepositoryHelper;
  25 import org.jetbrains.idea.maven.utils.Path;
  26
  27 import java.io.File;
  28
  29 public class FoldersImportingTest extends MavenImportingTestCase {
  30   public void testSimpleProjectStructure() throws Exception {
  31     createStdProjectFolders();
  32
  33     importProject("<groupId>test</groupId>" +
  34                   "<artifactId>project</artifactId>" +
  35                   "<version>1</version>");
  36
  37     assertModules("project");
  38     assertContentRoots("project", getProjectPath());
  39
  40     assertSources("project", "src/main/java", "src/main/resources");
  41     assertTestSources("project", "src/test/java", "src/test/resources");
  42   }
  43
  44   public void testInvalidProjectHasContentRoot() throws Exception {
  45     importProject("<groupId>test</groupId>" +
  46                   "<artifactId>project</artifactId>" +
  47                   "<version>1");
  48
  49     assertModules("project");
  50     assertContentRoots("project", getProjectPath());
  51   }
  52
  53   public void testDoNotResetFoldersAfterResolveIfProjectIsInvalid() throws Exception {
  54     createStdProjectFolders();
  55
  56     importProject("<groupId>test</groupId>" +
  57                   "<artifactId>project</artifactId>" +
  58                   "<version>1</version>" +
  59
  60                   "<build>" +
  61                   "  <extensions>" +
  62                   "    <extension>" +
  63                   "      <groupId>xxx</groupId>" +
  64                   "      <artifactId>xxx</artifactId>" +
  65                   "      <version>xxx</version>" +
  66                   "    </extension>" +
  67                   "  </extensions>" +
  68                   "</build>");
  69
  70     assertModules("project");
  71     assertSources("project", "src/main/java", "src/main/resources");
  72     assertTestSources("project", "src/test/java", "src/test/resources");
  73   }
  74
  75   public void testDoesNotResetUserFolders() throws Exception {
  76     VirtualFile dir1 = createProjectSubDir("userSourceFolder");
  77     VirtualFile dir2 = createProjectSubDir("userExcludedFolder");
  78
  79     importProject("<groupId>test</groupId>" +
  80                   "<artifactId>project</artifactId>" +
  81                   "<version>1</version>");
  82
  83     MavenRootModelAdapter adapter = new MavenRootModelAdapter(myProjectsTree.findProject(myProjectPom),
  84                                                               getModule("project"),
  85                                                               new MavenDefaultModifiableModelsProvider(myProject));
  86     adapter.addSourceFolder(dir1.getPath(), false);
  87     adapter.addExcludedFolder(dir2.getPath());
  88     adapter.getRootModel().commit();
  89
  90     assertSources("project", "userSourceFolder");
  91     assertExcludes("project", "target", "userExcludedFolder");
  92
  93     importProject();
  94
  95     assertSources("project", "userSourceFolder");
  96     assertExcludes("project", "target", "userExcludedFolder");
  97
  98     resolveFoldersAndImport();
  99
 100     assertSources("project", "userSourceFolder");
 101     assertExcludes("project", "target", "userExcludedFolder");
 102   }
 103
 104   public void testCustomSourceFolders() throws Exception {
 105     createStdProjectFolders();
 106     createProjectSubDirs("src", "test", "res1", "res2", "testRes1", "testRes2");
 107
 108     importProject("<groupId>test</groupId>" +
 109                   "<artifactId>project</artifactId>" +
 110                   "<version>1</version>" +
 111
 112                   "<build>" +
 113                   "  <sourceDirectory>src</sourceDirectory>" +
 114                   "  <testSourceDirectory>test</testSourceDirectory>" +
 115                   "  <resources>" +
 116                   "    <resource><directory>res1</directory></resource>" +
 117                   "    <resource><directory>res2</directory></resource>" +
 118                   "  </resources>" +
 119                   "  <testResources>" +
 120                   "    <testResource><directory>testRes1</directory></testResource>" +
 121                   "    <testResource><directory>testRes2</directory></testResource>" +
 122                   "  </testResources>" +
 123                   "</build>");
 124
 125     assertModules("project");
 126     assertContentRoots("project", getProjectPath());
 127
 128     assertSources("project", "src", "res1", "res2");
 129     assertTestSources("project", "test", "testRes1", "testRes2");
 130   }
 131
 132   public void testDoNotAddCustomSourceFoldersOutsideOfContentRoot() throws Exception {
 133     createStdProjectFolders();
 134     createProjectSubDirs("m",
 135                          "src",
 136                          "test",
 137                          "res",
 138                          "testRes");
 139
 140     createProjectPom("<groupId>test</groupId>" +
 141                      "<artifactId>project</artifactId>" +
 142                      "<packaging>pom</packaging>" +
 143                      "<version>1</version>" +
 144
 145                      "<modules>" +
 146                      "  <module>m</module>" +
 147                      "</modules>");
 148
 149     createModulePom("m", "<groupId>test</groupId>" +
 150                          "<artifactId>m</artifactId>" +
 151                          "<version>1</version>" +
 152
 153                          "<build>" +
 154                          "  <sourceDirectory>../src</sourceDirectory>" +
 155                          "  <testSourceDirectory>../test</testSourceDirectory>" +
 156                          "  <resources>" +
 157                          "    <resource><directory>../res</directory></resource>" +
 158                          "  </resources>" +
 159                          "  <testResources>" +
 160                          "    <testResource><directory>../testRes</directory></testResource>" +
 161                          "  </testResources>" +
 162                          "</build>");
 163     importProject();
 164     assertModules("project", "m");
 165     assertContentRoots("m",
 166                        getProjectPath() + "/m");
 167                        //getProjectPath() + "/src",
 168                        //getProjectPath() + "/test",
 169                        //getProjectPath() + "/res",
 170                        //getProjectPath() + "/testRes");
 171   }
 172
 173   public void testPluginSources() throws Exception {
 174     createStdProjectFolders();
 175     createProjectSubDirs("src1", "src2");
 176
 177     importProject("<groupId>test</groupId>" +
 178                   "<artifactId>project</artifactId>" +
 179                   "<version>1</version>" +
 180
 181                   "<build>" +
 182                   "  <plugins>" +
 183                   "    <plugin>" +
 184                   "      <groupId>org.codehaus.mojo</groupId>" +
 185                   "      <artifactId>build-helper-maven-plugin</artifactId>" +
 186                   "      <version>1.3</version>" +
 187                   "      <executions>" +
 188                   "        <execution>" +
 189                   "          <id>someId</id>" +
 190                   "          <phase>generate-sources</phase>" +
 191                   "          <goals>" +
 192                   "            <goal>add-source</goal>" +
 193                   "          </goals>" +
 194                   "          <configuration>" +
 195                   "            <sources>" +
 196                   "              <source>${basedir}/src1</source>" +
 197                   "              <source>${basedir}/src2</source>" +
 198                   "            </sources>" +
 199                   "          </configuration>" +
 200                   "        </execution>" +
 201                   "      </executions>" +
 202                   "    </plugin>" +
 203                   "  </plugins>" +
 204                   "</build>");
 205     resolveFoldersAndImport();
 206     assertModules("project");
 207
 208     assertSources("project", "src/main/java", "src/main/resources", "src1", "src2");
 209   }
 210
 211   public void testPluginSourceDuringGenerateResourcesPhase() throws Exception {
 212     createStdProjectFolders();
 213     createProjectSubDirs("extraResources");
 214
 215     importProject("<groupId>test</groupId>" +
 216                   "<artifactId>project</artifactId>" +
 217                   "<version>1</version>" +
 218
 219                   "<build>" +
 220                   "  <plugins>" +
 221                   "    <plugin>" +
 222                   "      <groupId>org.codehaus.mojo</groupId>" +
 223                   "      <artifactId>build-helper-maven-plugin</artifactId>" +
 224                   "      <version>1.3</version>" +
 225                   "      <executions>" +
 226                   "        <execution>" +
 227                   "          <id>someId</id>" +
 228                   "          <phase>generate-resources</phase>" +
 229                   "          <goals>" +
 230                   "            <goal>add-source</goal>" +
 231                   "          </goals>" +
 232                   "          <configuration>" +
 233                   "            <sources>" +
 234                   "              <source>${basedir}/extraResources</source>" +
 235                   "            </sources>" +
 236                   "          </configuration>" +
 237                   "        </execution>" +
 238                   "      </executions>" +
 239                   "    </plugin>" +
 240                   "  </plugins>" +
 241                   "</build>");
 242     resolveFoldersAndImport();
 243     assertModules("project");
 244
 245     assertSources("project", "extraResources", "src/main/java", "src/main/resources");
 246   }
 247
 248   public void testPluginTestSourcesDuringGenerateTestResourcesPhase() throws Exception {
 249     createStdProjectFolders();
 250     createProjectSubDirs("extraTestResources");
 251
 252     getMavenImporterSettings().setUpdateFoldersOnImportPhase("generate-test-resources");
 253
 254     importProject("<groupId>test</groupId>" +
 255                   "<artifactId>project</artifactId>" +
 256                   "<version>1</version>" +
 257
 258                   "<build>" +
 259                   "  <plugins>" +
 260                   "    <plugin>" +
 261                   "      <groupId>org.codehaus.mojo</groupId>" +
 262                   "      <artifactId>build-helper-maven-plugin</artifactId>" +
 263                   "      <version>1.3</version>" +
 264                   "      <executions>" +
 265                   "        <execution>" +
 266                   "          <id>someId</id>" +
 267                   "          <phase>generate-test-resources</phase>" +
 268                   "          <goals>" +
 269                   "            <goal>add-test-source</goal>" +
 270                   "          </goals>" +
 271                   "          <configuration>" +
 272                   "            <sources>" +
 273                   "              <source>${basedir}/extraTestResources</source>" +
 274                   "            </sources>" +
 275                   "          </configuration>" +
 276                   "        </execution>" +
 277                   "      </executions>" +
 278                   "    </plugin>" +
 279                   "  </plugins>" +
 280                   "</build>");
 281     resolveFoldersAndImport();
 282     assertModules("project");
 283
 284     assertTestSources("project", "extraTestResources", "src/test/java", "src/test/resources");
 285   }
 286
 287   public void testPluginSourcesWithRelativePath() throws Exception {
 288     createStdProjectFolders();
 289     createProjectSubDirs("relativePath");
 290
 291     importProject("<groupId>test</groupId>" +
 292                   "<artifactId>project</artifactId>" +
 293                   "<version>1</version>" +
 294
 295                   "<build>" +
 296                   "  <plugins>" +
 297                   "    <plugin>" +
 298                   "      <groupId>org.codehaus.mojo</groupId>" +
 299                   "      <artifactId>build-helper-maven-plugin</artifactId>" +
 300                   "      <version>1.3</version>" +
 301                   "      <executions>" +
 302                   "        <execution>" +
 303                   "          <id>someId</id>" +
 304                   "          <phase>generate-sources</phase>" +
 305                   "          <goals>" +
 306                   "            <goal>add-source</goal>" +
 307                   "          </goals>" +
 308                   "          <configuration>" +
 309                   "            <sources>" +
 310                   "              <source>relativePath</source>" +
 311                   "            </sources>" +
 312                   "          </configuration>" +
 313                   "        </execution>" +
 314                   "      </executions>" +
 315                   "    </plugin>" +
 316                   "  </plugins>" +
 317                   "</build>");
 318     resolveFoldersAndImport();
 319     assertModules("project");
 320
 321     assertSources("project", "src/main/java", "src/main/resources", "relativePath");
 322   }
 323
 324   public void testPluginSourcesWithVariables() throws Exception {
 325     createStdProjectFolders();
 326     createProjectSubDirs("target/src");
 327
 328     importProject("<groupId>test</groupId>" +
 329                   "<artifactId>project</artifactId>" +
 330                   "<version>1</version>" +
 331
 332                   "<build>" +
 333                   "  <plugins>" +
 334                   "    <plugin>" +
 335                   "      <groupId>org.codehaus.mojo</groupId>" +
 336                   "      <artifactId>build-helper-maven-plugin</artifactId>" +
 337                   "      <version>1.3</version>" +
 338                   "      <executions>" +
 339                   "        <execution>" +
 340                   "          <id>someId</id>" +
 341                   "          <phase>generate-sources</phase>" +
 342                   "          <goals>" +
 343                   "            <goal>add-source</goal>" +
 344                   "          </goals>" +
 345                   "          <configuration>" +
 346                   "            <sources>" +
 347                   "              <source>${project.build.directory}/src</source>" +
 348                   "            </sources>" +
 349                   "          </configuration>" +
 350                   "        </execution>" +
 351                   "      </executions>" +
 352                   "    </plugin>" +
 353                   "  </plugins>" +
 354                   "</build>");
 355     resolveFoldersAndImport();
 356     assertModules("project");
 357
 358     assertSources("project", "src/main/java", "src/main/resources", "target/src");
 359   }
 360
 361   public void testPluginSourcesWithIntermoduleDependency() throws Exception {
 362     createProjectSubDirs("m1/src/main/java",
 363                          "m1/src/main/resources",
 364                          "m1/src/foo");
 365
 366     createProjectPom("<groupId>test</groupId>" +
 367                      "<artifactId>project</artifactId>" +
 368                      "<version>1</version>" +
 369
 370                      "<modules>" +
 371                      "  <module>m1</module>" +
 372                      "  <module>m2</module>" +
 373                      "</modules>");
 374
 375     createModulePom("m1",
 376                     "<groupId>test</groupId>" +
 377                     "<artifactId>m1</artifactId>" +
 378                     "<version>1</version>" +
 379
 380                     "<dependencies>" +
 381                     "  <dependency>" +
 382                     "    <groupId>test</groupId>" +
 383                     "    <artifactId>m2</artifactId>" +
 384                     "    <version>1</version>" +
 385                     "  </dependency>" +
 386                     "</dependencies>" +
 387
 388                     "<build>" +
 389                     "  <plugins>" +
 390                     "    <plugin>" +
 391                     "      <groupId>org.codehaus.mojo</groupId>" +
 392                     "      <artifactId>build-helper-maven-plugin</artifactId>" +
 393                     "      <version>1.3</version>" +
 394                     "      <executions>" +
 395                     "        <execution>" +
 396                     "          <id>someId</id>" +
 397                     "          <phase>generate-sources</phase>" +
 398                     "          <goals>" +
 399                     "            <goal>add-source</goal>" +
 400                     "          </goals>" +
 401                     "          <configuration>" +
 402                     "            <sources>" +
 403                     "              <source>src/foo</source>" +
 404                     "            </sources>" +
 405                     "          </configuration>" +
 406                     "        </execution>" +
 407                     "      </executions>" +
 408                     "    </plugin>" +
 409                     "  </plugins>" +
 410                     "</build>");
 411
 412     createModulePom("m2",
 413                     "<groupId>test</groupId>" +
 414                     "<artifactId>m2</artifactId>" +
 415                     "<version>1</version>");
 416     importProject();
 417     assertModules("project", "m1", "m2");
 418
 419     resolveFoldersAndImport();
 420     assertSources("m1", "src/main/java", "src/main/resources", "src/foo");
 421   }
 422
 423   public void testDownloadingNecessaryPlugins() throws Exception {
 424     MavenCustomRepositoryHelper helper = new MavenCustomRepositoryHelper(myDir, "local1");
 425     setRepositoryPath(helper.getTestDataPath("local1"));
 426
 427     File pluginFile = new File(getRepositoryPath(),
 428                                "org/codehaus/mojo/build-helper-maven-plugin/1.2/build-helper-maven-plugin-1.2.jar");
 429     assertFalse(pluginFile.exists());
 430
 431     importProject("<groupId>test</groupId>" +
 432                   "<artifactId>project</artifactId>" +
 433                   "<version>1</version>" +
 434
 435                   "<build>" +
 436                   "  <plugins>" +
 437                   "    <plugin>" +
 438                   "      <groupId>org.codehaus.mojo</groupId>" +
 439                   "      <artifactId>build-helper-maven-plugin</artifactId>" +
 440                   "      <version>1.2</version>" +
 441                   "      <executions>" +
 442                   "        <execution>" +
 443                   "          <id>someId</id>" +
 444                   "          <phase>generate-sources</phase>" +
 445                   "          <goals>" +
 446                   "            <goal>add-source</goal>" +
 447                   "          </goals>" +
 448                   "          <configuration>" +
 449                   "            <sources>" +
 450                   "              <source>src</source>" +
 451                   "            </sources>" +
 452                   "          </configuration>" +
 453                   "        </execution>" +
 454                   "      </executions>" +
 455                   "    </plugin>" +
 456                   "  </plugins>" +
 457                   "</build>");
 458     resolveDependenciesAndImport();
 459     resolveFoldersAndImport();
 460
 461     assertTrue(pluginFile.exists());
 462   }
 463
 464   public void testAddingExistingGeneratedSources() throws Exception {
 465     createStdProjectFolders();
 466     createProjectSubDirs("target/generated-sources/src1",
 467                          "target/generated-sources/src2");
 468
 469     importProject("<groupId>test</groupId>" +
 470                   "<artifactId>project</artifactId>" +
 471                   "<version>1</version>");
 472
 473     assertSources("project",
 474                   "src/main/java",
 475                   "src/main/resources",
 476                   "target/generated-sources/src1",
 477                   "target/generated-sources/src2");
 478   }
 479
 480   public void testAddingExistingGeneratedSourcesWithCustomTargetDir() throws Exception {
 481     createStdProjectFolders();
 482     createProjectSubDirs("targetCustom/generated-sources/src1",
 483                          "targetCustom/generated-sources/src2");
 484
 485     importProject("<groupId>test</groupId>" +
 486                   "<artifactId>project</artifactId>" +
 487                   "<version>1</version>" +
 488
 489                   "<build>" +
 490                   "  <directory>targetCustom</directory>" +
 491                   "</build>");
 492
 493     assertSources("project",
 494                   "src/main/java",
 495                   "src/main/resources",
 496                   "targetCustom/generated-sources/src1",
 497                   "targetCustom/generated-sources/src2");
 498   }
 499
 500   public void testDoesNotAddAlreadyRegisteredSourcesUnderGeneratedDir() throws Exception {
 501     createStdProjectFolders();
 502     createProjectSubDir("target/generated-sources/main/src");
 503
 504     importProject("<groupId>test</groupId>" +
 505                   "<artifactId>project</artifactId>" +
 506                   "<version>1</version>" +
 507
 508                   "<build>" +
 509                   "  <plugins>" +
 510                   "    <plugin>" +
 511                   "      <groupId>org.codehaus.mojo</groupId>" +
 512                   "      <artifactId>build-helper-maven-plugin</artifactId>" +
 513                   "      <version>1.3</version>" +
 514                   "      <executions>" +
 515                   "        <execution>" +
 516                   "          <id>id</id>" +
 517                   "          <phase>generate-sources</phase>" +
 518                   "          <goals>" +
 519                   "            <goal>add-source</goal>" +
 520                   "          </goals>" +
 521                   "          <configuration>" +
 522                   "            <sources>" +
 523                   "              <source>target/generated-sources/main/src</source>" +
 524                   "            </sources>" +
 525                   "          </configuration>" +
 526                   "        </execution>" +
 527                   "      </executions>" +
 528                   "    </plugin>" +
 529                   "  </plugins>" +
 530                   "</build>");
 531     resolveFoldersAndImport();
 532
 533     assertSources("project",
 534                   "src/main/java",
 535                   "src/main/resources",
 536                   "target/generated-sources/main/src");
 537   }
 538
 539   public void testIgnoringFilesRightUnderGeneratedSources() throws Exception {
 540     createStdProjectFolders();
 541     createProjectSubFile("target/generated-sources/f.txt");
 542
 543     importProject("<groupId>test</groupId>" +
 544                   "<artifactId>project</artifactId>" +
 545                   "<version>1</version>");
 546
 547     assertSources("project", "src/main/java", "src/main/resources");
 548   }
 549
 550   public void testExcludingOutputDirectories() throws Exception {
 551     importProject("<groupId>test</groupId>" +
 552                   "<artifactId>project</artifactId>" +
 553                   "<version>1</version>");
 554     assertModules("project");
 555
 556     assertExcludes("project", "target");
 557     assertModuleOutput("project",
 558                        getProjectPath() + "/target/classes",
 559                        getProjectPath() + "/target/test-classes");
 560   }
 561
 562   public void testExcludingOutputDirectoriesIfProjectOutputIsUsed() throws Exception {
 563     getMavenImporterSettings().setUseMavenOutput(false);
 564
 565     importProject("<groupId>test</groupId>" +
 566                   "<artifactId>project</artifactId>" +
 567                   "<version>1</version>" +
 568
 569                   "<build>" +
 570                   "  <directory>foo</directory>" +
 571                   "</build>");
 572     assertModules("project");
 573
 574     assertExcludes("project", "foo");
 575     assertProjectOutput("project");
 576   }
 577
 578   public void testExcludingCustomOutputDirectories() throws Exception {
 579     importProject("<groupId>test</groupId>" +
 580                   "<artifactId>project</artifactId>" +
 581                   "<version>1</version>" +
 582
 583                   "<build>" +
 584                   "  <directory>targetCustom</directory>" +
 585                   "  <outputDirectory>outputCustom</outputDirectory>" +
 586                   "  <testOutputDirectory>testCustom</testOutputDirectory>" +
 587                   "</build>");
 588
 589     assertModules("project");
 590
 591     assertExcludes("project",
 592                    "targetCustom",
 593                    "outputCustom",
 594                    "testCustom");
 595     assertModuleOutput("project",
 596                        getProjectPath() + "/outputCustom",
 597                        getProjectPath() + "/testCustom");
 598   }
 599
 600   public void testExcludingCustomOutputUnderTargetUsingStandardVariable() throws Exception {
 601     importProject("<groupId>test</groupId>" +
 602                   "<artifactId>project</artifactId>" +
 603                   "<version>1</version>" +
 604
 605                   "<build>" +
 606                   "  <outputDirectory>${project.build.directory}/outputCustom</outputDirectory>" +
 607                   "  <testOutputDirectory>${project.build.directory}/testCustom</testOutputDirectory>" +
 608                   "</build>");
 609
 610     assertModules("project");
 611
 612     assertExcludes("project", "target");
 613     assertModuleOutput("project",
 614                        getProjectPath() + "/target/outputCustom",
 615                        getProjectPath() + "/target/testCustom");
 616   }
 617
 618   public void testOutputDirsOutsideOfContentRoot() throws Exception {
 619     importProject("<groupId>test</groupId>" +
 620                   "<artifactId>project</artifactId>" +
 621                   "<version>1</version>" +
 622
 623                   "<build>" +
 624                   "  <directory>../target</directory>" +
 625                   "  <outputDirectory>../target/classes</outputDirectory>" +
 626                   "  <testOutputDirectory>../target/test-classes</testOutputDirectory>" +
 627                   "</build>");
 628
 629     String targetPath = getParentPath() + "/target";
 630     String targetUrl = new Path(targetPath).toUrl().getUrl();
 631
 632     assertContentRoots("project", getProjectPath());
 633
 634     //ContentEntry targetEntry = null;
 635     //for (ContentEntry each : getContentRoots("project")) {
 636     //  if (each.getUrl().equals(targetUrl)) {
 637     //    targetEntry = each;
 638     //    break;
 639     //  }
 640     //}
 641     //ExcludeFolder[] excludedFolders = targetEntry.getExcludeFolders();
 642     //assertEquals(1, excludedFolders.length);
 643     //assertEquals(targetUrl, excludedFolders[0].getUrl());
 644     //
 645     assertModuleOutput("project",
 646                        getParentPath() + "/target/classes",
 647                        getParentPath() + "/target/test-classes");
 648   }
 649
 650   public void testDoesNotExcludeGeneratedSourcesUnderTargetDir() throws Exception {
 651     createStdProjectFolders();
 652     createProjectSubDirs("target/foo",
 653                          "target/bar",
 654                          "target/generated-sources/baz");
 655
 656     importProject("<groupId>test</groupId>" +
 657                   "<artifactId>project</artifactId>" +
 658                   "<version>1</version>");
 659
 660     assertExcludes("project", "target/foo", "target/bar");
 661
 662     assertSources("project",
 663                   "src/main/java",
 664                   "src/main/resources",
 665                   "target/generated-sources/baz");
 666   }
 667
 668   public void testDoesNotExcludeSourcesUnderTargetDir() throws Exception {
 669     createStdProjectFolders();
 670     createProjectSubDirs("target/src",
 671                          "target/test",
 672                          "target/xxx");
 673
 674     importProject("<groupId>test</groupId>" +
 675                   "<artifactId>project</artifactId>" +
 676                   "<version>1</version>" +
 677
 678                   "<build>" +
 679                   "  <sourceDirectory>target/src</sourceDirectory>" +
 680                   "  <testSourceDirectory>target/test</testSourceDirectory>" +
 681                   "</build>");
 682
 683     assertModules("project");
 684
 685     assertExcludes("project", "target/xxx");
 686   }
 687
 688   public void testDoesNotExcludeSourcesUnderTargetDirWithProperties() throws Exception {
 689     createProjectSubDirs("target/src", "target/xxx");
 690
 691     importProject("<groupId>test</groupId>" +
 692                   "<artifactId>project</artifactId>" +
 693                   "<version>1</version>" +
 694
 695                   "<build>" +
 696                   "  <sourceDirectory>${project.build.directory}/src</sourceDirectory>" +
 697                   "</build>");
 698
 699     assertModules("project");
 700
 701     assertSources("project", "target/src");
 702     assertExcludes("project", "target/xxx");
 703   }
 704
 705   public void testDoesNotExcludeFoldersWithSourcesUnderTargetDir() throws Exception {
 706     createStdProjectFolders();
 707     createProjectSubDirs("target/src/main",
 708                          "target/foo");
 709
 710     importProject("<groupId>test</groupId>" +
 711                   "<artifactId>project</artifactId>" +
 712                   "<version>1</version>" +
 713
 714                   "<build>" +
 715                   "  <sourceDirectory>target/src/main</sourceDirectory>" +
 716                   "</build>");
 717
 718     assertModules("project");
 719
 720     assertExcludes("project", "target/foo");
 721
 722     assertSources("project",
 723                   "target/src/main",
 724                   "src/main/resources");
 725   }
 726
 727   public void testUnexcludeNewSources() throws Exception {
 728     createProjectSubDirs("target/foo");
 729     createProjectSubDirs("target/src");
 730     createProjectSubDirs("target/test/subFolder");
 731
 732     importProject("<groupId>test</groupId>" +
 733                   "<artifactId>project</artifactId>" +
 734                   "<version>1</version>");
 735
 736     assertExcludes("project", "target");
 737
 738     createProjectPom("<groupId>test</groupId>" +
 739                      "<artifactId>project</artifactId>" +
 740                      "<version>1</version>" +
 741
 742                      "<build>" +
 743                      "  <sourceDirectory>target/src</sourceDirectory>" +
 744                      "  <testSourceDirectory>target/test/subFolder</testSourceDirectory>" +
 745                      "</build>");
 746     importProject();
 747
 748     assertSources("project", "target/src");
 749     assertTestSources("project", "target/test/subFolder");
 750     assertExcludes("project", "target/foo");
 751   }
 752
 753   public void testUnexcludeNewSourcesUnderCompilerOutputDir() throws Exception {
 754     createProjectSubDirs("target/classes/src");
 755
 756     importProject("<groupId>test</groupId>" +
 757                   "<artifactId>project</artifactId>" +
 758                   "<version>1</version>");
 759
 760     assertExcludes("project", "target");
 761     //assertTrue(getCompilerExtension("project").isExcludeOutput());
 762
 763     createProjectPom("<groupId>test</groupId>" +
 764                      "<artifactId>project</artifactId>" +
 765                      "<version>1</version>" +
 766
 767                      "<build>" +
 768                      "  <sourceDirectory>target/classes/src</sourceDirectory>" +
 769                      "</build>");
 770     importProject();
 771
 772     assertSources("project", "target/classes/src");
 773     assertExcludes("project");
 774
 775     //assertFalse(getCompilerExtension("project").isExcludeOutput());
 776   }
 777
 778   private CompilerModuleExtension getCompilerExtension(String moduleName) {
 779     return ModuleRootManager.getInstance(getModule(moduleName)).getModuleExtension(CompilerModuleExtension.class);
 780   }
 781 }