[%# This Source Code Form is subject to the terms of the Mozilla Public
  # License, v. 2.0. If a copy of the MPL was not distributed with this
  # file, You can obtain one at http://mozilla.org/MPL/2.0/.
  #
  # This Source Code Form is "Incompatible With Secondary Licenses", as
  # defined by the Mozilla Public License, v. 2.0.
  #%]

[% INCLUDE global/header.html.tmpl title = "$terms.Bug Writing Guidelines" %]

  <p>Effective [% terms.bug %] reports are the most likely to be fixed. 
  These guidelines explain how to write such reports.

<h3>Principles</h3>

  <ul>
    <li>Be precise</li>
    <li>Be clear - explain it so others can reproduce the [% terms.bug %]</li>
    <li>One [% terms.bug %] per report</li>
    <li>No [% terms.bug %] is too trivial to report - 
    small [% terms.bugs %] may hide big [% terms.bugs %]</li>
    <li>Clearly separate fact from speculation</li>
  </ul>

<h3>Preliminaries</h3>

<ol>
  <li>Reproduce your [% terms.bug %] using a recent build of the
  software, to see whether it has already been fixed.
  </li>

  <li><a href="query.cgi?format=specific">Search</a> 
  [% terms.Bugzilla %], to see whether your [% terms.bug %] has
  already been reported.</li>
</ol>

<h3>Reporting a New [% terms.Bug %]</h3>

<p>If you have reproduced the [% terms.bug %] in a recent build and 
no-one else appears to have reported it, then:</p>

<ol>
 <li>Choose 
 "<a href="enter_bug.cgi">Enter a new [% terms.bug %]</a>"</li>
 <li>Select the product in which you've found the [% terms.bug %]</li>
 <li>Fill out the form. Here is some help understanding it:</li>
</ol>

  <blockquote>
    <p><b>Component:</b> In which sub-part of the software does it 
          exist?<br>
    This field is required.
    Click the word "Component" to see a description of each 
    component. If none seems appropriate, look for a "General" component.</p>

    <p><b>[% field_descs.op_sys FILTER html %]:</b> On which operating system (OS) did you find 
          it?
    (e.g. Linux, Windows XP, Mac OS X.)<br>
    If you know the [% terms.bug %] happens on more than one type of 
    operating system, choose <em>[% display_value("op_sys", "All") FILTER html %]</em>. 
    If your [% field_descs.op_sys FILTER html %] isn't listed, choose 
    <em>[% display_value("op_sys", "Other") FILTER html %]</em>.</p>

    <p><b>Summary:</b> How would you describe the [% terms.bug %], in 
    approximately 60 or fewer characters?<br>
     A good summary should <b>quickly and uniquely identify [% terms.abug %]
    report</b>. It should explain the problem, not your suggested solution.<br>
    <ul>
     <li>Good: "<kbd>Cancelling a File Copy dialog crashes
     File Manager</kbd>"</li>
     <li>Bad: "<kbd>Software crashes</kbd>"</li>
     <li>Bad: "<kbd>Browser should work with my web site</kbd>"</li>
    </ul>
    
    <b>Description:</b>
    The details of your problem report, including:</p>

    <blockquote>
      <p><b>Overview:</b> More detailed restatement of
      summary.</p>

      <blockquote>
<pre>
Drag-selecting any page crashes Mac builds in the NSGetFactory function.
</pre>
      </blockquote>

      <p><b>Steps to Reproduce:</b> Minimized, easy-to-follow steps that
      will trigger the [% terms.bug %]. Include any special setup steps.</p>

      <blockquote>
<pre>
1) View any web page. (I used the default sample page, 
resource:/res/samples/test0.html)

2) Drag-select the page. (Specifically, while holding down 
the mouse button, drag the mouse pointer downwards from any 
point in the browser's content region to the bottom of the 
browser's content region.)
</pre>
      </blockquote>

      <p><b>Actual Results:</b> What the application did after performing
      the above steps.</p>

      <blockquote>
<pre>
The application crashed.
</pre>
      </blockquote>

      <p><b>Expected Results:</b> What the application should have done,
      were the [% terms.bug %] not present.</p>

      <blockquote>
<pre>
The window should scroll downwards. Scrolled content should be selected. 
(Or, at least, the application should not crash.)
</pre>
      </blockquote>

      <p><b>Build Date &amp; [% field_descs.rep_platform FILTER html %]:</b>
      Date and [% field_descs.rep_platform FILTER lower FILTER html %] of the build
      in which you first encountered the [% terms.bug %].</p>

      <blockquote>
<pre>
Build 2006-08-10 on Mac OS 10.4.3
</pre>
      </blockquote>

      <p><b>Additional Builds and Platforms:</b> Whether or not 
      the [% terms.bug %] takes place on other platforms (or browsers, 
      if applicable).</p>

      <blockquote>
<pre>
Doesn't Occur On Build 2006-08-10 on Windows XP Home (Service Pack 2)
</pre>
      </blockquote>

      <p><b>Additional Information:</b> Any other useful information.
      <br><br>For crashing [% terms.bugs %]:</p>

      <ul>
        <li><b>Windows:</b> Note the type of the crash, and the module that the
        application crashed in (e.g. access violation in apprunner.exe).</li>

        <li><b>Mac OS X:</b> Attach the "Crash Reporter" log that appears
        upon crash.
        Only include the section directly below the crashing thread, usually 
        titled "Thread 0 Crashed". Please do not paste the entire log!</li>
      </ul>
    </blockquote>

  <p>Double-check your report for errors and omissions, then press "Commit".
  Your [% terms.bug %] report will now be in 
  the [% terms.Bugzilla %] database.<br>
  </p>
</blockquote>

[% INCLUDE global/footer.html.tmpl %]
