TS 60Eclipse ProjectImport

Eclipse Project Importer Test Specification for NetBeans 6.0

Author: Tomas Bilka
Lastupdate: 31.07.2007
Introduction: Eclipse Project Importer adds ability to import projects from Eclipse IDE into NetBeans IDE. Currently only Eclipse in versions 3.0 and above is supported.
(plugins installed to the Eclipse should have no affect to imported java projects, altought recommended settings is pluginless Eclipse installation)
Following test specifications were written according to UI specification ver 1.1.5.
In general this test specification is trying to verify overall behaviour (installation, UI behaviour and ability to import Eclipse project) of Project Importer module.
Comments: You can download a set of sample tests projects (created in eclipse 3.1.2 ), used to perform all tests cases from this test-spec. Structure of downloaded folder is as follow: eclipseTestArea -> ws -> workspace (here are located "inside workspace" tests projects) , eclipseTestArea -> outofws (for "standalone" projects), eclipseTestArea -> test2, this folder is used for one specific test case (namely for external source code location).
Note that you may need to change path to your JDK/JRE platform in some projects. Also follow steps in tests cases to modify projects appropiate way if needed.

Contents


Test suite: Installation

Purpose: Suite to verify if it is possible to install our precious Project Import modul from autoupdate center (or manually downloaded nbm) to the NB.

  1. Installation from autoupdate center
    • Setup: Required NB without Project Importer modul installed.
    1. Start IDE with clear userdir.
    2. Invoke Tools | Update center and select "Check the web for available Updates and New Moduls" radio button, check "Netbeans Update Center" checkbox (don't forget setup apropriate proxy server, e.g. webcache.czech:8080) and press Next button.
    3. Select Features | Eclipse Project Importer module press Add button, module will appear in "Include for install" field, press Next button.
    4. Accept licence and wait untill modul is downloaded and installed and press Next button
    5. Check both checkboxes (for global and include) and press Finish button.
    • EXPECTED RESULT: New menu item must appear in File menu -> Import Eclipse Project. After invoking this menu item, Eclipse Importer main window must appear.
  1. Uninstalaltion
    • Setup: Required NB with Project Importer module installed.
    1. Remove previously installed Project Importer module. (Tools | Module manager select Infrastructure -> Eclipse Project Importer and press uninstall;
    • EXPECTED RESULT: There should be no "Import Eclipse Project.. " menu item in File menu
  1. Manual installation
    • Setup: Required NB without Project Importer modul installed.
    1. Start IDE with clear userdir.
    2. Download org-netbeans-modules-projectimport.nbm from here
    3. Invoke Tools | Update center and select "Install manually downloaded modules (.nbm Files)." radio button and press Next button.
    4. Push Add button and browse org-netbeans-modules-projectimport.nbm file and press Next button.
    5. Select Eclipse Project Importer module as Include for install and press Next button.
    6. Wait until modul is downloaded and installed and press Next button
    7. Check both checkboxes (for global and include) and press Finish button.
    • EXPECTED RESULT: New menu item must appear in File menu -> Import Eclipse Project. After invoking this menu item Improter main window must appear.


Test suite: UI behaviour

Purpose: This suite is trying to verify UI behaviour of Project Importer modul - buttons, labels, checkboxes, module dependencies visibility etc.
Setup: Netbeans module for Project Importing must be sucessfully installed.
There must be created Eclipse workspace (Eclipse version 3.0+) on your hard drive with at least projects in it. At least one project must be dependent on others two and one project must be depend on other project, which is depend on other project.
Or you can download such a set of (a very simple) Eclipse projects (created in Eclipse 3.1.2), see additional info, and unzip this file somewhere on your HD.

  1. Workspace selection
    1. Invoke File | Import Project | Eclipse Project .. menu item.
      R: Import Eclipse Project main window must be modal. All buttons (but Cancel button) are implicitly disabled. Radion button Import Project from Workspace is implicitly selected and corresponding text field (with bound browse button) is empty and enabled. Project import and Destination folder text fields (with bound browse buttons) are implicitly disabled.
    2. Browse some random directory (which doesn't contain Eclipse workspace)
      R: All buttons (but Cancel button and Browse button bound with Import projects from Workspace) are disabled. Message that your directory doesn't contain Eclipse workspace must appear.
    3. Browse directory with proper Eclipse workspace. (or one you unziped in Setup step)
      R: Next button is enabled.
    4. Press Next button.
    • EXPECTED RESULT: All projects bound to workspace you've selected must appear in window - all unchecked. Only enabled buttons are Back and Cancel. Browse button and browse field for location of Netbeans Projects are visible and enabled.
  1. Project(s) selection
    1. Select one from listed project(s) and browse "Netbeans Project Location" to dir that contains project with same name as selected.
      R: Button Finish remains disabled and message that such a project allready exists in selected "Netbeans Projects" location.
    2. Browse "Netbeans Project Location" to empty dir.
      R: Button Finish is enabled.
    3. Unselect selected project.
      R: Button Finish is disabled.
    4. Select project with dependencies (for unziped workspace it is TS2_sample_MainBA in "ws->workspace" dir )
      R: Button Finish is enabled. Dependent projects are also selected and marked grey without posibility to be unselected.
      (for our workspace is automatically selected TS2_sample_PrjA and TS2_sample_PrjB)
    5. Unselect selected project.
      R: All projects are unselected, even those dependent ones. User can select any project again.
    6. Select some project with chain dependencies (one project depends on other, which depends on another one) (for our workspace its TS2_sample_MainCA dependent on TS2_samplePrjCA dependent on TS2_sample_PrjA)
      R: Project is selected, dependent ones are selected, greyed, and user is not able unselect dependent ones. (for our workspace TS2_samplePrjCA, TS2_sample_PrjA are greyed)
    7. Press Back button.
    • EXPECTED RESULT: Importing selected project window with progress bar appears. After sucessfull import are all importer windows closed and imported project(s) is(are) opened in NetBeans.
  1. Standalone project selection
    1. Select Import Project Ignoring Project dependencies radion button
      R: Text fields Project to Import and Destionation folder (with bound browse buttons) are enabled. Text field Import Project from Workspace (with bound browse button) is disabled.
    2. Browse some random directory (make sure it doesn't contain regular Eclipse project) to Project Import.
      R: Message that selected directory doesn't contain Eclipse project must appear. Button next is disabled.
    3. Select directory that contains regular Eclipse project. (you can use TS5_sample06_IntSrc from our test workspace)
      R: Message about nonregular Eclipse project disappears but Finish button remains disabled because user haven't choose valid destination path.
    4. Select valid empty directory to Destination Path text field.
      R: Finish button is enabled.
    5. Press Finish button.
    • EXPECTED RESULT: Project is successfuly imported and standard NB project is created in specified location, project is opened in IDE.

Teardown: Close all previously opened projects in Netbeans.

Test suite: General import rules

Purpose: Verifies if any Eclipse project is imported as specified in UI spec (no src files copied, standard NB project structure created, platform import..) and verifies general rules for importing Eclipse project. \ If there is specified no exception in further suites, all projects must be imported this way.
Imports means that user will be able to work with imported projects in the same manner as with newly created projects. Complete NetBeans Java Project structure will be created.
Setup: Netbeans module for Project Importing must be sucessfully installed. You can download a set of sample projects. See additional info.

  1. General project import
    1. Create basic Standard Java Eclipse project in clear workspace.
      Requirements:
    • create this project INSIDE Eclipse workspace
    • as Eclipse JRE use default platform from NB (usually JDKx.y.z)
    • create at least one class in default package (don't create any packages)
    • project must be compilable/runnable under Eclipse (you can use TS2_samplePrjA from our test workspace)
    1. Invoke command File | Import Project | Eclipse Project
    2. Push Next button
    3. Browse proper Eclipse workspace (or the one you have unziped from attached zip file)
    4. Select proper project from your workspace (or select TS2_sample_PrjA if you are using test workspace)
    5. Browse empty dir as NB Project Location
    6. Push Finish button
      R:
    • Your project (TS2_samplePrjA) must be sucessfully imported and opened in Netbeans.
    • Only one Library (default platform) is bound with this project. (check that Eclipse and Netbeans are bound to the same JDK platform)
    • Project have only one package (default package) with all sources created in Eclipse.
    • Sources are taken from same directory where Eclipse created em. (NB didn't create any copies of this sources) and that's why in Files view there are 2 views for this project (one with NB project structure and output dir for class/jar files and another bound to Eclipse project structure)
    • Project is compilable and runnable under NB.
    1. Browse Netbeans Project Location specified in Project Importer.
    • EXPECTED RESULT: Standard NB project structure must be created in this location (at least project name with build.xml and nbproject).
  1. Non Java project import
    1. Create non-Java project in eclipse workspace.
      (you can use TS3_sample02_NonJavaPrj from our test workspace)
    2. Invoke command File | Import Project | Eclipse Project
    3. Push Next button
    4. Browse proper Eclipse workspace
    5. Try select proper non-java project from your workspace.
    • EXPECTED RESULT: Non-java project is visible in Importer main window. User is not able select non-java project.

Teardown: Close all imported project(s) in NetBeans.

Test suite: Workspace project Import

Purpose: Verify if any standard Eclipse Java Project located in proper Eclipse workspace can be succesesfuly imported to the NetBeans IDE (e.g. Eclipse platforms, variables, libraries, dependent projects are improted and interpreted correctly).
Last step in each Test Case is to import created project -> that means select item Eclipse Project Importe from File main menu, browse apropriate workspace, select apropriate project and import it to clear directory.
Setup: Netbeans module for Project Importing must be sucessfully installed. You can download a set of sample projects. See additional info.

  1. JDK Import
    1. Requirements: You should have at least 2 different JDK's installed.
    2. Create new Eclipse Standard Java Project. (or you can use TS4_sample-multi_JDKimp from our test workspace)
    3. As standard JRE System library choose one of installed JDK (Project Properties | Java Build Path | Libraries | JRE System Library -> Edit)
    4. Create new Class A with method main.
      R: Project is compilable and runnable under Eclipse.
    5. Import such a project to NB.
      R: Project is compilable/runnable under NB and its default platform is same as specified in Eclipse.
      (check project | Properties | Libraries | Java Platform -> Manage Platforms)
    6. Change JRE System Library in Eclipse project to another JDK (jdk 1.6 for example)
    7. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable/runnable under NB and its default platform is same as specified in Eclipse.(jdk 1.6.0)
      (check project
  2. Unknown JDK Import
    1. Create new Eclipse Standard Java Project. (or you can use TS4_sample-multi_JDKimp from our test workspace)
    2. As standard JRE System library choose one of installed JDK (Project Properties | Java Build Path | Libraries | JRE System Library -> Edit)
    3. Create new Class A with method main.
      R:Project is compilable and runnable under Eclipse.
    4. Make sure platform chosen in step 2 is not valid anymore (uninstall or move it to new location).
    5. Import such a project to NB.
      R: Project is NOT compilable in NB. Platoform is marked as "Broken", user must resolve problems. User is warned about problems after importing of Eclipse project.
    6. Resolve problems (either move back suitable JDK or choose standard platform as project plaform).
    • EXPECTED RESULT: Project is compilable/runnable in NB.
  1. Undefined JDK Import
    1. Create new Eclipse Standard Java Project. (or you can use TS4_sample-multi_JDKimp from our test workspace)
    2. As standard JRE System library choose one of installed JDK which is not defined in Netbeans as platform. (jdk 1.4.1)
      (Project Properties | Java Build Path | Libraries | JRE System Library -> Edit)
    3. Create new Class A with method main.
      R: Project is compilable and runnable under Eclipse.
    4. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable/runnable in NB. Non existing platoform is automatically created as valid NB Java Platform and chosen as Java Platform for this particular project.
  1. JRE Import
    1. Requirements: You should have at least 2 different JRE's and 1 JDK installed.
    2. Create new Eclipse Standard Java Project. (or you can use TS4_sample-multi_JDKimp from our test workspace)
    3. As standard JRE System library choose one of installed JRE (Project Properties | Java Build Path | Libraries | JRE System Library -> Edit) and as Eclipse Java Builder choose their internal builder. (Project Properties | Java Build Path | Builders | JavaBuilder -> enabled
    4. Create new Class A with method main.
      R: Project is compilable and runnable under Eclipse.
    5. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable/runnable in NB. User is warned that JRE is not valid NB Platform and that's why as valiad platform is used Default Platform.
  1. Double JDK/JRE Import
    1. Requirements: You should have at least 2 different JDK's and 1 JRE installed.
    2. Create new Eclipse Standard Java Project. (or you can use TS4_sample-multi_JDKimp from our test workspace)
    3. As standard JRE System library choose one of installed JDK (Project Properties | Java Build Path | Libraries | JRE System Library -> Edit) and add another JRE (or JDK) as secondary JRE library. (Project Properties | Java Build Path | Libraries | Add library | JRE System Libraryt).
    4. Create new Class A with method main.
      R: Project is compilable and runnable under Eclipse.
    5. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable/runnable in NB. There is only one java platoform defined for this project. (1st one selected in Eclipse, in case 1st one was JRE, then default platform is used).
  1. Internal src roots
    1. Create new Eclipse Standard Java Project. (or you can use TS4_sample06_IntSrc from our test workspace).
    • Create separated source and output folders.
    • as JRE System Library use suitable JDK
    • add new Source folder "test" on same level as folders "src" and "bin"
    • create new package "a" in "src" folder
    • create new package "b" in "src" folder
    • create new package "b.c" in "src" folder
    • create new package "d.e.f" in "test" folder
    • create new class "A" in package "a" with method main
    • create new class "B" in package "b"
    • create new class "C' in package "b.c"
    • create new class "F" in package "d.e.f"
    • add code to A.main() for creating instances of classes B,C,F
    • add apropriate imports to class A (import b.B, import b.c.C, import d.e.f.F)
      R:Project is compilable and runnable in Eclipse.
    1. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable and runnable in NB. Structure of all internal sources is imported to the NB as well. There are visible 3 packages (project, project_src, project_test) in Files view.
  1. External src roots
    1. Open same project as in previous testcase in Eclipse.
    2. Add external source folder "test2" (Properties | Java Build Path | Source | Add Folder | Create New Folder | Advanced | Link to the folder in file system) created outside project directory.
    3. Create new package "external" in source folder "test2".
    4. Create new class "X" in package "External".
    5. Add to the clas A to the method main () creating of new instance of class X. (X x = new X();)
      R: Project is compilable and runnable in Eclipse.
      (or you can use TS4_sample07_ExtSrc from our test workspace).
    6. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable and runnable in NB. Structure of all internal sources is imported to the NB as well. There are visible 4 packages (project, project_src, project_test, project_test2) in Files view. In projects view check properties of "test2" source folder -> should point to the same location as specified in Eclipse.
  1. Project outside workspace
    1. Create new Eclipse Standard Java Project. (or you can use TS5_sample06_IntSrc from our standalone projects location , i.e. eclipseTestArea -> outofws ) as project at Extenral location (browse some other directory but your workspace).
    2. In project create same class/package structure as in testcase "Internal src roots".
      R:Project is compilable and runnable in Eclipse.
    • EXPECTED RESULT: Project is compilable and runnable in NB. Structure of all external sources is imported to the NB as well. There are visible 3 packages (external_path_to_project,external_path_to_ project_src,external_path_to_ project_test) in Files view.
  1. Internal jars
    1. Create new Eclipse Standard Java Project. (or you can use TS4_sample09_IntJar from our test workspace).
    2. Add some internal jars to this project. (Properties | Java Build Path | Libraries | Add Jars)
      (or you can use xTest.jar located in eclipseTestArea -> ws -> workspace -> SamplePrj)
    3. Create new class with main method which invokes some classes/methods from bounded jar file.
      PrjMain InstPrjMain = new PrjMain();
      InstPrjMain.callPrjMain();
      R: Project is compilable and runnable in Eclipse.
    4. Import such a project to NB.
    • EXPECTED RESULT: Project is runnable/compilable in NB. Internal jar appears in Project view
  1. External jars
    1. Create new Eclipse Standard Java Project. (or you can use TS4_sample10_ExtJar from our test workspace).
    2. Add some external jars to this project. (Properties | Java Build Path | Libraries | Add External Jars)
      (or you can use SamplePrj.jar)
    3. Create new class with main method which invokes some classes/methods from bounded jar file.
      PrjMain InstPrjMain = new PrjMain();
      InstPrjMain.callPrjMain();
      R: Project is compilable and runnable in Eclipse.
    4. Import such a project to NB.
    • EXPECTED RESULT: Project is runnable/compilable in NB. Internal jar appears in Project view
  1. Classpath variables
    1. Create new Eclipse Standard Java Project. (or you can use TS4_sample11_ClsPth from our test workspace).
    2. Add new variable bound with file.
      (Properties | Java Build Path | Libraries | Add Variable | Configure Variables | New and create new variable bound with some jar file)
      (for example variable var bound with SamplePrj.jar)
    3. Create new class with main method which invokes some classes/methods from bounded jar file.
      R: Project is compilable and runnable in Eclipse.
    4. Import such a project to NB.
      R: In newly imported project (Project view) expand Libraries node - it must contain imported Eclipse System variable (for our example src.zip)
    5. Add new variable bound with jar file.
      (Properties | Java Build Path | Libraries | Add Variable | Configure Variables | New and create for example "var" bound with file SamplePrj.jar)
    6. Import such a project to NB.
      R: In newly imported project (Project view) expand Libraries node - it must contain imported variable (for our example SamplePrj.jar)
    7. Add new variable bound with jar folder with jars/zips.
      (Properties | Java Build Path | Libraries | Add Variable | Configure Variables | New | Folder browse some dir with jars/zips (for example "libs" bound with folder filled with SamplePrj.jar Select this variable | Extend it and choose which jars/zips shall be added (SamplePrj.jar).
    8. Import such a project to NB.
    • EXPECTED RESULT: In newly imported project (Project view) expand Libraries node - it must contain imported variable (for our example SamplePrj.jar).Project must be compilable and runnable in NB.
  1. User libs
    1. Create new Eclipse Standard Java Project. (or you can use TS4_sample13_UsrLibs from our test workspace).
    2. Create new User Library
      (Properties | Java Build Path | Libraries | Add Library | User Library | Next | User Libraries | New specify name "user_lib" select it and Add Jar SamplePrj.jar from this .zip file)
    3. Create new class with main method which invokes some classes/methods from bounded jar file.
      R: Project is compilable and runnable in Eclipse.
    4. Import such a project to NB.
    • EXPECTED RESULT: In newly imported project (Project view) expand Libraries node - it must contain imported user libraries (for our example SamplePrj.jar). Project must be compilable and runnable in NB.
  1. Plugin dependencies
    • EXPECTED RESULT: tbd


Test suite: Standalone project import

Purpose: Verifies if standalone project created in Eclipse can be also properly imported to the NB. (without requiring proper Eclipse workspace).
Setup: Netbeans module for Project Importing must be sucessfully installed. You can download a set of sample projects. See additional info.

  1. JDK Import standalone
    1. Requirements: You should have at least 2 different JDK's installed.
    2. Create new Eclipse Standard Java Project. (or you can use project TS5_sample-multi_JDKimp from eclipseTestArea -> outofws location, more info about sample projects)
    3. As standard JRE System library choose one of installed JDK ;(Project Properties | Java Build Path | Libraries | JRE System Library -> Edit)
    4. Create new Class A with method main.
      R: Project is compilable and runnable under Eclipse.
    5. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    6. Import such a project to NB.
      R: Project is compilable/runnable under NB and its default platform is same as specified in Eclipse.
      (check project | Properties | Libraries | Java Platform -> Manage Platforms)
    7. Change JRE System Library in Eclipse project to another JDK (jdk 1.6 for example)
    8. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable/runnable under NB and its default platform is same as specified in Eclipse.(jdk 1.6.0)
      (check project
  1. Unknown JDK Import standalone
    1. Create new Eclipse Standard Java Project. (or you can use

project TS5_sample-multi_JDKimp from eclipseTestArea -> outofws folder)

    1. As standard JRE System library choose one of installed JDK

(Project Properties | Java Build Path | Libraries | JRE System Library -> Edit)

    1. Create new Class A with method main.
      R:Project is compilable and runnable under Eclipse.
    2. Make sure platform chosen in step 2 is not valid anymore (uninstall or move it to new location).
    3. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    4. Import such a project to NB.
      R: Project is NOT compilable in NB. Platoform is marked as "Broken", user must resolve problems. User is warned about problems after importing of Eclipse project.
    5. Resolve problems (either move back suitable JDK or choose standard platform as project plaform).
    • EXPECTED RESULT: Project is compilable/runnable in NB.
  1. Undefined JDK Import standalone
    1. Create new Eclipse Standard Java Project. (or you can use project TS5_sample-multi_JDKimp from eclipseTestArea -> outofws folder)
    2. As standard JRE System library choose one of installed JDK which is not defined in Netbeans as platform. (jdk 1.4.1) (Project Properties | Java Build Path | Libraries | JRE System Library -> Edit)
    3. Create new Class A with method main.
      R: Project is compilable and runnable under Eclipse.
    4. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    5. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable/runnable in NB. Non existing platoform is automatically created as valid NB Java Platform and chosen as Java Platform for this particular project.
  2. JRE Import standalone
    1. Requirements: You should have at least 2 different JRE's and 1 JDK installed.
    2. Create new Eclipse Standard Java Project. (or you can use you can use project TS5_sample-multi_JDKimp from eclipseTestArea -> outofws folder)
    3. As standard JRE System library choose one of installed JRE (Project Properties | Java Build Path | Libraries | JRE System Library -> Edit) and as Eclipse Java Builder choose their internal builder. (Project Properties | Java Build Path | Builders | JavaBuilder -> enabled
    4. Create new Class A with method main.
      R: Project is compilable and runnable under Eclipse.
    5. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    6. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable/runnable in NB. User is warned that JRE is not valid NB Platform and that's why as valiad platform is used Default Platform.
  1. Double JDK/JRE Import standalone
    1. Requirements: You should have at least 2 different JDK's and 1 JRE installed.
    2. Create new Eclipse Standard Java Project. (or you can use project TS5_sample-multi_JDKimp from eclipseTestArea -> outofws folder)
    3. As standard JRE System library choose one of installed JDK (Project Properties | Java Build Path | Libraries | JRE System Library -> Edit) and add another JRE (or JDK) as secondary JRE library.

(Project Properties | Java Build Path | Libraries | Add library | JRE System Libraryt).

    1. Create new Class A with method main.
      R:Project is compilable and runnable under Eclipse.
    2. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    3. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable/runnable in NB. There is only one java platoform defined for this project. (1st one selected in Eclipse, in case 1st one was JRE, then default platform is used).
  1. Internal src roots standalone
    1. Create new Eclipse Standard Java Project. (or you can use project TS5_sample06_IntSrc from eclipseTestArea -> outofws folder)
    • Create separated source and output folders.
    • as JRE System Library use suitable JDK
    • add new Source folder "test" on same level as folders "src" and "bin"
    • create new package "a" in "src" folder
    • create new package "b" in "src" folder
    • create new package "b.c" in "src" folder
    • create new package "d.e.f" in "test" folder
    • create new class "A" in package "a" with method main
    • create new class "B" in package "b"
    • create new class "C' in package "b.c"
    • create new class "F" in package "d.e.f"
    • add code to A.main() for creating instances of classes B,C,F
    • add apropriate imports to class A (import b.B, import b.c.C, import d.e.f.F)
      R:Project is compilable and runnable in Eclipse.
    1. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    2. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable and runnable in NB. Structure of all internal sources is imported to the NB as well. There are visible 3 packages (project, project_src, project_test) in Files view.
  1. External src roots standalone
    1. Open same project as in previous testcase in Eclipse.
    2. Add external source folder "test2" (Properties | Java Build Path | Source | Add Folder | Create New Folder | Advanced | Link to the folder in file system) created outside project directory.
    3. Create new package "external" in source folder "test2".
    4. Create new class "X" in package "External".
    5. Add to the clas A to the method main () creating of new instance of class X. (new ClassX();)
      R: Project is compilable and runnable in Eclipse.
    6. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    7. Import such a project to NB.
    • EXPECTED RESULT: Project is compilable and runnable in NB. Structure of all internal sources is imported to the NB as well. There are visible 4 packages (project, project_src, project_test, project_test2) in Files view. In projects view check properties of "test2" source folder -> should point to the same location as specified in Eclipse.
  2. Internal jars standalone
    1. Create new Eclipse Standard Java Project. (or you can use project TS5_sample08_IntJar from eclipseTestArea -> outofws folder)
    2. Add some internal jars to this project. (Properties | Java Build Path | Libraries | Add Jars)
      (or you can use sampleJar.jar from eclipseTestArea -> outofws -> TS5_sample-multi_Jar folder)
    3. Create new class with main method which invokes some classes/methods from bounded jar file.
      JarMain x = new JarMain();
      x.callJarMain();
      R:Project is compilable and runnable in Eclipse.
    4. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    5. Import such a project to NB.
    • EXPECTED RESULT: Project is runnable/compilable in NB. Internal jar appears in Project view
  1. External jars standalone
    1. Create new Eclipse Standard Java Project. (or you can use project TS5_sample09_ExtJar from eclipseTestArea -> outofws folder)
    2. Add some external jars to this project. (Properties | Java Build Path | Libraries | Add External Jars)
      (or you can use sampleJar.jar from eclipseTestArea -> outofws -> TS5_sample-multi_Jar folder)
    3. Create new class with main method which invokes some classes/methods from bounded jar file.
      JarMain x = new JarMain();
      x.callJarMain();
      R: Project is compilable and runnable in Eclipse.
    4. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    5. Import such a project to NB.
    • EXPECTED RESULT: Project is runnable/compilable in NB. Internal jar appears in Project view
  1. Classpath variables standalone
    1. Create new Eclipse Standard Java Project. (or you can use project TS5_sample10_ClsPth from eclipseTestArea -> outofws folder)
    2. Add new variable bound with file.
      (Properties | Java Build Path | Libraries | Add Variable | Configure Variables | New and create new variable bound with some jar file)
      (for example variable var bound with sampleJar.jar)
    3. Create new class with main method which invokes some classes/methods from bounded jar file.
      R: Project is compilable and runnable in Eclipse.
    4. Import such a project to NB.
      R: In newly imported project (Project view) expand Libraries node - it must contain imported Eclipse System variable (for our example src.zip)
    5. Add new variable bound with jar file.
      (Properties | Java Build Path | Libraries | Add Variable | Configure Variables | New and create for example "var" bound with filesampleJar.jar)
    6. Import such a project to NB.
      R: In newly imported project (Project view) expand Libraries node - it must contain imported variable (for our example samplejar.jar)
    7. Add new variable bound with jar folder with jars/zips.
      (Properties | Java Build Path | Libraries | Add Variable | Configure Variables | New | Folder browse some dir with jars/zips (for example "libs" bound with folder TS5_sample-multi_Jar filled with sampleJar.jar Select this variable | Extend it and choose which jars/zips shall be added (sampleJar.jar).
    8. Make sure such a project is located out of Eclipse workspace (and Eclipse workspace itself is not available).
    9. Import such a project to NB.
    • EXPECTED RESULT: In newly imported project (Project view) expand Libraries node - it must contain imported variable (for our example sampleJar.jar).Project must be compilable and runnable in NB.


Test suite: Import eclipse test projects

Purpose: To show full compatability bunch of examples from book about Eclipse is beeing imported to the NB.
Setup: Netbeans module for Project Importing must be sucessfully installed. You can download a set of sample projects. See additional info.

  1. Eclipse test projects import
    1. Import all Eclipse test projects located in workspace (folder eclipseTestArea -> ws -> workspace)
    • EXPECTED RESULT: All projects must be sucessfuly imported to the NB, opened, compilable and runnable.

}}
}}

Not logged in. Log in, Register

By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2012, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo