TS 74 Git

Git Support Test Specification for NetBeans 7.4

Author: Martin Kanak
Version: 1.0
Last update: 2.7.2013
Introduction: Git open source tool is one of the supported version control systems in the IDE. This document describes how Git support module should be tested in order to know whether all of its functionality works correctly.
Comments: This document is heavily based on TS_73_Git which is now obsolete.

Contents


Test suite: Initiating/Cloning a new project

Purpose: Tests whether is it possible to initialize a new repository and clone from an existing repository.
Setup: IDE with activated Git module. Repositories configured for tested access methods, containing some NB projects.

  1. Initialize repository in a new project
    1. Invoke File | New Project... from main menu. "New Project" wizard shows up.
    2. In the first step of the wizard select "Java" category and "Java Application" project. Push Next > button.
    3. In the second step of the wizard enter "GitTestLocal" into the "Project Name" field and "gittestlocal.Main" into the "Create Main Class" field.
    4. Keep all other fields default and push Finish button.
    5. Invoke popup menu on the created project's root node in the "Projects" view. Select Versioning | Initialize Git Repository action. "Initialize a Git Repository" dialog shows up.
    6. In the dialog, verify that correct path to the "GitTestLocal" project folder is specified in the "Root path" field and push OK button.
    • EXPECTED RESULT: Git repository is initialized in the "GitTestLocal" project folder. Git actions are now available from popup menu and main menu. Versioning states of project files are visualy represented as on attached pictures:
      Projects view Files view
  2. Clone using file:/// method
    1. Invoke Team | Git | Clone... from main menu. "Clone Repository" wizard shows up.
    2. In the first step of the wizard use Browse... button next to "Repository URL" field to find and select your local repository.
    3. Push Next > button. In the second step of the wizard verify that "master" branch is ticked.
    4. Push Next > button. In the third step of the wizard use Browse... button next to "Parent Directory" field to select a directory for your clone. Enter desired "Clone Name", verify values of "Checkout Branch" and "Remote Name".
    5. Push Finish button. Click Open Project in the following dialog.
    • EXPECTED RESULT: Repository is cloned and any valid NetBeans project from the repository is opened in "Projects" view. Git actions are now available from popup menu and main menu for those projects.
  3. Clone using git:// method
    1. Invoke Team | Git | Clone... from main menu. "Clone Repository" wizard shows up.
    2. Switch to "Repository URL" field and set it to your valid repository with "git://" connection type (e.g. "git://localhost/repo.git/").
    3. Push Next > button. In the second step of the wizard verify that "master" branch is ticked.
    4. Push Next > button. In the third step of the wizard use Browse... button next to "Parent Directory" field to select a directory for your clone. Enter desired "Clone Name", verify values of "Checkout Branch" and "Remote Name".
    5. Push Finish button. Click Open Project in the following dialog.
    • EXPECTED RESULT: Repository is cloned and any valid NetBeans project from the repository is opened in "Projects" view. Git actions are now available from popup menu and main menu for those projects.
  4. Clone using ssh:// method
    1. Invoke Team | Git | Clone... from main menu. "Clone Repository" wizard shows up.
    2. Switch to "Repository URL" field and set it to your valid repository with "ssh://" connection type (e.g. "ssh://host.mycomcany.com/git/repo/").
    3. After setting up "ssh://" connection type there should be visible "User", "Password" and "Proxy Configuration..." components.
    4. Setup username and password and verify functionality of "Save Password" checkbox and "Proxy Configuration..." button. (Alternatively use a key)
    5. Push Next > button. Click Yes to accept server fingerprint if pop-up dialog shows up. Next step of "Clone Repository" wizard with "Select Remote Branches" field shows up. Select desired branch.
    6. Push Next > button to proceed to the third step. Set "Parent Directory" using Browse... button. Enter desired "Clone Name", verify values of "Checkout Branch" and "Remote Name".
    7. Push Finish button. Click Open Project in the following dialog.
    • EXPECTED RESULT: Repository is cloned and any valid NetBeans project from the repository is opened in "Projects" view. Git actions are now available from popup menu and main menu for those projects.
  5. Clone using sftp:// method
    1. Invoke Team | Git | Clone... from main menu. "Clone Repository" wizard shows up.
    2. Switch to "Repository URL" field and set it to your valid repository with "sftp://" connection type (e.g. "sftp://host.mycomcany.com/git/repo/").
    3. After setting up "sftp://" connection type there should be visible "User", "Password" and "Proxy Configuration..." components.
    4. Setup username and password and verify functionality of "Save Password" checkbox and "Proxy Configuration..." button.
    5. Push Next > button. Next step of "Clone Repository" wizard with "Select Remote Branches" field shows up. Select desired branch.
    6. Push Next > button to proceed to the third step. Set "Parent Directory" using Browse... button. Enter desired "Clone Name", verify values of "Checkout Branch" and "Remote Name".
    7. Push Finish button. Click Open Project in the following dialog.
    • EXPECTED RESULT: Repository is cloned and any valid NetBeans project from the repository is opened in "Projects" view. Git actions are now available from popup menu and main menu for those projects.
  6. Clone using http:// method
    1. Invoke Team | Git | Clone... from main menu. "Clone Repository" wizard shows up.
    2. Switch to "Repository URL" field and set it to your valid repository with "http://" connection type (e.g. "http://localhost/repo.git/").
    3. After setting up "http://" connection type there should be visible "User", "Password" and "Proxy Configuration..." components.
    4. Setup username and password and verify functionality of "Save Password" checkbox and "Proxy Configuration..." button.
    5. Push Next > button. Next step of "Clone Repository" wizard with "Select Remote Branches" field shows up. Select desired branch.
    6. Push Next > button to proceed to the third step. Set "Parent Directory" using Browse... button. Enter desired "Clone Name", verify values of "Checkout Branch" and "Remote Name".
    7. Push Finish button. Click Open Project in the following dialog.
    • EXPECTED RESULT: Repository is cloned and any valid NetBeans project from the repository is opened in "Projects" view. Git actions are now available from popup menu and main menu for those projects.
  7. Clone using https:// method
    1. Invoke Team | Git | Clone... from main menu. "Clone Repository" wizard shows up.
    2. Switch to "Repository URL" field and set it to your valid repository with "https://" connection type (e.g. "https://localhost/repo.git/").
    3. After setting up "https://" connection type there should be visible "User", "Password" and "Proxy Configuration..." components.
    4. Setup username and password and verify functionality of "Save Password" checkbox and "Proxy Configuration..." button.
    5. Push Next > button. Next step of "Clone Repository" wizard with "Select Remote Branches" field shows up. Select desired branch.
    6. Push Next > button to proceed to the third step. Set "Parent Directory" using Browse... button. Enter desired "Clone Name", verify values of "Checkout Branch" and "Remote Name".
    7. Push Finish button. Click Open Project in the following dialog.
    • EXPECTED RESULT: Repository is cloned and any valid NetBeans project from the repository is opened in "Projects" view. Git actions are now available from popup menu and main menu for those projects.

