<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en">
<head>
  <title>Progetto QA Italiano</title>


  <script type="text/javascript">
<!--
function clickmail(user, domain) {
at_sign="&#064;";
address=user+at_sign+domain;
document.write("<"+"A"+" HR"+"EF=\"mailto:"+address+"\">"+address+"<"+"/"+"a>");
}
-->
  </script>
</head>


<body>

<div id="bodycol">
<div id="projecthome" class="app">
<div class="h3" id="longdescription">


<h2>Progetto QA ("Quality Assurance") Italiano</h2>

<p>Questo progetto si occupa di eseguire i test QA, che
sono <strong>indispensabili</strong> per il rilascio della
versione italiana di
OpenOffice.org e vengono completamente gestiti da un gruppo di <strong>volontari</strong>
sempre ben disposto ad accogliere nuove persone
che vogliano dare una mano. </p>

<p></p>
<h3>Cosa facciamo e come collaborare</h3>

<a name="cosa"></a>
<h4>Che cosa facciamo qui in QA?</h4>

<p>I test QA sulle versioni localizzate servono a ridurre
la
possibilit&agrave;&nbsp; che le
versioni compilate di OpenOffice.org non funzionino. Possono comunque
esserci
imperfezioni, ma il processo di QA garantisce quantomeno che non si
rendano
disponibili al pubblico versioni che non possono essere installate, che
non
funzionino affatto, o che presentino gravi problemi di utilizzo. </p>

<p>Viene
organizzata una sessione completa di test circa <strong>una
volta al
mese</strong>, e l'inizio dei test viene annunciato alla <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-progetto-it/">mailing
list utenti</a>. I <strong>bug</strong> trovati
durante ogni sessione
di test vengono poi segnalati tramite <a href="http://qa.openoffice.org/issue_handling/bug_writing_guidelines.html">IssueZilla</a>
in modo che possano essere corretti il prima possibile. </p>

<a name="collaborare"></a>
<h4>Posso collaborare?</h4>

<p>Certamente! Segnala la tua disponibilit&agrave; alla
mailing list
QA-IT: iscriviti inviando un messaggio vuoto a
<script type="text/javascript">clickmail("progetto-it-"+"subscribe", "openoffice."+"apache"+".org");</script> e
poi comunica che sei disponibile ad aiutare, specificando anche quale
sistema operativo utilizzi (Linux o Windows, e la versione precisa).
Puoi anche
contattare direttamente il responsabile Andrea Pescetti,
<script type="text/javascript">clickmail("pesc"+"etti", "apa"+"che"+".org");</script>.
</p>

<a name="test"></a>
<h4>Che tipo di test bisogna svolgere?</h4>

<ul>

  <li>Il tempo necessario per svolgere i test &egrave;
di <strong>circa
un'ora</strong> per ogni volontario.</li>

  <li>I test sono tutti alla portata di un utente medio e <strong>nessuna
conoscenza di programmazione</strong> &egrave; richiesta.</li>

  <li>Non ci sono particolari requisiti di sistema, basta
avere
un sistema
Linux o Windows a disposizione e naturalmente poter <strong>installare</strong>
la versione in sviluppo di OpenOffice.org di volta in volta in collaudo.</li>

	<!-- AP 2011-04: Tolto.
  <li>I test si svolgono con l'aiuto del <a href="http://l10n.openoffice.org/localization/About_TCM.html">TCM</a>,
un
comodo sistema via Web a cui i volontari accedono con una password
personale.
Il TCM contiene la descrizione passo-passo dei test da svolgere e
l'interfaccia
attraverso la quale si riportano i risultati.</li>
-->

</ul>

<a name="ml"></a>
<h4>Come posso tenermi informato anche se non collaboro?</h4>

<p>Tutti gli interessati al progetto QA e gli utenti che
vogliono avere
informazioni sempre aggiornate su <strong>quando sar&agrave;
disponibile la
versione italiana</strong> possono iscriversi alla Mailing list
QA-IT
inviando un messaggio vuoto a
<script type="text/javascript">clickmail("progetto-it-"+"subscribe", "openoffice."+"apache"+".org");</script>.
In alternativa &egrave; possibile consultare gli <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-progetto-it/">archivi
della lista</a> che vengono aggiornati con un leggero ritardo. </p>

