<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
         "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
	<meta http-equiv="content-type" content="text/html ; charset=utf-8">
	<meta name="keywords" content="OpenOffice, open office, office suite, office, international office, linux, Linux, Linux Office, Collaboration, Companies, Open Source, UNO, Java, StarOffice" />
	<meta name="description" content="OpenOffice.org - Proces QA za lokalizirane gradnje" />
<title>qa: Proces QA za lokalizirane gradnje</title>
</head>
<body>
<h1>Proces QA za lokalizirane gradnje</h1>
<p>Ta proces je v teku, and as better processes become apparent, we will follow them and change this guideline. Preizkušanje gradenj globoko vključuje projekte QA in Native-Lang. Obvestila, ki kažejo na ta process guideline bo objavljen na teh projektih in tudi pri projektu <a href="http://l10n.openoffice.org" target="_blank">l10n</a>.</p>
<h3>Od kod prihajajo lokalizacije?</h3>
<p>Lokalizirane gradnje ustvarja skupnost. Projekt <a href="http://l10n.openoffice.org" target="_blank">l10n</a> koordinira to aktivnost in vsakdo si lahko ogleda stanje vsake lokalizacije na strani stanja.</p>
<h3>Kaj počnemo pri QA?</h3>
<p>Smisel preizkušanja QA teh gradenj je reduce verjetnosti, da gradnje ne bodo delovale. They may still be rough, but by going through the QA process, we can at least ensure that we won't be sending out to the world builds that can't be installed, won't work at all, ...</p>
<h3>Kaj je proces QA?</h3>
<ul>
  <li>Lokalizirane gradnje so na voljo na več mestih. To so:
    <ul>
      <li>the mirror network under the /contrib/rc directory for most of the builds provided by hamburg release engineering.</li>
      <li><a
 href="http://oootranslation.services.openoffice.org/pub/OpenOffice.org/">http://oootranslation.services.openoffice.org/pub/OpenOffice.org/</a> for language packs or full builds provided by hamburg release engineering.</li>
      <li>places used by contributors for different platform builds.</li>
    </ul>
  </li>
	<li>The builds are registered and managed in <a href="http://qatrack.services.openoffice.org/">OpenOffice.org QATrack</a>. 
	The builds are submitted by the QA project, and updated by each build's responsible to indicate the build's current status. Often the responsible is one of the qa responsibles in the Native Lang community.<br/>
For more information about OpenOffice.org QATrack, see the system's <a href="http://qatrack.services.openoffice.org/help.php">Help section</a>.<br/>There might be a slight delay for the submission of some builds. Therefore, for most current information about the availability of these builds you should subscribe to the relevant mailing lists:
	<ul>
		<li>releases@openoffice.org</li>
		<li>dev@porting.openoffice.org</li>
	</ul>
</li>
  <li>Native-Lang leads or their delegates assigned to the task of helping QA the builds download the builds and run through a series of tests. This process should begin immediately upon the availability of localized release candidates and should not take more than two weeks from beginning to end. For managing those testcases, test assignemnts and results we use the <a href="http://www.sunvirtuallab.com/tcm2/opensource/tcm_index.cgi?tcm_config=newooo">TCM</a> (Test Case Management) Portal</li>
  <li>An IssueTracker ticket should be filed so as to move the tested builds over to the /localized directory for proper downstream dissemination and to update the pages. Mirrors need to be notified by
the Distribution project lead.<br />This should be filed as "Task" for Componente "qa", subcomponent "www". Assign it to the default owner and make shure, you name the exact location of the files that have been used for testing.</li>
  <li>Finally, once the mirror network has indicated that the builds have been successfully uploaded into the proper directory, the builds may be announced by the appropriate persons, such as the Native-Lang leads and Community Manager.</li>
</ul>
<hr /> $Revision: 1.3 $
</body>
</html>