Test suite: Basic tasks

Purpose: Test all actions used during editing files - add, commit, diff, reset, revert, export patch, apply patch. Test correct behavior of editor and all views. Test functionality of Git, Diff and Conflicts Resolver window. Verify contents of Output window.
Setup: IDE with activated Git module. Opened "GitTestLocal" project from previous test suite. Initial commit must be performed on this project prior to start of the first test case.

  1. "Git" window
    1. Select the project root node in "Projects" view and invoke Git | Show Changes pop-up menu action.
    • EXPECTED RESULT: "Git" window is opened. Message
      <No Head/Working Tree Changes>
      should be shown there.
  2. "Output" window
    1. Select the project root node in "Projects" view and invoke Team | Open Output main menu action.
    • EXPECTED RESULT: "Output" window is opened. Project name and location is shown in the window/tab header. Window should contain output from last Git action performed on this project.
  3. File modifying
    1. Find a double-click "Main.java" file in "Projects" view to open it in the editor.
    2. Insert brand-new line somewhere into the file.
    3. Delete some other line, but not directly next to the new line.
    4. Modify another line, but not directly next to the lines mentioned above, and save the file.
    • EXPECTED RESULT: For each modification, there should be a diff mark on the left side and a navigation mark on the right side of the editor. New lines are green, modified are blue, deleted are red. The file is shown in the "Git" window with "-/Modified" status. The file "Main.java" must change its font color to blue in the editor header, "Git" window and in all views. Nodes in the path to the file are marked with blue badges in all views.
  4. File creating
    1. Create new Java class "NewClass.java" file in the main package.
    • EXPECTED RESULT: File is created and opened into editor. The file is shown in the "Git" window with "-/Added" status. The file has green font color in the editor header, "Git" window and in all views. Nodes in the path to the file are marked with blue badges in all views.
  5. Diff sidebar
    1. Switch off View | Show Diff Sidebar option from main menu.
    2. Switch View | Show Diff Sidebar back on.
    • EXPECTED RESULT: When option is switched off, all diff marks and navigation marks in the editor should disappear. When turned back on, all marks should reappear again.
  6. Versioning labels
    1. Switch on View | Show Versioning Labels option from main menu.
    • EXPECTED RESULT: When switched on, versioning labels should be shown in "Projects", "Files" and "Favorites" views. Next to the project root, there should be a branch name (e.g. [master]). Next to the "Main.java", there should be [-/M], and next to the "NewClass.java", ther should be [-/A].
  7. Add
    1. Select "Main.java" in "Projects" view and invoke Git | Add pop-up menu action.
    2. Select "NewClass.java" in "Git" window and invoke Add pop-up menu action.
    • EXPECTED RESULT: Both files are staged. Their status in "Git" window changes to "Modified/-" for "Main.java" and "Added/-" for "NewClass.java". Versioning labels changes to [M/-] and [A/-] respectively. Colors, marks and badges remains the same. "Output" window contains details about performed Add actions.
  8. Commit
    1. Select the project root node in "Projects" view and invoke Team | Commit... main menu action. "Commit" dialog shows up.
    2. Files "Main.java" and "NewClass.java" should be listed in a table. Enter some "Commit Message" and modify "Author" and "Committer".
    3. Click Commit button.
    • EXPECTED RESULT: Commit is performed. Details can be reviewed in the "Output" window. All diff marks in the editor disappear. Both files disappear from "Git" window. All colors change back to black, all badges and modification labels disappear.
  9. Commit amend
    1. Select the project root node in "Projects" view and invoke Team | Show History main menu action.
    2. "Show History" tab is displayed, push the Search button
    3. You can see a list of changes that you committed in previous steps and also the "Commit Message"
    4. Select the project root node in "Projects" view and invoke Team | Commit... main menu action. "Commit" dialog shows up.
    5. Check "Amend Last Commit" checkbox, enter "Commit Message" (enter different message than before) and push the Commit button
    6. Switch to the "Show History" tab and push the Search button again
    • EXPECTED RESULT: Verify that there is no new change in the history list, number of changes is same as before the amend commit. Verify that the last commit message was changed.
  10. Diff
    1. Make all types of changes (add, modify, remove) to both "Main.java" and "NewClass.java" and save them.
    2. Create new Java interface "NewInterface.java" in the main package.
    3. Select the project root node in "Projects" view and invoke Team | Diff .
    • EXPECTED RESULT: "Diff" window is opened. It lists both modified and one created file. All changes to the currently selected file are shown in a split pane. On the left there is the HEAD/Index state and on the right there is the Working Tree state. Right part is editable, left part isn't. Arrows can be used to navigate among files and their differences.
  11. Files differences in commit dialog
    1. Select e.g. "Main.java" file, modify it on two different lines.
    2. Select the project root and invoke Team | Show Changes from main menu.
    3. File should be listed in "Git" tab - "Main.java" as "-/Modified"
    4. In "Git" tab push "Commit All" icon
    5. In the commit dialog, which appears, double click on the file, that you modified
    • EXPECTED RESULT: New diff tab in commit dialog is displayed. Verify functionality of "UP" and "DOWN" arrows. (Arrows navigate among all differences in processed file). Verify results displayed in both "Graphical" and "Textual" representation of Diff tab.
  12. Export Patch
    1. Select the project root node in "Projects" view and invoke Team | Patches | Export Uncommitted Changes... main menu action. "Export Diff Patch" dialog shows up.
    2. Keep "Save as File" option selected and use "Browse..." button to select file location and name. Confirm it by pushing Save button.
    3. Push OK button.
    • EXPECTED RESULT: Patch file is created in the selected location and opened into editor.
  13. Simple Revert
    1. Select the project root node in "Projects" view and invoke Team | Revert | Revert Modifications... main menu action. "Revert Modifications in ..." dialog shows up.
    2. Keep "Revert Uncommitted Changes Both in Working Tree and Index" option selected, tick "Remove Also New Files and Folders" checkbox.
    3. Push Revert button.
    • EXPECTED RESULT: All uncommitted changes are reverted and newly created files removed. Details can be reviewed in the "Output" window. All diff marks in the editor disappear. All files disappear from "Git" window. All colors change back to black, all badges and modification labels disappear.
  14. Apply Patch
    1. Select the project root node in "Projects" view and invoke Tools | Apply Diff Patch... . File browser shows up.
    2. Find and select the previously created patch file and push Patch button.
    3. Click Yes button in the following question dialog.
    • EXPECTED RESULT: Patch is successfully applied. Details can be reviewed in the "Output" window/tab named "Patch Report". Diff windows are opened for all patched files. Files are shown exactly as before revert.
  15. Export Commit
    1. Commit all previously made changes.
    2. Select the project root node in "Projects" view and invoke Team | Patches | Export Commit... . "Export Diff" dialog shows up.
    3. Push Select button next to "Revision" field. "Select Revision" dialog shows up. Select the last revision you just committed and push Select.
    4. Keep "Save as File" option selected and use "Browse..." button to select file location and name. Confirm it by pushing Save button.
    5. Push OK button.
    • EXPECTED RESULT: Patch file with changes from selected revision is created in the selected location and opened into editor. "Output" window contains details about performed Export action.
  16. Revert Commit without change commit
    1. Select the project root node in "Projects" view and invoke Team | Revert | Revert Commit... main menu action. "Revert Commit" dialog shows up.
    2. Push Select button next to "Revision" field. "Select Revision" dialog shows up. Select the last revision and push Select.
    3. Untick "Commit Revert Changes" checkbox. "Commit Message" text field should disappear.
    4. Push Revert button.
    • EXPECTED RESULT: Changes from selected revision are reverted. Details can be reviewed in the "Output" window. Affected files should have their changes and statuses marked accordingly and should be staged.
  17. Revert Commit with automatic change commit
    1. Revert all uncommited changes.
    2. Select the project root node in "Projects" view and invoke Team | Revert | Revert Commit... main menu action. "Revert Commit" dialog shows up.
    3. Push Select button next to "Revision" field. "Select Revision" dialog shows up. Select the last revision and push Select.
    4. Keep "Commit Revert Changes" checkbox ticked. Leave "Commit Message" text field empty.
    5. Push Revert button.
    • EXPECTED RESULT: Changes from selected revision are reverted and the new state is commited. Details can be reviewed in the "Output" window. New commit is visible in Git History.
  18. Ignore file
    1. Create a new java file in the main class of the project.
    2. Select the file in "Projects" view and invoke Team | Ignore main menu action.
    • EXPECTED RESULT: The file font color changes to gray in the editor header and in all views. The .gitignore file is created if not already present and a new entry for the file is added.
  19. Unignore file
    1. Commit the .gitignore changes from previous test case.
    2. Select the file in "Projects" view and invoke Git | Unignore pop-up menu action.
    • EXPECTED RESULT: File status changes to "-/Added". The file font color changes to green in the editor header and in all views. The .gitignore entry is removed.
  20. Exlclude from commit
    1. Select the newly created file in "Projects" view and invoke Team | Exclude From Commit main menu action.
    2. Select the project root node in "Projects" view and invoke Team | Commit... main menu action. "Commit - {projectname}" dialog shows up.
    • EXPECTED RESULT: The dialog should contain the modified .gitignore and the newly created java file. The java file is strikethroughed and it's "Commit Action" is set to "Exclude from Commit".
  21. Include in commit
    1. Finish the commit form the previous test case. The new java file should still have "-/Added" status.
    2. Select the file in "Projects" view and invoke Git | Include In Commit pop-up menu action.
    3. Select the project root node in "Projects" view and invoke Git | Commit... pop-up menu action. "Commit - {projectname}" dialog shows up.
    4. In the dialog, verify that "Commit Action" for the java file is "Commit" and push the Commit button.
    • EXPECTED RESULT: The file is successfully committed.
  22. Delete File
    1. In "Projects" view select some java file and invoke Delete pop-up menu action.
    2. Push OK button in the following dialog to finish the deletion.
    • EXPECTED RESULT: File should disappear from all views. It should appear in "Git" window with "Deleted/-" status.
  23. Undelete File
    1. Select the project root node in "Projects" view and invoke Team | Revert | Revert Modifications... main menu action. "Revert Modifications in ..." dialog shows up.
    2. Verify "Revert Uncommitted Changes Both in Working Tree and Index" option is selected and push Revert.
    • EXPECTED RESULT: File should reappear in all views and it should disappear from the "Git" window.
  24. Refactor Rename file
    1. In "Projects" view, select the "Main.java" file node and invoke Refactor | Rename... pop-up menu action on it.
    2. Enter a new name for the file and push Refactor.
    3. Commit all changes.
    • EXPECTED RESULT: After the rename, status of the file is "Renamed/Modified". In "Git" window, also the file with the original name is visible vith "Deleted/-" status. Additionally, "project.properties" file is modified with the new main class name. After commit, the renamed file keeps full history since original creation.
  25. Refactor Rename folder
    1. In "Files" view, select some package and invoke Refactor | Rename... pop-up menu action on it.
    2. Enter a new name for the package and push Refactor.
    3. Commit all changes.
    • EXPECTED RESULT: After the rename, status of all files inside the package is "Renamed/Modified" or just "Renamed/-" for files which content wasn't changed by refactoring. In "Git" window, all affected files are also visible with their original path and "Deleted/-" status. After commit, the files under the renamed folder keep their full history since their original creation.

