<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head>
  <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
  <title>3.2 M4 Test Plan</title>
  <style type="text/css">
    h4 { margin-bottom: .5em; margin-top: 1.5em }
    ul { margin-top: .5em }
    ul li ul { margin-top: 0em; margin-bottom: .25em }
  </style>
</head>

<body>
<h1>3.2 M4 Test Grid</h1>
Test day: Tuesday, 2005-12-13<br>
Test Build: latest I-build<br>
Components: JDT/Text, JDT/UI, Platform/Search, and Platform/Text<br>
Testers: Martin, Dani, Markus, Tobias, Benno, Tom, Philip<br>

<h4>Goal</h4>
<ul>
  <li>test new functionality added since M3</li>
  <li>sanity check performance</li>
  <li>verify that severe bugs are correctly fixed</li>
</ul>

<h4>Verification of Bugs (ALL)</h4>
<span style="font-style: italic;">There are 184 so everyone should verify 31. Take high-priority and M4 bugs first.<br>
Before starting to verify add a comment that you take a bug for verification.</span><br>
<ul>
<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Eclipse&amp;product=JDT&amp;component=UI&amp;priority=P1&amp;priority=P2&amp;target_milestone=3.2%20M1&amp;target_milestone=3.2%20M2&amp;target_milestone=3.2%20M3&amp;target_milestone=3.2%20M4&amp;bug_status=RESOLVED&amp;resolution=FIXED&amp;order=bugs.priority,bugs.target_milestone,bugs.bug_id">
  JDT UI bugs P1/P2, 3.2M1-4</a></li>

<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Eclipse&amp;component=Text&amp;component=Search&amp;component=Compare&amp;priority=P1&amp;priority=P2&amp;target_milestone=3.2%20M1&amp;target_milestone=3.2%20M2&amp;target_milestone=3.2%20M3&amp;target_milestone=3.2%20M4&amp;bug_status=RESOLVED&amp;resolution=FIXED&amp;order=bugs.priority,bugs.target_milestone,bugs.bug_id">
  Text, Search, and Compare bugs P1/P2, 3.2 M1-4</a><p></p></li>

<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Eclipse&amp;product=JDT&amp;component=UI&amp;bug_severity=blocker&amp;bug_severity=critical&amp;bug_severity=major&amp;target_milestone=3.2%20M1&amp;target_milestone=3.2%20M2&amp;target_milestone=3.2%20M3&amp;target_milestone=3.2%20M4&amp;bug_status=RESOLVED&amp;resolution=FIXED&amp;order=bugs.priority,bugs.target_milestone,bugs.bug_id">
  JDT UI bugs blocker/critical/major, 3.2 M1-4</a></li>

<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Eclipse&amp;component=Text&amp;component=Search&amp;component=Compare&amp;bug_severity=blocker&amp;bug_severity=critical&amp;bug_severity=major&amp;target_milestone=3.2%20M1&amp;target_milestone=3.2%20M2&amp;target_milestone=3.2%20M3&amp;target_milestone=3.2%20M4&amp;bug_status=RESOLVED&amp;resolution=FIXED&amp;order=bugs.priority,bugs.target_milestone,bugs.bug_id">
  Text, Search, and Compare bugs blocker/critical/major, 3.2 M1-4</a><p></p></li>

<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Eclipse&amp;product=JDT&amp;component=UI&amp;target_milestone=3.2%20M1&amp;target_milestone=3.2%20M2&amp;target_milestone=3.2%20M3&amp;target_milestone=3.2%20M4&amp;bug_status=RESOLVED&amp;resolution=FIXED&amp;order=bugs.priority,bugs.target_milestone,bugs.bug_id">
  all JDT UI bugs 3.2 M1-4</a></li>

<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Eclipse&amp;component=Text&amp;component=Search&amp;component=Compare&amp;target_milestone=3.2%20M1&amp;target_milestone=3.2%20M2&amp;target_milestone=3.2%20M3&amp;target_milestone=3.2%20M4&amp;bug_status=RESOLVED&amp;resolution=FIXED&amp;order=bugs.priority,bugs.target_milestone,bugs.bug_id">
  all Text, Search, and Compare bugs 3.2 M1-4</a><p></p></li>

</ul>

<h4>Watch out for cheese and odd behavior in the Text and Java editors (ALL)</h4>
<p></p>
<hr/>

<h4>New clean ups (Philip, Tom) (FAQ: Benno)</h4>
<ul>
<li>Remove unused private field</li>
  <li>Remove unused local variable</li>
  <li>Convert for loops to enhanced for loops</li>
  <li>Convert control statement body to block</li>
  <li>Qualify access to static field with declaring class</li>
  <li>Change indirect access to static member to direct access</li>
</ul>

<h4>Surround with template (Tobias, Philip) (FAQ: Benno)</h4>
<ul>
  <li>Define new templates and apply them.</li>
</ul>

<h4>JAR Import/Export with refactorings (Markus, Philip) (FAQ: Tobias)</h4>
Currently available for all Rename refactorings, Move Method and Change Method Signature
<ul>
  <li>JAR Export
    <ul>
      <li>Verify that the wizard only shows UI for refactoring export if corresponding option is checked on first page</li>
      <li>Verify that JAR file contains META-INF/REFACTORINGS.XML with corresponding entries</li>
      <li>Verify that refactoring preview can be adjusted by starting time</li>
    </ul>
  </li>
  <li>JAR Import
    <ul>
      <li>Verify that JAR files with no refactoring information are rejected</li>
      <li>Verify that only pending refactorings are executed, even if JAR contains entire refactoring history of associated projects</li>
      <li>Verify that refactorings are correctly applied</li>
    </ul>
  </li>
