Attachment #142185 for bug #124313

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 124313
Collapse All | Expand All

Lines 202-208 Link Here

(-)apisupport.ant/src/org/netbeans/modules/apisupport/project/ui/ModuleActions.java (-4 / +89 lines)
202	} else if (command.equals(COMMAND_TEST)) {	202	} else if (command.equals(COMMAND_TEST)) {
203	return project.supportedTestTypes().contains("unit");	203	return project.supportedTestTypes().contains("unit");
204	} else if (command.equals(COMMAND_TEST_SINGLE)) {	204	} else if (command.equals(COMMAND_TEST_SINGLE)) {
205	return findTestSourcesForSources(context) != null \|\| findTestSources(context, true) != null;	205	return findTestSourcesForSources(context) != null \|\| findTestSources(context, true) != null \|\| findTestSourcesForFiles(context) != null;
206	} else if (command.equals(COMMAND_DEBUG_TEST_SINGLE)) {	206	} else if (command.equals(COMMAND_DEBUG_TEST_SINGLE)) {
207	TestSources testSources = findTestSourcesForSources(context);	207	TestSources testSources = findTestSourcesForSources(context);
208	if (testSources == null)	208	if (testSources == null)
Lines 247-255 Link Here
247	private static final String SUBSTNG = "NGTest.java"; // NOI18N	247	private static final String SUBSTNG = "NGTest.java"; // NOI18N
248		248
249	private FileObject[] findSources(Lookup context) {	249	private FileObject[] findSources(Lookup context) {
		250	return findSources(context, false, true);
		251	}
		252
		253	private FileObject[] findSources(Lookup context, boolean findInPackages, boolean strict) {
250	FileObject srcDir = project.getSourceDirectory();	254	FileObject srcDir = project.getSourceDirectory();
251	if (srcDir != null) {	255	if (srcDir != null) {
252	FileObject[] files = ActionUtils.findSelectedFiles(context, srcDir, ".java", true); // NOI18N	256	FileObject[] files = ActionUtils.findSelectedFiles(context, srcDir, findInPackages ? null : ".java", strict); // NOI18N
253	//System.err.println("findSources: srcDir=" + srcDir + " files=" + (files != null ? java.util.Arrays.asList(files) : null) + " context=" + context);	257	//System.err.println("findSources: srcDir=" + srcDir + " files=" + (files != null ? java.util.Arrays.asList(files) : null) + " context=" + context);
254	return files;	258	return files;
255	} else {	259	} else {
Lines 295-300 Link Here
295	}	299	}
296	return null;	300	return null;
297	}	301	}
		302	@CheckForNull private FileObject[] findTestSourcesFOs(@NonNull Lookup context, boolean allowFolders, boolean strict) {
		303	TYPE: for (String testType : project.supportedTestTypes()) {
		304	FileObject testSrcDir = project.getTestSourceDirectory(testType);
		305	if (testSrcDir != null) {
		306	FileObject[] files = ActionUtils.findSelectedFiles(context, testSrcDir, null, strict);
		307	if (files != null) {
		308	for (FileObject file : files) {
		309	if (!(file.hasExt("java") \|\| allowFolders && file.isFolder())) {
		310	break TYPE;
		311	}
		312	}
		313	return files;
		314	}
		315	}
		316	}
		317	return null;
		318	}
298	@CheckForNull private TestSources findTestMethodSources(@NonNull Lookup context) {	319	@CheckForNull private TestSources findTestMethodSources(@NonNull Lookup context) {
299	SingleMethod meth = context.lookup(SingleMethod.class);	320	SingleMethod meth = context.lookup(SingleMethod.class);
300	if (meth != null) {	321	if (meth != null) {
Lines 328-339 Link Here
328		349
329	/** Find tests corresponding to selected sources.	350	/** Find tests corresponding to selected sources.
330	*/	351	*/
331	private TestSources findTestSourcesForSources(Lookup context) {	352	TestSources findTestSourcesForSources(Lookup context) {
332	String testType = "unit"; // NOI18N	353	String testType = "unit"; // NOI18N
333	FileObject[] sourceFiles = findSources(context);	354	FileObject[] sourceFiles = findSources(context);
334	if (sourceFiles == null) {	355	if (sourceFiles == null) {
		356	// no source file selected. try folders
		357	sourceFiles = findSources(context, true, true);
		358	if (sourceFiles == null) {
335	return null;	359	return null;
336	}	360	}
		361	}
337	FileObject testSrcDir = project.getTestSourceDirectory(testType);	362	FileObject testSrcDir = project.getTestSourceDirectory(testType);
338	if (testSrcDir == null) {	363	if (testSrcDir == null) {
339	return null;	364	return null;
Lines 347-357 Link Here
347	if (matches != null) {	372	if (matches != null) {
348	return new TestSources(matches, testType, testSrcDir, null);	373	return new TestSources(matches, testType, testSrcDir, null);
349	} else {	374	} else {
		375	// no test files found. The selected FOs must be folders under source packages
		376	ArrayList<FileObject> testFOs = new ArrayList<FileObject>();
		377	for (FileObject file : sourceFiles) {
		378	if (file.isFolder()) {
		379	String relativePath = FileUtil.getRelativePath(srcDir, file);
		380	if (relativePath != null && !relativePath.isEmpty()) {
		381	FileObject testFO = FileUtil.toFileObject(new File(FileUtil.toFile(testSrcDir).getPath().concat(File.separator).concat(relativePath)));
		382	if (testFO != null && testFO.getChildren().length != 0) {
		383	testFOs.add(testFO);
		384	}
		385	}
		386	}
		387	}
		388	if (testFOs.isEmpty()) {
350	return null;	389	return null;
351	}	390	}
		391	return new TestSources(testFOs.toArray(new FileObject[testFOs.size()]), testType, testSrcDir, null);
352	}	392	}
353	}	393	}
		394	}
354		395
		396	/** Find tests corresponding to selected files.
		397	* Selected files might be under Source and/or Test Packages
		398	*/
		399	@CheckForNull TestSources findTestSourcesForFiles(Lookup context) {
		400	String testType = "unit"; // NOI18N
		401	FileObject[] sourcesFOs = findSources(context, false, false);
		402	FileObject[] testSourcesFOs = findTestSourcesFOs(context, false, false);
		403	HashSet<FileObject> testFiles = new HashSet<FileObject>();
		404	FileObject testRoot = project.getTestSourceDirectory(testType);
		405	if (testRoot == null) {
		406	return null;
		407	}
		408	if (testSourcesFOs == null) {
		409	return findTestSources(context, true);
		410	} else {
		411	if (sourcesFOs == null) {
		412	return findTestSources(context, false);
		413	} else {
		414	testFiles.addAll(Arrays.asList(testSourcesFOs));
		415	//Try to find the test under the test roots
		416	FileObject srcRoot = project.getSourceDirectory();
		417	FileObject[] files2 = ActionUtils.regexpMapFiles(sourcesFOs, srcRoot, SRCDIRJAVA, testRoot, SUBST, true);
		418	if (files2 != null) {
		419	for (FileObject fo : files2) {
		420	if (!testFiles.contains(fo)) {
		421	testFiles.add(fo);
		422	}
		423	}
		424	}
		425	FileObject[] files2NG = ActionUtils.regexpMapFiles(sourcesFOs, srcRoot, SRCDIRJAVA, testRoot, SUBSTNG, true);
		426	if (files2NG != null) {
		427	for (FileObject fo : files2NG) {
		428	if (!testFiles.contains(fo)) {
		429	testFiles.add(fo);
		430	}
		431	}
		432	}
		433	}
		434	}
		435	return testFiles.isEmpty() ? null : new TestSources(testFiles.toArray(new FileObject[testFiles.size()]), testType, testRoot, null);
		436	}
		437
355	@Messages("MSG_no_source=No source to operate on.")	438	@Messages("MSG_no_source=No source to operate on.")
356	public void invokeAction(final String command, final Lookup context) throws IllegalArgumentException {	439	public void invokeAction(final String command, final Lookup context) throws IllegalArgumentException {
357	if (!canRunNoLock(command, project.getTestUserDirLockFile())) {	440	if (!canRunNoLock(command, project.getTestUserDirLockFile())) {
Lines 411-418 Link Here
411	TestSources testSources = findTestSourcesForSources(context);	494	TestSources testSources = findTestSourcesForSources(context);
412	if (testSources == null) {	495	if (testSources == null) {
413	testSources = findTestSources(context, true);	496	testSources = findTestSources(context, true);
414		497	if(testSources == null) {
		498	testSources = findTestSourcesForFiles(context);
415	}	499	}
		500	}
416	p.setProperty("continue.after.failing.tests", "true"); //NOI18N	501	p.setProperty("continue.after.failing.tests", "true"); //NOI18N
417	targetNames = setupTestSingle(p, testSources);	502	targetNames = setupTestSingle(p, testSources);
418	} else if (command.equals(COMMAND_DEBUG_TEST_SINGLE)) {	503	} else if (command.equals(COMMAND_DEBUG_TEST_SINGLE)) {




        assertEquals("null", String.valueOf(a.findTestSources(Lookups.fixed(oneTest, r), true)));
    }
    
    public void testFindTestSourcesForSources() throws Exception {
        NbModuleProject p = generateStandaloneModule("p");
        FileObject source = p.getSourceDirectory();
        FileObject one = FileUtil.createData(source, "p/One.java");
        FileObject r = FileUtil.createData(source, "p/r.png");
        FileObject other = FileUtil.createData(source, "p/Other.java");
        FileObject pkg = source.getFileObject("p");
        FileObject third = FileUtil.createData(source, "p2/Third.java");
        
        FileObject test = p.getTestSourceDirectory("unit");
        FileObject oneTest = FileUtil.createData(test, "p/OneTest.java");
        FileObject otherTest = FileUtil.createData(test, "p/OtherTest.java");
        FileObject thirdTest = FileUtil.createData(test, "p2/ThirdTest.java");
        
        ModuleActions a = new ModuleActions(p);
        assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookup.EMPTY)));
        assertEquals("unit:p/OneTest.java", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(one))));
        assertEquals("unit:p/OneTest.java,p/OtherTest.java", String.valueOf(a.findTestSourcesForSources(Lookups.fixed(one, other))));
        assertEquals("unit:p/**", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(pkg))));
        assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(r))));
        assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookups.fixed(one, r))));
        assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookup.EMPTY)));
        assertEquals("unit:p/OneTest.java", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(one))));
        assertEquals("unit:p/OneTest.java,p/OtherTest.java", String.valueOf(a.findTestSourcesForSources(Lookups.fixed(one, other))));
        assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(r))));
        assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookups.fixed(one, r))));
}

    public void testFindTestSourcesForFiles() throws Exception {
        NbModuleProject p = generateStandaloneModule("p");
        FileObject source = p.getSourceDirectory();
        FileObject one = FileUtil.createData(source, "p/One.java");
        FileObject r = FileUtil.createData(source, "p/r.png");
        FileObject other = FileUtil.createData(source, "p/Other.java");
        FileObject pkg = source.getFileObject("p");
        FileObject third = FileUtil.createData(source, "p2/Third.java");
        
        FileObject test = p.getTestSourceDirectory("unit");
        FileObject oneTest = FileUtil.createData(test, "p/OneTest.java");
        FileObject otherTest = FileUtil.createData(test, "p/OtherTest.java");
        FileObject thirdTest = FileUtil.createData(test, "p2/ThirdTest.java");
        
        ModuleActions a = new ModuleActions(p);
        assertEquals("null", String.valueOf(a.findTestSourcesForFiles(Lookup.EMPTY)));
        String actual = String.valueOf(a.findTestSourcesForFiles(Lookups.fixed(oneTest, other, third)));
        String testType = "unit";
        String expOne = "p/OneTest.java";
        String expOther = "p/OtherTest.java";
        String expThird = "p2/ThirdTest.java";
        assertTrue(actual.startsWith(testType.concat(":")));
        assertTrue(actual.contains(expOne));
        assertTrue(actual.contains(expOther));
        assertTrue(actual.contains(expThird));
        
        actual = String.valueOf(a.findTestSourcesForFiles(Lookups.fixed(one, otherTest)));
        assertTrue(actual.startsWith(testType.concat(":")));
        assertTrue(actual.contains(expOne));
        assertTrue(actual.contains(expOther));
    }
    
}

Lines 2368-2374 Link Here

(-)j2ee.clientproject/src/org/netbeans/modules/j2ee/clientproject/resources/build-impl.xsl (-1 / +1 lines)
2368	<target name="-do-test-run">	2368	<target name="-do-test-run">
2369	<xsl:attribute name="if">have.tests</xsl:attribute>	2369	<xsl:attribute name="if">have.tests</xsl:attribute>
2370	<xsl:attribute name="depends">init,compile-test,-pre-test-run</xsl:attribute>	2370	<xsl:attribute name="depends">init,compile-test,-pre-test-run</xsl:attribute>
2371	<carproject:test testincludes="*/Test.java"/>	2371	<carproject:test testincludes="*/Test.java" includes="${{includes}}"/>
2372	</target>	2372	</target>
2373		2373
2374	<target name="-post-test-run">	2374	<target name="-post-test-run">

Lines 2345-2351 Link Here

(-)j2ee.ejbjarproject/src/org/netbeans/modules/j2ee/ejbjarproject/resources/build-impl.xsl (-1 / +1 lines)
2345	<target name="-do-test-run">	2345	<target name="-do-test-run">
2346	<xsl:attribute name="if">have.tests</xsl:attribute>	2346	<xsl:attribute name="if">have.tests</xsl:attribute>
2347	<xsl:attribute name="depends">init,compile-test,-pre-test-run</xsl:attribute>	2347	<xsl:attribute name="depends">init,compile-test,-pre-test-run</xsl:attribute>
2348	<ejbjarproject2:test testincludes="*/Test.java"/>	2348	<ejbjarproject2:test testincludes="*/Test.java" includes="${{includes}}"/>
2349	</target>	2349	</target>
2350		2350
2351	<target name="-post-test-run">	2351	<target name="-post-test-run">




                if (targetNames == null) {
                    return;
                }
                final String command2execute;
                if(COMMAND_TEST_SINGLE.equals(command) && targetNames.length == 1 && targetNames[0].equals(COMMAND_TEST)) {
                    //multiple files or package(s) selected so we need to call test target instead of test-single
                    command2execute = COMMAND_TEST;
                    p.put("nb.internal.action.name", command2execute);
                } else {
                    command2execute = command;
                }
                if (isCompileOnSaveEnabled) {
                    if (COMMAND_BUILD.equals(command2execute) && !allowAntBuild()) {
                        showBuildActionWarning(context);
                        return ;
                    }
                    Map<String, Object> execProperties = new HashMap<String, Object>();
                    execProperties.put("nb.internal.action.name", command2execute);

                    copyMultiValue(ProjectProperties.RUN_JVM_ARGS, execProperties);
                    prepareWorkDir(execProperties);

                                String url = p.getProperty("applet.url");
                                execProperties.put("applet.url", url);
                                execProperties.put(JavaRunner.PROP_EXECUTE_FILE, file);
                                prepareSystemProperties(execProperties, command2execute, context, false);
                                task =
                                JavaRunner.execute(targetNames[0], execProperties);
                            }

                        }
                        return;
                    }
                    if (!isServerExecution() && (COMMAND_RUN.equals(command2execute) || COMMAND_DEBUG.equals(command2execute) || COMMAND_DEBUG_STEP_INTO.equals(command2execute) || COMMAND_PROFILE.equals(command2execute))) {
                        prepareSystemProperties(execProperties, command2execute, context, false);
                        AtomicReference<ExecutorTask> _task = new AtomicReference<ExecutorTask>();
                        bypassAntBuildScript(command2execute, context, execProperties, _task);
                        task = _task.get();
                        return ;
                    }
                    // for example RUN_SINGLE Java file with Servlet must be run on server and not locally
                    boolean serverExecution = p.getProperty(PROPERTY_RUN_SINGLE_ON_SERVER) != null;
                    p.remove(PROPERTY_RUN_SINGLE_ON_SERVER);
                    if (!serverExecution && (COMMAND_RUN_SINGLE.equals(command2execute) || COMMAND_DEBUG_SINGLE.equals(command2execute) || COMMAND_PROFILE_SINGLE.equals(command2execute))) {
                        prepareSystemProperties(execProperties, command2execute, context, false);
                        if (COMMAND_RUN_SINGLE.equals(command2execute)) {
                            execProperties.put(JavaRunner.PROP_CLASSNAME, p.getProperty("run.class"));
                        } else if (COMMAND_DEBUG_SINGLE.equals(command2execute)) {
                            execProperties.put(JavaRunner.PROP_CLASSNAME, p.getProperty("debug.class")); 
                        } else {
                            execProperties.put(JavaRunner.PROP_CLASSNAME, p.getProperty("profile.class"));
                        }
                        AtomicReference<ExecutorTask> _task = new AtomicReference<ExecutorTask>();
                        bypassAntBuildScript(command2execute, context, execProperties, _task);
                        task = _task.get();
                        return;
                    }
                    String buildDir = evaluator.getProperty(ProjectProperties.BUILD_DIR);
                    if (COMMAND_TEST_SINGLE.equals(command2execute) || COMMAND_DEBUG_TEST_SINGLE.equals(command2execute) || COMMAND_PROFILE_TEST_SINGLE.equals(command2execute)) {
                        @SuppressWarnings("MismatchedReadAndWriteOfArray")
                        FileObject[] files = findTestSources(context, true);
                        try {
                            prepareSystemProperties(execProperties, command2execute, context, true);
                            execProperties.put(JavaRunner.PROP_EXECUTE_FILE, files[0]);
                            if (buildDir != null) { // #211543
                                execProperties.put("tmp.dir", updateHelper.getAntProjectHelper().resolvePath(buildDir));
                            }
                            updateJavaRunnerClasspath(command2execute, execProperties);
                            task =
                            JavaRunner.execute(command2execute.equals(COMMAND_TEST_SINGLE) ? JavaRunner.QUICK_TEST : (COMMAND_DEBUG_TEST_SINGLE.equals(command2execute) ? JavaRunner.QUICK_TEST_DEBUG :JavaRunner.QUICK_TEST_PROFILE),
                                               execProperties);
                        } catch (IOException ex) {
                            Exceptions.printStackTrace(ex);
                        }
                        return;
                    }
                    if (SingleMethod.COMMAND_RUN_SINGLE_METHOD.equals(command2execute) || SingleMethod.COMMAND_DEBUG_SINGLE_METHOD.equals(command2execute)) {
                        SingleMethod methodSpec = findTestMethods(context)[0];
                        try {
                            execProperties.put("methodname", methodSpec.getMethodName());//NOI18N

                            if (buildDir != null) {
                                execProperties.put("tmp.dir",updateHelper.getAntProjectHelper().resolvePath(buildDir));
                            }
                            updateJavaRunnerClasspath(command2execute, execProperties);
                            task =
                            JavaRunner.execute(command2execute.equals(SingleMethod.COMMAND_RUN_SINGLE_METHOD) ? JavaRunner.QUICK_TEST : JavaRunner.QUICK_TEST_DEBUG,
                                                  execProperties);
                        } catch (IOException ex) {
                            Exceptions.printStackTrace(ex);

                        return;
                    }
                }
                collectStartupExtenderArgs(p, command2execute);
                Set<String> concealedProperties = collectAdditionalProperties(p, command2execute, context);
                if (targetNames.length == 0) {
                    targetNames = null;
                }
                if (isCompileOnSaveEnabled && !NO_SYNC_COMMANDS.contains(command2execute)) {
                    p.put("nb.wait.for.caches", "true");
                }
                final Callback cb = getCallback();

                        DialogDisplayer.getDefault().notify(nd);
                    } else {
                        if (cb2 != null) {
                            cb2.antTargetInvocationStarted(command2execute, context);
                        }
                        try {
                            task = ActionUtils.runTarget(buildFo, targetNames, p, concealedProperties);

                                        }
                                    } finally {
                                        if (cb2 != null) {
                                            cb2.antTargetInvocationFinished(command2execute, context, task.result());
                                        }
                                    }
                                }
                            });
                        } catch (IOException ex) {
                            if (cb2 != null) {
                                cb2.antTargetInvocationFailed(command2execute, context);
                            }
                            throw ex;
                        } catch (RuntimeException ex) {
                            if (cb2 != null) {
                                cb2.antTargetInvocationFailed(command2execute, context);
                            }
                            throw ex;
                        }

            targetNames = getCommands().get(command);
        } else if ( command.equals( COMMAND_TEST_SINGLE ) ) {
            p.setProperty("ignore.failing.tests", "true");  //NOI18N
            final FileObject[] files = findTestSourcesForFiles(context);
            if (files == null) {
                return null;
            }
            if(files.length == 1 && files[0].isData()) {
                //one file or a package containing one file selected
            targetNames = setupTestSingle(p, files);            
            } else {
                //multiple files or package(s) selected
                targetNames = setupTestFilesOrPackages(p, files);
            }
        } else if ( command.equals( COMMAND_DEBUG_TEST_SINGLE ) ) {
            final FileObject[] files = findTestSources(context, true);
            if (files == null) {

        return new String[] {"test-single"}; // NOI18N
    }

    private String[] setupTestFilesOrPackages(Properties p, FileObject[] files) {
        if (files != null) {
            FileObject root = getRoot(projectTestRoots.getRoots(), files[0]);
            p.setProperty("includes", ActionUtils.antIncludesList(files, root).replace("**", "**/*Test.java")); // NOI18N
        }
        return new String[]{"test"}; // NOI18N
    }

    private String[] setupDebugTestSingle(Properties p, FileObject[] files) {
        FileObject[] testSrcPath = projectTestRoots.getRoots();
        FileObject root = getRoot(testSrcPath, files[0]);

                    || findSourcesAndPackages( context, projectTestRoots.getRoots()) != null;
        }
        else if ( command.equals( COMMAND_TEST_SINGLE ) ) {
            FileObject[] fos = findTestSourcesForFiles(context);
            return fos != null;
        }
        else if ( command.equals( COMMAND_DEBUG_TEST_SINGLE ) ) {
            FileObject[] fos = findTestSources(context, true);

     */
    @org.netbeans.api.annotations.common.SuppressWarnings("PZLA_PREFER_ZERO_LENGTH_ARRAYS")
    private @CheckForNull FileObject[] findSources(Lookup context) {
        return findSources(context, true, false);
    }
    
    /**
     * Find selected source files
     *
     * @param context the lookup in which files should be found
     * @param strict if true, all files in the selection have to be accepted
     * @param findInPackages if true, all files under a selected package in the selection will also be checked
     */
    @org.netbeans.api.annotations.common.SuppressWarnings("PZLA_PREFER_ZERO_LENGTH_ARRAYS")
    private @CheckForNull FileObject[] findSources(Lookup context, boolean strict, boolean findInPackages) {
        FileObject[] srcPath = projectSourceRoots.getRoots();
        for (int i=0; i< srcPath.length; i++) {
            FileObject[] files = ActionUtils.findSelectedFiles(context, srcPath[i], findInPackages ? null : ".java", strict); // NOI18N
            if (files != null) {
                return files;
            }

     */
    @org.netbeans.api.annotations.common.SuppressWarnings("PZLA_PREFER_ZERO_LENGTH_ARRAYS")
    private @CheckForNull FileObject[] findTestSources(Lookup context, boolean checkInSrcDir) {
        return findTestSources(context, checkInSrcDir, true, false);
    }
    
    /**
     * Find selected tests and/or tests which belong to selected source files
     *
     * @param context the lookup in which files should be found
     * @param checkInSrcDir if true, tests which belong to selected source files will be searched for
     * @param strict if true, all files in the selection have to be accepted
     * @param findInPackages if true, all files under a selected package in the selection will also be checked
     */
    @org.netbeans.api.annotations.common.SuppressWarnings("PZLA_PREFER_ZERO_LENGTH_ARRAYS")
    private @CheckForNull FileObject[] findTestSources(Lookup context, boolean checkInSrcDir, boolean strict, boolean findInPackages) {
        //XXX: Ugly, should be rewritten
        FileObject[] testSrcPaths = projectTestRoots.getRoots();
        for (FileObject testSrcPath : testSrcPaths) {
            FileObject[] files = ActionUtils.findSelectedFiles(context, testSrcPath, findInPackages ? null : ".java", strict); // NOI18N
            ArrayList<FileObject> testFOs = new ArrayList<>();
            if (files != null) {
                for (FileObject file : files) {
                    if ((file.hasExt("java") || findInPackages && file.isFolder())) {
                        testFOs.add(file);
            }
        }
                return testFOs.toArray(new FileObject[testFOs.size()]);
            }
        }
        if (checkInSrcDir && testSrcPaths.length>0) {
            FileObject[] files = findSources (context, strict, findInPackages);
            if (files != null) {
                //Try to find the test under the test roots
                FileObject srcRoot = getRoot(projectSourceRoots.getRoots(),files[0]);
                for (FileObject testSrcPath : testSrcPaths) {
                    FileObject[] files2 = ActionUtils.regexpMapFiles(files, srcRoot, SRCDIRJAVA, testSrcPath, SUBST, strict);
                    if (files2 != null) {
                        return files2;
                    }
                    FileObject[] files2NG = ActionUtils.regexpMapFiles(files, srcRoot, SRCDIRJAVA, testSrcPath, SUBSTNG, strict);
                    if (files2NG != null) {
                        return files2NG;
                    }
                }
                // no test files found. The selected FOs must be folders under source packages
                files = ActionUtils.findSelectedFiles(context, srcRoot, findInPackages ? null : ".java", strict); // NOI18N
                ArrayList<FileObject> testFOs = new ArrayList<>();
                if (files != null) {
                    for (FileObject file : files) {
                        if (findInPackages && file.isFolder()) {
                            String relativePath = FileUtil.getRelativePath(srcRoot, file);
                            if (relativePath != null) {
                                for (FileObject testSrcPath : testSrcPaths) {
                                    FileObject testFO = FileUtil.toFileObject(new File(FileUtil.toFile(testSrcPath).getPath().concat(File.separator).concat(relativePath)));
                                    if (testFO != null) {
                                        testFOs.add(testFO);
            }
        }
                            }
                        }
                    }
                    return testFOs.toArray(new FileObject[testFOs.size()]);
                }
            }
        }
        return null;
    }

    /**
     * Find selected tests and tests which belong to selected source files
     * when package(s) or multiple files are selected.
     *
     * @param context the lookup in which files should be found
     */
    @org.netbeans.api.annotations.common.SuppressWarnings("PZLA_PREFER_ZERO_LENGTH_ARRAYS")
    private @CheckForNull FileObject[] findTestSourcesForFiles(Lookup context) {
        FileObject[] sourcesFOs = findSources(context, false, true);
        FileObject[] testSourcesFOs = findTestSources(context, false, false, true);
        HashSet<FileObject> testFiles = new HashSet<>();
        if(testSourcesFOs == null) {
            return findTestSources(context, true, false, true);
        } else {
            if(sourcesFOs == null) {
                return testSourcesFOs;
            } else {
                testFiles.addAll(Arrays.asList(testSourcesFOs));
                //Try to find the test under the test roots
                FileObject srcRoot = getRoot(projectSourceRoots.getRoots(),sourcesFOs[0]);
                for (FileObject testRoot : projectTestRoots.getRoots()) {
                    FileObject[] files2 = ActionUtils.regexpMapFiles(sourcesFOs, srcRoot, SRCDIRJAVA, testRoot, SUBST, true);
                    if (files2 != null) {
                        for (FileObject fo : files2) {
                            if(!testFiles.contains(fo)) {
                                testFiles.add(fo);
                            }
                        }
                    }
                    FileObject[] files2NG = ActionUtils.regexpMapFiles(sourcesFOs, srcRoot, SRCDIRJAVA, testRoot, SUBSTNG, true);
                    if (files2NG != null) {
                        for (FileObject fo : files2NG) {
                            if(!testFiles.contains(fo)) {
                                testFiles.add(fo);
                            }
                        }
                    }
                }
            }
        }
        return testFiles.isEmpty() ? null : testFiles.toArray(new FileObject[testFiles.size()]);
    }

    /**
     * Finds single method specification objects corresponding to JUnit test

Lines 2397-2403 Link Here

(-)java.j2seproject/src/org/netbeans/modules/java/j2seproject/resources/build-impl.xsl (-1 / +1 lines)
2397	<target name="-do-test-run">	2397	<target name="-do-test-run">
2398	<xsl:attribute name="if">have.tests</xsl:attribute>	2398	<xsl:attribute name="if">have.tests</xsl:attribute>
2399	<xsl:attribute name="depends">init,compile-test,-pre-test-run</xsl:attribute>	2399	<xsl:attribute name="depends">init,compile-test,-pre-test-run</xsl:attribute>
2400	<j2seproject3:test testincludes="*/Test.java"/>	2400	<j2seproject3:test testincludes="*/Test.java" includes="${{includes}}"/>
2401	</target>	2401	</target>
2402		2402
2403	<target name="-post-test-run">	2403	<target name="-post-test-run">

Lines 75-77 Link Here

(-)java.project/src/org/netbeans/spi/java/project/support/ui/Bundle.properties (+4 lines)
75	ACSD_excludesLabel=Excludes pattern	75	ACSD_excludesLabel=Excludes pattern
76	ACSN_IncludeExcludeVisualizerPanel=Include Exclude Panel	76	ACSN_IncludeExcludeVisualizerPanel=Include Exclude Panel
77	ACSD_IncludeExcludeVisualizerPanel=Include and Exclude patterns for project	77	ACSD_IncludeExcludeVisualizerPanel=Include and Exclude patterns for project
		78
		79	# Name of package action
		80	# {0} - # of selected packages
		81	LBL_TestPackageAction_Name=T&est {0,choice,0#Package\|1#Package\|1<Packages}




import org.openide.util.Exceptions;
import org.openide.util.ImageUtilities;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.NbBundle.Messages;
import org.openide.util.RequestProcessor;
import org.openide.util.WeakListeners;

    private final RequestProcessor.Task visibility_refresh;
    private FileChangeListener wfcl;    // Weak listener on the system filesystem
    private ChangeListener wvqcl;       // Weak listener on the VisibilityQuery
    private final Action testPackageAction;

    /**
     * Creates children based on a single source root.

        
        // Sem mas dat cache a bude to uplne nejrychlejsi na svete
        names2nodes = Collections.synchronizedMap(new TreeMap<String,Object>());
        testPackageAction = FileSensitiveActions.fileCommandAction(ActionProvider.COMMAND_TEST_SINGLE, NbBundle.getMessage(PackageViewChildren.class, "LBL_TestPackageAction_Name"), null);
        this.root = group.getRootFolder();
        this.group = group;
        visibility_refresh = VISIBILITY_CHANGE_RP.create(new Runnable() {

                        else if ( superActions[i] instanceof FileSystemAction ) {
                            actionList.add (null); // insert separator and new action
                            actionList.add (FileSensitiveActions.fileCommandAction(ActionProvider.COMMAND_COMPILE_SINGLE, LBL_CompilePackage_Action(), null));                           
                            actionList.add (testPackageAction);
                            actionList.addAll((List<Action>) org.openide.util.Utilities.actionsForPath("Projects/package/Actions"));
                        }
                        




package org.netbeans.modules.maven.execute;

import java.io.File;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;

import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.modules.maven.NbMavenProjectImpl;
import org.netbeans.modules.maven.api.NbMavenProject;
import org.netbeans.modules.maven.classpath.MavenSourcesImpl;
import org.netbeans.modules.maven.configurations.M2ConfigProvider;

import org.openide.filesystems.URLMapper;
import org.openide.loaders.DataObject;
import org.openide.util.Lookup;
import org.openide.util.Utilities;

/**
 *

                    assert rel != null;
                    String pkg = rel.replace('/', '.');
                    if (!pkg.isEmpty()) {
                        packClassname.append(pkg).append(".**."); // test everything under this package recusively
                    }
                    packClassname.append("*");
                    if (ActionProvider.COMMAND_TEST_SINGLE.equals(actionName) || ActionProvider.COMMAND_DEBUG_TEST_SINGLE.equals(actionName)) {

                    }
                }
            }
        } else { 
            // not all of the selected files are under one source root, so maybe they were
            // selected from both source and test packages and "Test Files" action was invoked on them?
            if (ActionProvider.COMMAND_TEST_SINGLE.equals(actionName)) {
                HashSet<String> test = new HashSet<String>();
                addSelectedFiles(false, fos, test);
                addSelectedFiles(true, fos, test);
                String files2test = test.toString().replace(" ", "");
                packClassname.append(files2test.substring(1, files2test.length() - 1));
        }
        }
        if (packClassname.length() > 0) { //#213671
            replaceMap.put(PACK_CLASSNAME, packClassname.toString());
        }

        return replaceMap;
    }

    private void addSelectedFiles(boolean testRoots, FileObject[] candidates, HashSet<String> test) {
        NbMavenProjectImpl prj = project.getLookup().lookup(NbMavenProjectImpl.class);
        if (prj != null) {
            URI[] roots = prj.getSourceRoots(testRoots);
            for (URI uri : roots) {
                FileObject root = FileUtil.toFileObject(Utilities.toFile(uri));
                for (FileObject candidate : candidates) {
                    String relativePath = FileUtil.getRelativePath(root, candidate);
                    if (relativePath != null) {
                        if (testRoots) {
                            relativePath = relativePath.replace(".java", "").replace('/', '.'); //NOI18N
                        } else {
                            relativePath = relativePath.replace(".java", "Test").replace('/', '.'); //NOI18N
                        }
                        test.add(relativePath);
                    }
                }
            }
        }
    }

    /** Finds the one source group, if any, which contains all of the listed files. */
    private static @CheckForNull SourceGroup findGroup(SourceGroup[] groups, FileObject[] files) {
        SourceGroup selected = null;

Lines 80-88 Link Here

(-)projectui/src/org/netbeans/modules/project/ui/actions/Bundle.properties (-1 / +3 lines)
80	LBL_RunMainProjectAction_Name=&Run {0,choice,-1#Main Project\|0#Project\|1#Project ({1})\|1<{0} Projects}	80	LBL_RunMainProjectAction_Name=&Run {0,choice,-1#Main Project\|0#Project\|1#Project ({1})\|1<{0} Projects}
81		81
82		82
		83	# Name of 1-off actions
		84	# {0} - # of selected files
83	LBL_RunSingleAction_Name=Run &File	85	LBL_RunSingleAction_Name=Run &File
84	# {0,choice,0#File\|1#"{1}"\|1<Files}	86	# {0,choice,0#File\|1#"{1}"\|1<Files}
85	LBL_TestSingleAction_Name=T&est File	87	LBL_TestSingleAction_Name=T&est {0,choice,0#File\|1#File\|1<Files}
86	#{0,choice,0#File\|1#"{1}"\|1<Files}	88	#{0,choice,0#File\|1#"{1}"\|1<Files}
87		89
88	# OpenProject.java	90	# OpenProject.java

Lines 2665-2671 Link Here

(-)web.project/src/org/netbeans/modules/web/project/resources/build-impl.xsl (-1 / +1 lines)
2665	<target name="-do-test-run">	2665	<target name="-do-test-run">
2666	<xsl:attribute name="if">have.tests</xsl:attribute>	2666	<xsl:attribute name="if">have.tests</xsl:attribute>
2667	<xsl:attribute name="depends">init,compile-test,-pre-test-run</xsl:attribute>	2667	<xsl:attribute name="depends">init,compile-test,-pre-test-run</xsl:attribute>
2668	<webproject2:test testincludes="*/Test.java"/>	2668	<webproject2:test testincludes="*/Test.java" includes="${{includes}}"/>
2669	</target>	2669	</target>
2670		2670
2671	<target name="-post-test-run">	2671	<target name="-post-test-run">

Return to bug 124313

Lines 103-106 Link Here

(-)apisupport.ant/test/unit/src/org/netbeans/modules/apisupport/project/ui/ModuleActionsTest.java (+60 lines)
103	assertEquals("null", String.valueOf(a.findTestSources(Lookups.fixed(oneTest, r), true)));	103	assertEquals("null", String.valueOf(a.findTestSources(Lookups.fixed(oneTest, r), true)));
104	}	104	}
105		105
		106	public void testFindTestSourcesForSources() throws Exception {
		107	NbModuleProject p = generateStandaloneModule("p");
		108	FileObject source = p.getSourceDirectory();
		109	FileObject one = FileUtil.createData(source, "p/One.java");
		110	FileObject r = FileUtil.createData(source, "p/r.png");
		111	FileObject other = FileUtil.createData(source, "p/Other.java");
		112	FileObject pkg = source.getFileObject("p");
		113	FileObject third = FileUtil.createData(source, "p2/Third.java");
		114
		115	FileObject test = p.getTestSourceDirectory("unit");
		116	FileObject oneTest = FileUtil.createData(test, "p/OneTest.java");
		117	FileObject otherTest = FileUtil.createData(test, "p/OtherTest.java");
		118	FileObject thirdTest = FileUtil.createData(test, "p2/ThirdTest.java");
		119
		120	ModuleActions a = new ModuleActions(p);
		121	assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookup.EMPTY)));
		122	assertEquals("unit:p/OneTest.java", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(one))));
		123	assertEquals("unit:p/OneTest.java,p/OtherTest.java", String.valueOf(a.findTestSourcesForSources(Lookups.fixed(one, other))));
		124	assertEquals("unit:p/**", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(pkg))));
		125	assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(r))));
		126	assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookups.fixed(one, r))));
		127	assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookup.EMPTY)));
		128	assertEquals("unit:p/OneTest.java", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(one))));
		129	assertEquals("unit:p/OneTest.java,p/OtherTest.java", String.valueOf(a.findTestSourcesForSources(Lookups.fixed(one, other))));
		130	assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookups.singleton(r))));
		131	assertEquals("null", String.valueOf(a.findTestSourcesForSources(Lookups.fixed(one, r))));