Test suite: Working with branches

Purpose: Tests branching actions.
Setup: IDE with activated Git module. Opened Git versioned project.

  1. "Git Repository Browser" window
    1. Select the project root node in "Projects" view and invoke Team | Repository Browser main menu action.
    • EXPECTED RESULT: "Git Repository Browser" window is opened. It should contain at least the current project.
  2. Create branch I
    1. Select the project root node in "Projects" view and invoke Team | Branch | Create Branch... main menu action. "Create Branch" dialog shows up.
    2. In the dialog, enter some "Branch Name" and push the Create button.
    • EXPECTED RESULT: New branch is created. Details can be reviewed in the "Output" window. The new branch should be also visible in "Git Repository Browser" under local branches.
  3. Create branch II
    1. Select the project root node in "Projects" view and invoke Team | Branch | Create Branch... main menu action. "Create Branch" dialog shows up.
    2. In the dialog, enter some "Branch Name", check "Checkout Created Branch" and push the Create button.
    • EXPECTED RESULT: New branch is created. Details can be reviewed in the "Output" window. The new branch should be also visible in "Git Repository Browser" under local branches and it should be highlighted.
  4. Switch branch
    1. Select the project root node in "Projects" view and invoke Team | Branch | Switch To Branch... main menu action. "Switch To Selected Branch" dialog shows up.
    2. In the dialog, use the "Branch" combobox to select the branch created in the previous test case and push the Switch button.
    • EXPECTED RESULT: The project is switched to the selected branch. Details can be reviewed in the "Output" window. Versioning label next to project root node in "Projects" view should be the branch name. The branch name should be also in the "Git" window header. Current branch should be highlighted in "Git Repository Browser".
  5. Switch new branch
    1. Select the project root node in "Projects" view and invoke Team | Branch | Switch To Branch... main menu action. "Switch To Selected Branch" dialog shows up.
    2. In the dialog, tick the "Checkout as New Branch" combobox.
    3. Enter some "Branch Name" and push the Create button.
    • EXPECTED RESULT: New branch is created and the project is switched to it. Details can be reviewed in the "Output" window. Versioning label next to project root node in "Projects" view should be the branch name. The branch name should be also in the "Git" window header. Current branch should be highlighted in "Git Repository Browser".
  6. Merge branch
    1. While on the branch, modify some file and commit the change.
    2. Switch back to "master" branch.
    3. Select the project root node in "Projects" view and invoke Team | Branch | Merge Revision... main menu action. "Merge Revision" dialog shows up.
    4. In the dialog, push the Select button. "Select Revision" dialog shows up.
    5. Expand "Branches", "Local" and select the branch with the modification.
    6. Push the Select button to choose the selected branch.
    7. Back in the "Merge Revision" dialog, push Merge.
    • EXPECTED RESULT: Selected branch is merged into current branch. Details can be reviewed in the "Output" window.
  7. Create Tag
    1. Make some modifications and commit them.
    2. Select the project root node in "Projects" view and invoke Team | Tag | Create Tag... main menu action. "Create Tag" dialog shows up.
    3. Enter some "Tag Name" and some "Tag Message".
    4. Keep default "Revision" - it should be the last commit.
    5. Push Create.
    • EXPECTED RESULT: Tag is created on selected commit. Details can be reviewed in the "Output" window and in "Manage Tags" dialog (Team
  8. Diff between branches
    1. Use the "master" and another branch from previous testcases
    2. Modify some files in "master" branch and commit it
    3. Select the project root in "Project" view and invoke Team | Diff | Diff to...
    4. New dialog appears, select "Local To Revision" in "Diff" combobox
    5. Push the Select button and select another branch than "master" branch, push the Select button
    6. Push the Diff button
    • EXPECTED RESULT: New tab labeled "Project_Name [Diff]" is displayed. All differencies between "master" and another branch are highlighted.
  9. Rebase support
    1. Create a new branch and switch to this branch
    2. Make some modification in file from the new branch, save file and commit changes, repeat this step once more
    3. Switch to "master" branch
    4. Select the project root in "Project" view and invoke Team | Branch/Tag | Rebase...
    5. Rebase dialog appears, select "Current Branch to Any Destination" in "Rebase" combobox
    6. Push the Select button and in the new dialog select the branch that you created in first step, click on Select button
    7. Push the Rebase button
    • EXPECTED RESULT: Verify that all changes are also in "master" branch. Verify in "Show History" list that there are all commits that you made in the new branch and previous commits from "master" branch.

Test suite: Team development

Purpose: Tests pull and push actions.
Setup: IDE with activated Git module. Make two same clones from one origin.

  1. Push to default
    1. Open the first clone created in test suite setup.
    2. Make a few commits with some modifications.
    3. Select the project root node in "Projects" view and invoke Team | Remote | Push... main menu action. "Push to Remote Repository" wizard shows up.
    4. "Select Configured Git Repository Location" option with url to origin should be selected, keep it and push Next.
    5. In the second step of the wizard, local branches with modifications are ticked and marked with blue [U] flag, any new branches aren't ticked and are marked with green [A] flag. Keep this default selection and push Next >.
    6. In the third step of the wizard, all remote branches which needs update are listed and ticked, keep this default selection and push Finish.
    • EXPECTED RESULT: Changes from local clone are pushed into origin and remote references are updated. Details can be reviewed in the "Output" window. Make another clone of the origin to verify that it contains all changes.
  2. Fetch from default
    1. Open the second clone created in test suite setup.
    2. Select the project root node in "Projects" view and invoke Team | Remote | Fetch... main menu action. "Fetch from Remote Repository" wizard shows up.
    3. "Select Configured Git Repository Location" option with url to origin should be selected, keep it and push Next.
    4. In the second step of the wizard, remote branches with modifications are ticked and marked with blue [U] flag, any new branches aren't ticked and are marked with green [A] flag. Keep this default selection and push Finish.
    • EXPECTED RESULT: Remote references are updated. Details can be reviewed in the "Output" window. No merges on local branches are made.
  3. Pull from default
    1. Open the first clone, make some modifications on it, commit and push them.
    2. Open the second clone.
    3. Select the project root node in "Projects" view and invoke Team | Remote | Pull... main menu action. "Pull from Remote Repository" wizard shows up.
    4. "Select Configured Git Repository Location" option with url to origin should be selected, keep it and push Next.
    5. In the second step of the wizard, remote branches with modifications are ticked and marked with blue [U] flag, any new branches aren't ticked and are marked with green [A] flag. Keep this default selection and push Finish.
    • EXPECTED RESULT: Remote references are updated. Details can be reviewed in the "Output" window. Upstream changes are merged into current branch.
  4. Merge Conflict
    1. Open the first clone, modify one line in some file, commit and push the change.
    2. Open the second clone, modify the same line in the same file differently and commit the change.
    3. Select the project root node in "Projects" view and invoke Team | Remote | Pull from Upstream main menu action.
    4. "Merge Conflicts" question dialog is shown, push the Resolve button.
    5. "Merge Conflicts Resolver" window is opened. Choose which version will be used by pushing the Accept button above it.
    6. Push OK button to proceed and Yes on a following question whether to save modifications.
    • EXPECTED RESULT: "Merge Conflicts Resolver" window is closed. The conflicting files are modified according to selection and all changes are saved. Red badges disappears from all views. Font color of conflicting files changes from red back to normal. Versioning labels on conflicting files changes from "[XX]" back to normal as well as statuses in "Git" window. After merge commit must be performed.

Test suite: Shelve Changes

Purpose: Tests whether Shelving feature works correctly.
Setup: Subversion versioned project opened in the IDE.

  1. Shelve Changes
    1. Modify some file and save it, don't commit.
    2. Invoke Team | Shelve Changes | Shelve Changes... action from main menu.
    3. Verify that window "Shelve Changes" appears and contains field "Patch Name:" with default value "unfinishedChanges" and buttons "Shelve", "Cancel" and "Help".
    4. Keep default value and push Shelve.
    • EXPECTED RESULT: The file "unfinishedChanges.patch" appears and contains all changes that we made.
  2. Unshelve Changes
    1. Invoke Team | Shelve Changes | Unshelve Changes... action from main menu.
    2. Verify that window "Shelved Changes" appears and contains "Patches" combobox with "unfinishedChanges" selected, "Keep Patch File" checkbox and buttons "Unshelve", "Remove Patch", "Cancel" and "Help".
    3. Keep selection and push Unshelve Changes.
    4. Verify that the window "Question" with report "Patch applied successfully. View applied changes? (patched binary files will not be displayed)" appears.
    5. Confirm by pushing Yes button.
    • EXPECTED RESULT: All shelved changes from "unfinishedChanges" are correctly applied. New Diff tab showing applied changes is opened into editor.
  3. Unshelve "unfinishedChanges"
    1. Invoke Team | Shelve Changes | Shelve Changes... action from main menu.
    2. Keep default name and push Shelve.
    3. Invoke Team | Shelve Changes | Unshelve unfinishedChanges action from main menu.
    4. Verify that the window "Question" with report "Patch applied successfully. View applied changes? (patched binary files will not be displayed)" appears.
    5. Confirm by pushing Yes button.
    • EXPECTED RESULT: All shelved changes from "unfinishedChanges" are correctly applied. New Diff tab showing applied changes is opened into editor.
  4. Remove Patch
    1. Invoke Team | Shelve Changes | Shelve Changes... action from main menu.
    2. Keep default name and push Shelve.
    3. Invoke Team | Shelve Changes | Unshelve Changes... action from main menu.
    4. Push Remove Patch button.
    • EXPECTED RESULT: Patch with shelved changes is dropped.


Test suite: Versioning history

Purpose: Tests browsing through Git history.
Setup: IDE with activated Git module. Opened Git versioned project.

  1. Show history
    1. Select the project root node in "Projects" view and invoke Team | Show History... main menu action. "Show History - <projectname>" window shows up.
    2. Keep default "Search Options" and push the Search button.
    • EXPECTED RESULT: Last 10 revisions including merges are shown. Each revision can be expanded to list all modified files. Diff view is also available.
  2. Show annotations
    1. Select some file in "Projects" view and invoke Team | Show Annotations... main menu action.
    • EXPECTED RESULT: The selected file is opened into editor with annotations shown on the left side of the window. Annotation of the line on which is currently cursor has blue font, as well as all other occurences of the same revision. Pop-up menu is available on each annotation.
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