</ul>

<h4>enhanced support for Java files from repository (Martin, Benno) (FAQ: Dani)</h4>
  <ul>
    <li>test that all aspects (filters, sorting, actions from main and context menus, ...) inside the Java Outline page work</li>
    <li>test that all aspects (filters, sorting, actions from main and context menus, ...) inside the Quick Outline work</li>
    <li>make the editor active and test that all actions via tool bar and editor context menu don't break</li>
  </ul>
<h4>enhanced support for external Java files (Tobias, Martin) (FAQ: Dani)</h4>
  <ul>
    <li>test that all aspects (filters, sorting, actions from main and context menus, ...) inside the Java Outline page work</li>
    <li>test that all aspects (filters, sorting, actions from main and context menus, ...) inside the Quick Outline work</li>
    <li>make the editor active and test that all actions via tool bar and editor context menu don't break</li>
  </ul>
<h4>test the Java editor with a Java file that has non *.java extension (Markus, Martin) (FAQ: Dani)</h4>

<h4>test Javadoc view and hovering with library that has no source but attached Javadoc (Tom, Markus) (FAQ: Dani)</h4>

<h4>test content assist with a library that has no source but attached Javadoc (Markus, Tom) (FAQ: Dani, Martin)</h4>
  <ul>
    <li>test performance</li>
    <li>play with the new timeout preference (Java &gt; Editor &gt; Content Assist &gt; Work in Progress &gt; Timeout...)</li>
  </ul>
<h4>test Delete Line and Cut Line with empty, full single line and multiple line selection (Tom, Benno) (FAQ: Dani)</h4>

<h4>Test camelCase navigation in dialog fields (Tom, Martin) (FAQ: Markus)</h4>
  <ul>
    <li>check "New ..." wizards, refactoring dialogs, Open Type, Quick Views, ...</li>
    <li>check Ctrl+(Shift)+Left/Right, Ctrl+Delete, Ctrl+Backspace</li>
  </ul>
  
<h4>Content Assist: most recently used ranking of type proposals (Tobias, Markus) (FAQ: Tom)</h4>
  <ul>
    <li>Ensure that a selected type proposal is remembered in situations with an expected type:
      <ul>
        <li>Assignments: <code>List list= new ArrayLi|</code></li>
        <li>Method calls: <code>list.addAll(new |)</code></li>
        <li>Return statements: <pre>
              public CharSequence createName() {
                  return new Str|
              }
          </pre>
        </li>
      </ul>

    </li>
    <li>Ensure that remembered types show up even if there is no prefix:
      <ul>
        <li><code>List list= new |</code></li>
      </ul>
    </li>
  </ul>

<h4>Content Assist: test CamelCaseCompletion (Benno, Tobias) (FAQ: Tom, Dani)</h4>
  <ul>
    <li>see also: Java &gt; Editor &gt; Content Assist &gt; "Match camel case proposals"</li>
    <li>test interaction with different content assist modes:
   	  <ul>
        <li>prefix insertion</li>
        <li>overwrite vs. insert</li>
        <li>automatically insert single proposals</li>
      </ul>
    </li>
    <li>test different completions:
   	  <ul>
        <li>fields</li>
        <li>methods</li>
        <li>types</li>
        <li>override / implement method</li>
      </ul>
    </li>
  </ul>
  
<h4>Enable different file extension for compilation units (Benno, Philip) (FAQ: Martin)</h4>
  <ul>
    <li>refactorings should preserve file suffix</li>
    <li>all functionality should work, code resolve, search...</li>
  </ul>

<h4>Quick Fixes for annotations (Philip, Tobias) (FAQ: Martin)</h4>
  <ul>
    <li>missing attribute, unknow attribute, wrong type in attribute, unknown references in attributes</li>
  </ul>

<h4>Search (Dani, Tom) (FAQ: Martin)</h4>
  <ul>
    <li>remembered dialog size and position (changed to use platform code):<br>
    Multi monitor, screen resolution changes etc.</li>
    <li>Text search testing: Java rename with textual matches, NLS search<br>
    Check that everything works as expected. Try different file extensions and scopes</li>
    <li>Text search with derived resource/derived folders:<br>
    All elements in a derived folder are considered to be derived</li>
  </ul>

<h4>Rename Type with "update similar elements" (Benno, Tobias) (FAQ: Philip, Markus)</h4>
  <ul>
    <li>Test all three matching strategies</li>
    <li>Test changing the chosen renamings for similar elements (page 2)</li>
    <li>Test going back and forth in the wizard (also with errors, e.g. when renaming to an already existing element)</li>
  </ul>

<h4>Delete Package (Tobias, Tom) (FAQ: Philip, Markus)</h4>
  <ul>
    <li>Verify that empty superpackages are automatically removed (also on multi-selection, etc.)</li>
    <li>Test "Delete subpackages" option in delete dialog</li>
    <li>If time permits: check that participants get reasonable notifications</li>
  </ul>


<br>
</body>
</html>