106	}	132	}
		133
		134	public void testFindTestSourcesForFiles() throws Exception {
		135	NbModuleProject p = generateStandaloneModule("p");
		136	FileObject source = p.getSourceDirectory();
		137	FileObject one = FileUtil.createData(source, "p/One.java");
		138	FileObject r = FileUtil.createData(source, "p/r.png");
		139	FileObject other = FileUtil.createData(source, "p/Other.java");
		140	FileObject pkg = source.getFileObject("p");
		141	FileObject third = FileUtil.createData(source, "p2/Third.java");
		142
		143	FileObject test = p.getTestSourceDirectory("unit");
		144	FileObject oneTest = FileUtil.createData(test, "p/OneTest.java");
		145	FileObject otherTest = FileUtil.createData(test, "p/OtherTest.java");
		146	FileObject thirdTest = FileUtil.createData(test, "p2/ThirdTest.java");
		147
		148	ModuleActions a = new ModuleActions(p);
		149	assertEquals("null", String.valueOf(a.findTestSourcesForFiles(Lookup.EMPTY)));
		150	String actual = String.valueOf(a.findTestSourcesForFiles(Lookups.fixed(oneTest, other, third)));
		151	String testType = "unit";
		152	String expOne = "p/OneTest.java";
		153	String expOther = "p/OtherTest.java";
		154	String expThird = "p2/ThirdTest.java";
		155	assertTrue(actual.startsWith(testType.concat(":")));
		156	assertTrue(actual.contains(expOne));
		157	assertTrue(actual.contains(expOther));
		158	assertTrue(actual.contains(expThird));
		159
		160	actual = String.valueOf(a.findTestSourcesForFiles(Lookups.fixed(one, otherTest)));
		161	assertTrue(actual.startsWith(testType.concat(":")));
		162	assertTrue(actual.contains(expOne));
		163	assertTrue(actual.contains(expOther));
		164	}
		165
		166	}