<a name="bug"></a>
<h4>Posso segnalare un bug di OpenOffice.org anche al di
fuori
dei test QA?</h4>

<p>Naturalmente s&igrave;. I passi previsti sono: </p>

<ol>

  <li>Fare il <a href="https://issues.apache.org/ooo/">login
sul
	  servizio BugZilla/IssueZilla</a> di OpenOffice.org; gli utenti che non si sono ancora
registrati
possono farlo dalla stessa pagina.</li>


  <li>Leggere la <a href="http://qa.openoffice.org/issue_handling/bug_writing_guidelines.html">breve
guida di IssueZilla</a> (in inglese) se non si ha gi&agrave;
familiarit&agrave;
con il sistema.</li>

  <li>Controllare con la <a href="http://qa.openoffice.org/issue_handling/project_issues.html">ricerca
veloce dei duplicati</a> che il bug non sia gi&agrave; stato
segnalato.</li>

  <li>Procedere alla <a href="http://www.openoffice.org/issues/enter_bug.cgi">segnalazione</a>.
I valori preimpostati vanno generalmente bene. Se il bug che si
desidera
segnalare &egrave; un errore di traduzione dei men&ugrave;,
dell'interfaccia
o della Guida &egrave; consigliabile aggiungere "<code>IT: </code>"
prima
del titolo, specificare "<code>ui</code>" come component e
subcomponent e
assegnare il bug a <code>iano</code> per velocizzare la
correzione.</li>

</ol>

<p></p>
<h3>Come funziona la QA per le versioni localizzate</h3>

	<!-- AP 2012-04: Tolto
<a name="svolgere"></a>
<h4>Come faccio a svolgere i test che mi sono stati
assegnati?</h4>

<ol>

  <li>Apri il <a href="http://quaste.services.openoffice.org/tcm/tcm_login.cgi?tcm_config=newooo">sistema
TCM</a>
e fai il login. Se hai perso la password, chiedi al responsabile Andrea
Pescetti,
    <script type="text/javascript">clickmail("pesc"+"etti", "open"+"office"+".org");</script>,
di reimpostarla.</li>

  <li>Fai clic su "Test Result Update".</li>

  <li>Scegli la versione attualmente in test, nella tabella dove compare
il tuo nome.</li>

  <li>Compariranno gli scenari di test che ti sono stati assegnati
(ad esempio: Writer-2. Calc-1, ...).
Fai clic su quello che intendi svolgere nella colonna "Assign By".
(Se stai riprendendo uno scenario interrotto, invece fai clic sul numero
che compare nella colonna "U").
</li>

  <li>Imposta a <strong>FAIL</strong> i test
su cui hai problemi o dubbi, a <strong>SKIP</strong>
quelli non ancora eseguiti
o saltati perch&eacute; non
sono previsti per la lingua italiana, a <strong>PASS</strong>
quelli che non
evidenziano problemi.</li>

<li>Ricorda che quando nei test si dice di inserire del testo
   "localizzato", o "in italiano", o "nella vostra lingua", o "nel
   vostro alfabeto", si intende di inserire testo in italiano contenente
   caratteri accentati.</li>

  <li>Avvisa la mailing list QA-IT che hai terminato i test
e riporta gli
eventuali problemi o dubbi direttamente in mailing list.</li>

</ol>
-->
	
<a name="multiple"></a>
<h4>Posso installare la versione in test insieme all'ultima
versione stabile?</h4>

<p>Le versioni in test si dividono in versioni <strong>dev</strong>,
che sono
intese esclusivamente per i test e si installano senza causare
interferenze con
eventuali altre versioni di OpenOffice.org gi&agrave; presenti nel
sistema, e
versioni <strong>Release Candidate</strong> (RC), che
invece si sostituiscono
alla precedente installazione se installate con la procedura standard.</p>