Lines 99-104 Link Here

(-)java.project/src/org/netbeans/spi/java/project/support/ui/PackageViewChildren.java (+4 lines)
99	import org.openide.util.Exceptions;	99	import org.openide.util.Exceptions;
100	import org.openide.util.ImageUtilities;	100	import org.openide.util.ImageUtilities;
101	import org.openide.util.Lookup;	101	import org.openide.util.Lookup;
		102	import org.openide.util.NbBundle;
102	import org.openide.util.NbBundle.Messages;	103	import org.openide.util.NbBundle.Messages;
103	import org.openide.util.RequestProcessor;	104	import org.openide.util.RequestProcessor;
104	import org.openide.util.WeakListeners;	105	import org.openide.util.WeakListeners;
Lines 133-138 Link Here
133	private final RequestProcessor.Task visibility_refresh;	134	private final RequestProcessor.Task visibility_refresh;
134	private FileChangeListener wfcl; // Weak listener on the system filesystem	135	private FileChangeListener wfcl; // Weak listener on the system filesystem
135	private ChangeListener wvqcl; // Weak listener on the VisibilityQuery	136	private ChangeListener wvqcl; // Weak listener on the VisibilityQuery
		137	private final Action testPackageAction;
136		138
137	/**	139	/**
138	* Creates children based on a single source root.	140	* Creates children based on a single source root.
Lines 142-147 Link Here
142		144
143	// Sem mas dat cache a bude to uplne nejrychlejsi na svete	145	// Sem mas dat cache a bude to uplne nejrychlejsi na svete
144	names2nodes = Collections.synchronizedMap(new TreeMap<String,Object>());	146	names2nodes = Collections.synchronizedMap(new TreeMap<String,Object>());
		147	testPackageAction = FileSensitiveActions.fileCommandAction(ActionProvider.COMMAND_TEST_SINGLE, NbBundle.getMessage(PackageViewChildren.class, "LBL_TestPackageAction_Name"), null);
145	this.root = group.getRootFolder();	148	this.root = group.getRootFolder();
146	this.group = group;	149	this.group = group;
147	visibility_refresh = VISIBILITY_CHANGE_RP.create(new Runnable() {	150	visibility_refresh = VISIBILITY_CHANGE_RP.create(new Runnable() {
Lines 757-762 Link Here
757	else if ( superActions[i] instanceof FileSystemAction ) {	760	else if ( superActions[i] instanceof FileSystemAction ) {
758	actionList.add (null); // insert separator and new action	761	actionList.add (null); // insert separator and new action
759	actionList.add (FileSensitiveActions.fileCommandAction(ActionProvider.COMMAND_COMPILE_SINGLE, LBL_CompilePackage_Action(), null));	762	actionList.add (FileSensitiveActions.fileCommandAction(ActionProvider.COMMAND_COMPILE_SINGLE, LBL_CompilePackage_Action(), null));
		763	actionList.add (testPackageAction);
760	actionList.addAll((List<Action>) org.openide.util.Utilities.actionsForPath("Projects/package/Actions"));	764	actionList.addAll((List<Action>) org.openide.util.Utilities.actionsForPath("Projects/package/Actions"));
761	}	765	}
762		766

Lines 43-48 Link Here

(-)maven/src/org/netbeans/modules/maven/execute/DefaultReplaceTokenProvider.java (-1 / +35 lines)
43	package org.netbeans.modules.maven.execute;	43	package org.netbeans.modules.maven.execute;
44		44
45	import java.io.File;	45	import java.io.File;
		46	import java.net.URI;
46	import java.net.URL;	47	import java.net.URL;
47	import java.util.ArrayList;	48	import java.util.ArrayList;
48	import java.util.Collection;	49	import java.util.Collection;
Lines 60-65 Link Here
60	import org.netbeans.api.project.ProjectUtils;	61	import org.netbeans.api.project.ProjectUtils;
61	import org.netbeans.api.project.SourceGroup;	62	import org.netbeans.api.project.SourceGroup;
62	import org.netbeans.api.project.Sources;	63	import org.netbeans.api.project.Sources;
		64	import org.netbeans.modules.maven.NbMavenProjectImpl;
63	import org.netbeans.modules.maven.api.NbMavenProject;	65	import org.netbeans.modules.maven.api.NbMavenProject;
64	import org.netbeans.modules.maven.classpath.MavenSourcesImpl;	66	import org.netbeans.modules.maven.classpath.MavenSourcesImpl;
65	import org.netbeans.modules.maven.configurations.M2ConfigProvider;	67	import org.netbeans.modules.maven.configurations.M2ConfigProvider;
Lines 75-80 Link Here
75	import org.openide.filesystems.URLMapper;	77	import org.openide.filesystems.URLMapper;
76	import org.openide.loaders.DataObject;	78	import org.openide.loaders.DataObject;
77	import org.openide.util.Lookup;	79	import org.openide.util.Lookup;
		80	import org.openide.util.Utilities;
78		81
79	/**	82	/**
80	*	83	*
Lines 170-176 Link Here
170	assert rel != null;	173	assert rel != null;
171	String pkg = rel.replace('/', '.');	174	String pkg = rel.replace('/', '.');
172	if (!pkg.isEmpty()) {	175	if (!pkg.isEmpty()) {
173	packClassname.append(pkg).append('.');	176	packClassname.append(pkg).append(".**."); // test everything under this package recusively
174	}	177	}
175	packClassname.append("*");	178	packClassname.append("*");
176	if (ActionProvider.COMMAND_TEST_SINGLE.equals(actionName) \|\| ActionProvider.COMMAND_DEBUG_TEST_SINGLE.equals(actionName)) {	179	if (ActionProvider.COMMAND_TEST_SINGLE.equals(actionName) \|\| ActionProvider.COMMAND_DEBUG_TEST_SINGLE.equals(actionName)) {
Lines 222-228 Link Here
222	}	225	}
223	}	226	}
224	}	227	}
		228	} else {
		229	// not all of the selected files are under one source root, so maybe they were
		230	// selected from both source and test packages and "Test Files" action was invoked on them?
		231	if (ActionProvider.COMMAND_TEST_SINGLE.equals(actionName)) {
		232	HashSet<String> test = new HashSet<String>();
		233	addSelectedFiles(false, fos, test);
		234	addSelectedFiles(true, fos, test);
		235	String files2test = test.toString().replace(" ", "");
		236	packClassname.append(files2test.substring(1, files2test.length() - 1));
225	}	237	}
		238	}
226	if (packClassname.length() > 0) { //#213671	239	if (packClassname.length() > 0) { //#213671
227	replaceMap.put(PACK_CLASSNAME, packClassname.toString());	240	replaceMap.put(PACK_CLASSNAME, packClassname.toString());
228	}	241	}
Lines 250-255 Link Here
250	return replaceMap;	263	return replaceMap;
251	}	264	}
252		265
		266	private void addSelectedFiles(boolean testRoots, FileObject[] candidates, HashSet<String> test) {
		267	NbMavenProjectImpl prj = project.getLookup().lookup(NbMavenProjectImpl.class);
		268	if (prj != null) {
		269	URI[] roots = prj.getSourceRoots(testRoots);
		270	for (URI uri : roots) {
		271	FileObject root = FileUtil.toFileObject(Utilities.toFile(uri));
		272	for (FileObject candidate : candidates) {
		273	String relativePath = FileUtil.getRelativePath(root, candidate);
		274	if (relativePath != null) {
		275	if (testRoots) {
		276	relativePath = relativePath.replace(".java", "").replace('/', '.'); //NOI18N
		277	} else {
		278	relativePath = relativePath.replace(".java", "Test").replace('/', '.'); //NOI18N
		279	}
		280	test.add(relativePath);
		281	}
		282	}
		283	}
		284	}
		285	}
		286
253	/** Finds the one source group, if any, which contains all of the listed files. */	287	/** Finds the one source group, if any, which contains all of the listed files. */
254	private static @CheckForNull SourceGroup findGroup(SourceGroup[] groups, FileObject[] files) {	288	private static @CheckForNull SourceGroup findGroup(SourceGroup[] groups, FileObject[] files) {
255	SourceGroup selected = null;	289	SourceGroup selected = null;