<p>Questa stessa procedura si applica anche al caso in cui
vogliate installare
contemporaneamente due diverse localizzazioni (ad esempio, italiana e
inglese)
della medesima versione di OpenOffice.org. Parti di queste procedure sono
state suggerite da R.&nbsp;Braconi, M.&nbsp;Neumann, P.&nbsp;Pedaletti,
S.&nbsp;Cicuto.</p>

<p>Su sistemi Windows:</p>

<ol>

  <li>Avviate la prima fase dell'installazione
(decompressione dei file
di installazione) ed uscite appena i file sono stati estratti.</li>

  <li>Entrate nella cartella sul Desktop che contiene i
file di installazione
e rintracciate il file <code>setup.exe</code>.
Posizionatevi nella cartella che lo
contiene.</li>

  <li>Create, col tasto destro, un nuovo documento di testo
semplice in quella
cartella. Inserite come contenuto la sola riga <code>setup.exe&nbsp;/a</code>
e
salvate con nome <code>netsetup.bat</code>, tipo: <code>Tutti
i file</code>, quindi uscite.</li>

  <li>Avviate <code>netsetup.bat</code> e
installate il programma in una nuova
cartella, ad esempio <code>C:\Programmi\OOoTest</code>.</li>

  <li>Per avviare la versione test usate <code>program/soffice.exe</code>
nella
cartella di installazione.</li>

  <li>Per evitare incompatibilit&agrave; con versioni
di OpenOffice.org
preesistenti, disattivate il quaickstart in tutte le versioni.</li>

</ol>

<p>Su sistemi Linux basati su RPM:</p>

<ol>

  <li>Estraete l'archivio e posizionatevi nella directoy
che contiene gli
RPM.</li>

  <li>Per installare, ad esempio, in <code><b>/home/utente/oootest</b></code>
date i
comandi (ciascuno su un'unica riga):<br />

    <code>mkdir -p <b>/home/utente/oootest</b>/.rpm</code><br />
    <code>rpm -ivh --dbpath <b>/home/utente/oootest</b>/.rpm
--nodeps --prefix <b>/home/utente/oootest</b> *.rpm</code><br />

</li>

  <li>Potete avviare la versione test da <code>/home/utente/oootest/openoffice.org3/program/soffice</code>.</li>

</ol>

<p>Su sistemi Linux non basati su RPM (ad esempio Debian o Ubuntu <b>se scaricate la versione RPM</b>):</p>

<ol>

  <li>Estraete l'archivio e posizionatevi nella directoy
che contiene gli
RPM.</li>

  <li>Estraete il contenuto usando <code>rpm2cpio</code> oppure <code>alien</code>
come segue:<br />
    <code>for FILENAME in *.rpm ; do rpm2cpio "$FILENAME" | cpio -i -d; done</code> <br />
se avete <code>rpm2cpio</code>, oppure <br />
    <code>alien -t -c *.rpm ; for FILENAME in *.tgz ; do tar zxvf $FILENAME ; done</code>  <br />
se avete <code>alien</code>.</li>

  <li>Potete avviare la versione test da <code>opt/openoffice.org3/program/soffice</code>.</li>

</ol>

<p>Su sistemi Linux (ad esempio su Debian o Ubuntu <b>se scaricate la versione DEB</b>):</p>

<ol>

  <li>Aprite il terminale e posizionatevi nella cartella dove avete scaricato il file.</li>
  <li>Se non l'avete gi&agrave; estratto, estraetelo con il comando<br/>
      <code>tar zxvf OOo_3.0.0rc1_20080904_LinuxIntel_install_it_deb.tar.gz</code><br/>
      altrimenti prendete nota del nome della cartella che contiene i file estratti,
      ad esempio <code><b>OOO300_m5_native_packed-3_it.9350</b></code>.</li>
  <li>Installate i pacchetti con il comando seguente, dove inserirete la stringa
      opportuna:<br/>
      sudo dpkg -i <code><b>OOO300_m5_native_packed-3_it.9350</b>/DEBS/*.deb</code></li>
  <li>Potete avviare la versione test con <code>/opt/openoffice.org3/program/soffice</code>.</li>
</ol>

<a name="coordinatori"></a>
<h4>In cosa consiste il processo di QA per i coordinatori?</h4>

<ol>

  <li>Le versioni localizzate, inclusa quella italiana,
sono rese
disponibili
attraverso la rete di siti mirror nella cartella <code>/contrib/rc</code>
(vedere il
progetto <a href="http://distribution.openoffice.org/files.html">Distribution</a>
per spiegazioni sulla struttura delle directory).</li>
<!--
  <li>Le versioni disponibili sono elencate nella <a href="http://qatrack.services.openoffice.org/view.php?lg=it">pagina
di stato</a>. Questa pagina viene aggiornata dai coordinatori del
progetto QA
ed indica, lingua per lingua, lo stato attuale (compilazione in corso,
disponibilit&agrave;&nbsp; di versioni non collaudate, test in
corso, versione approvata per
la pubblicazione, versione pubblicata).</li>
-->

  <li>I coordinatori dei singoli gruppi Native-Lang o loro
delegati hanno il compito di assistere al processo di QA delle
versioni, scaricando le versioni localizzate e organizzando una
sessione di test nel <a href="http://l10n.openoffice.org/localization/About_TCM.html">TCM</a>,
l'apposito sistema via web. Questa procedura generalmente viene avviata
appena dopo il rilascio delle versioni in inglese e non dovrebbe
portare via pi&ugrave; di <strong>due settimane</strong>
dall'inizio alla fine.</li>

	<!--
  <li>Una volta che la versione italiana &egrave; stata
approvata e ha superato
i test previsti, la <a href="http://qatrack.services.openoffice.org/view.php?lg=it">pagina
di stato</a> viene aggiornata.</li>
-->
  <li>Viene aperto un ticket su <a href="http://www.openoffice.org/issues/enter_bug.cgi">IssueZilla</a>,
sul
componente QA, per ottenere lo spostamento della versione verificata
dalla
cartella <code>/contrib/rc</code> alla cartella <code>/localized</code>
per la
distribuzione ufficiale. I siti mirror riceveranno informazioni dai
coordinatori del progetto <a href="http://distribution.openoffice.org/">Distribution</a>.</li>

  <li>Infine, una volta che i siti mirror sono pronti e
contengono la versione
italiana nella cartella appropriata, la
disponibilit&agrave;&nbsp; della versione italiana
viene annunciata pubblicamente da uno dei responsabili del Progetto
Linguistico
Italiano o della Comunit&agrave;. </li>

</ol>

<a name="stato"></a>
<h4>Da dove vengono le versioni localizzate?</h4>

<p>Le versioni localizzate sono create dalla
comunit&agrave;. Il
progetto <a href="http://qa.openoffice.org/project/l10n/">l10n</a>
coordina questa attivit&agrave;.<!--, e chiunque pu&ograve;
verificare lo stato delle
localizzazioni in corso controllando la <a href="http://qatrack.services.openoffice.org/view.php?lg=it">pagina
di stato</a>, che contiene anche informazioni sul download delle
versioni
in test.--></p>

<a name="aggiornamenti"></a>
<h4>Dove vengono annunciati gli aggiornamenti di questa
procedura?</h4>

<p>La procedura che si segue per i test QA viene aggiornata
spesso in modo
che si possano sempre utilizzare i migliori strumenti disponibili.
Anche questa
guida di riferimento viene aggiornata di conseguenza. Il collaudo delle
versioni
coinvolge direttamente i progetti <a href="http://qa.openoffice.org/">QA internazionale</a>
e <a href="http://projects.openoffice.org/native-lang.html">Native-Lang</a>,
sulle pagine dei quali si possono trovare informazioni aggiornate sulla
procedura prevista per i test QA.</p>

<hr />

</div>

</div>

</div>

</body>
</html>
