Subversion Repositories Applications.referentiel

Rev

Rev 176 | Rev 183 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
20 jpm 1 
<?php
2 
// Encodage : UTF-8
3 
// +-------------------------------------------------------------------------------------------------------------------+
4 
/**
5 
* Tests de référentiels de nomenclature et taxonomie
6 
*
7 
* Description : classe permettant de tester les référentiels selon le manuel technique
8 
* Utilisation : php script.php tests -p bdnff -a tout
9 
*
10 
//Auteur original :
11 
* @author       Jean-Pascal MILCENT <jpm@tela-botanica.org>
12 
* @copyright	Tela-Botanica 1999-2010
13 
* @link			http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
14 
* @licence		GPL v3 & CeCILL v2
15 
* @version		$Id$
16 
*/
17 
// +-------------------------------------------------------------------------------------------------------------------+
38 jpm 18 
// TODO : supprimer l'utilisation du paramêtres 'p' et chercher les infos depuis la bdd
20 jpm 19 
class Tests extends ScriptCommande {
20 
 
42 jpm 21 
	const SCRIPT_NOM = 'tests';
22 
 
20 jpm 23 
	private $projet = null;
30 jpm 24 
	private $traitement = null;
20 jpm 25 
 
26 
	private $manuel = null;
171 jpm 27 
	private $tests = null;
167 jpm 28 
	private $colonnes = null;
29 
	private $analyses = null;
64 jpm 30 
	private $noms = null;
20 jpm 31 
 
30 jpm 32 
	private $resultatDao = null;
33 
	private $traitementDao = null;
34 
	private $tableStructureDao = null;
35 
	private $referentielDao = null;
36 
 
20 jpm 37 
	public function executer() {
150 jpm 38 
		$this->manuel = parse_ini_file(Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS.'referentiel_v4.1.ini');
176 jpm 39 
		$this->definirConstantes();
171 jpm 40 
		$this->tests = parse_ini_file($this->getModuleChemin().DS.'configurations'.DS.'tests.ini', true);
20 jpm 41 
 
30 jpm 42 
		$this->resultatDao = new ResultatDao();
43 
		$this->traitementDao = new TraitementDao();
97 jpm 44 
		Debug::printr('Dans le script test');
30 jpm 45 
		// Récupération du dernier traitement demandé
142 delphine 46 
		$this->traitement = $this->traitementDao->getDernierTraitement('tout', self::SCRIPT_NOM);
42 jpm 47 
		if (isset($this->traitement)) {
142 delphine 48 
			$this->projet = $this->traitement['referentiel_code']; // Récupération du nom de projet
38 jpm 49 
			Debug::printr($this->traitement);
50 
			// Écriture de la date de début du traitement
51 
			Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
52 
 
53 
			// Nettoyage des traitements obsolètes
42 jpm 54 
			$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet, self::SCRIPT_NOM);
55 
			if (isset($traitements_obsoletes)) {
56 
				Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
57 
			}
38 jpm 58 
 
165 delphine 59 
			$this->tableStructureDao = new TableStructureDao();
60 
			$this->referentielDao = new ReferentielDao();
61 
 
38 jpm 62 
			// Lancement du test demandé
63 
			$cmd = $this->getParam('a');
64 
	    	switch ($cmd) {
65 
				case 'tout' :
66 
					Debug::printr('Départ lancement test:');
165 delphine 67 
					$this->recupererDonnees();
177 jpm 68 
					$this->lancerTestsAuto();
38 jpm 69 
					break;
165 delphine 70 
				case 'test11' :
71 
					$this->recupererDonnees();
72 
					Debug::printr('Départ lancement test 11 :');
73 
					$this->testerClassificationRang();
74 
					break;
38 jpm 75 
				default :
76 
					$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
77 
			}
78 
			// Écriture de la date de fin du traitement
79 
			Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
97 jpm 80 
		} else {
142 delphine 81 
			Debug::printr("Aucun dernier traitement trouvé pour le script '".self::SCRIPT_NOM."' !");
20 jpm 82 
		}
83 
    }
165 delphine 84 
 
176 jpm 85 
    /**
86 
     * Cette méthode définie des constantes qui peuvent ensuite être utilisée dans les fichier ini.
87 
     * Surtout utile pour le fichier tests.ini
88 
     */
89 
    private function definirConstantes() {
90 
    	define('RANG_GENRE', $this->manuel['rang_genre']);
91 
    	define('RANG_SP', $this->manuel['rang_sp']);
92 
    }
93 
 
165 delphine 94 
    public function recupererDonnees() {
20 jpm 95 
		// Récupération des données à tester
167 jpm 96 
		$this->colonnes = $this->tableStructureDao->getColonnes($this->projet);
97 
		$this->analyses = $this->tableStructureDao->getAnalyse($this->projet);
64 jpm 98 
		$this->noms = $this->referentielDao->getTout($this->projet);
99 
		Debug::printr('Nbre noms :'.count($this->noms));
165 delphine 100 
    }
101 
 
175 jpm 102 
    public function lancerTestsAuto() {
103 
		$resultats = array();
104 
 
105 
		// Lancement des tests unitaires
177 jpm 106 
		Debug::printr('Lancement des tests unitaires');
175 jpm 107 
    	foreach (array_keys($this->tests) as $numero) {
108 
			$info = $this->getInfosTest($numero);
109 
 
110 
    		if ($numero < 5) {
111 
    			// Tests spéciaux vérifiant la structure de la table
112 
    			$resultats[] = $this->lancerTestUnitaire($info);
113 
    		} else if ($numero >= 5 && $this->verifierResultats($resultats)) {
114 
				// Si la structure est bonne nous lançons les autres tests
177 jpm 115 
				$this->lancerTestUnitaire($info);
175 jpm 116 
    		}
117 
		}
118 
    }
119 
 
120 
    public function lancerTestUnitaire($info) {
177 jpm 121 
		Debug::printr($info['numero'].'::'.$info['methode']);
122 
    	$methodeDeTest = $info['methode'];
123 
    	$erreurs = $this->$methodeDeTest();
175 jpm 124 
 
125 
    	// Analyse des résultats
126 
    	if (isset($erreurs['special'])) {
127 
    		$info = $erreurs;
128 
    	} else {
176 jpm 129 
    		if (count($erreurs) > 0) {
175 jpm 130 
				$info['message']['entete'] = explode(',', $info['entete']);
131 
				$info['message']['lignes'] = $erreurs;
176 jpm 132 
				unset($erreurs);
175 jpm 133 
			} else {
134 
				$info['resultat'] = true;
135 
			}
136 
    	}
137 
 
138 
		$this->traiterResultatTest($info);
139 
 
140 
		if ($info['numero'] < 5) {
141 
			return ($info['resultat'] ? '1' : '0');
142 
		}
143 
    }
64 jpm 144 
 
145 
	private function verifierResultats($resultats) {
146 
		$ok = true;
147 
		foreach ($resultats as $resultat) {
148 
			if ($resultat == '0') {
149 
				$ok = false;
150 
				break;
151 
			}
152 
		}
153 
		return $ok;
154 
	}
20 jpm 155 
 
30 jpm 156 
	private function traiterResultatTest($info) {
157 
		if (isset($info['message'])) {
158 
			if (is_array($info['message'])) {
31 jpm 159 
				$info['message'] = $this->getVue('tests/squelettes/message_table', $info);
160 
			} else {
161 
				$info['message'] = $this->getVue('tests/squelettes/message_p', $info);
30 jpm 162 
			}
163 
		}
164 
		$this->resultatDao->ajouter($this->traitement['id_traitement'], $info);
64 jpm 165 
		$info = null;
30 jpm 166 
	}
167 
 
168 
	//+--------------------------------------------------------------------------------------------------------------+//
20 jpm 169 
	// TESTS
170 
 
171 jpm 171 
	/**
172 
	 * Test #01
173 
	 */
175 jpm 174 
	private function testerNombreDeChamps() {
171 jpm 175 
		$info = $this->getInfosTest(1);
175 jpm 176 
		$info['special'] = true;
20 jpm 177 
 
175 jpm 178 
		$nbre_colonnes = count($this->colonnes);
171 jpm 179 
		$info['message'] = $nbre_colonnes;
180 
		if ($nbre_colonnes >= 35) {
181 
			$info['resultat'] = true;
182 
		}
175 jpm 183 
 
184 
		return $info;
171 jpm 185 
	}
186 
 
187 
	/**
188 
	 * Test #02
189 
	 */
175 jpm 190 
	private function testerNomDesChamps() {
171 jpm 191 
		$info = $this->getInfosTest(2);
175 jpm 192 
		$info['special'] = true;
171 jpm 193 
 
194 
		$champs_attendus = explode(',', $this->manuel['champs']);
195 
		$champs_presents = array();
175 jpm 196 
		foreach ($this->colonnes as $colonne) {
171 jpm 197 
			$champs_presents[$colonne['Field']] = $colonne;
198 
		}
199 
 
200 
		$ok = true;
201 
		$champs_manquant = array();
202 
		foreach ($champs_attendus as $champ_attendu) {
203 
			if (!isset($champs_presents[$champ_attendu])) {
204 
				$champs_manquant[] = $champ_attendu;
205 
				$ok = false;
206 
			}
207 
		}
175 jpm 208 
 
171 jpm 209 
		$info['resultat'] = $ok;
210 
		if (!$ok) {
211 
			$info['message'] = sprintf($info['message'], implode(', ', $champs_manquant));
212 
		}
213 
 
175 jpm 214 
		return $info;
171 jpm 215 
	}
216 
 
217 
	/**
218 
	 * Test #03
219 
	 */
175 jpm 220 
	private function testerTypeDesChamps() {
171 jpm 221 
		$champs_attendus = explode(',', $this->manuel['champs_type']);
222 
		$champs_presents = array();
175 jpm 223 
		foreach ($this->colonnes as $colonne) {
171 jpm 224 
			$champs_presents[$colonne['Field']] = $colonne['Type'];
225 
		}
226 
 
227 
		// Recercherche des erreurs
228 
		$champs_erreur = array();
229 
		foreach ($champs_attendus as $champ_attendu) {
230 
			list($champ_attendu_nom, $champ_attendu_type_taille) = explode('=', trim($champ_attendu));
231 
			list($champ_attendu_type, $champ_attendu_taille) = explode('|', trim($champ_attendu_type_taille));
232 
 
233 
			if (isset($champs_presents[$champ_attendu_nom])) {
234 
				$champs_present_type = $champs_presents[$champ_attendu_nom];
235 
 
236 
				if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
237 
					|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
238 
					|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
239 
					|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
175 jpm 240 
					$champs_erreur[] = array($champ_attendu, $champ_attendu_type, $champs_present_type);
171 jpm 241 
				}
242 
			}
243 
		}
175 jpm 244 
		return $champs_erreur;
171 jpm 245 
	}
246 
 
247 
	/**
248 
	 * Test #04
249 
	 */
175 jpm 250 
	private function testerNumNomClePrimaire() {
171 jpm 251 
		$info = $this->getInfosTest(4);
175 jpm 252 
		$info['special'] = true;
171 jpm 253 
 
175 jpm 254 
		foreach ($this->colonnes as $colonne) {
171 jpm 255 
			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
256 
				$info['resultat'] = true;
257 
			}
258 
		}
175 jpm 259 
		return $info;
171 jpm 260 
	}
261 
 
262 
 
263 
	/**
264 
	 * Test #05
265 
	 */
175 jpm 266 
	private function testerTailleDesChamps() {
171 jpm 267 
		$tailles_champs_maxi = array();
175 jpm 268 
		foreach ($this->colonnes as $colonne) {
171 jpm 269 
			if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
270 
				$tailles_champs_maxi[$colonne['Field']] = $match[1];
271 
			}
272 
		}
273 
 
274 
		$tailles_trouvees = array();
175 jpm 275 
		foreach ($this->analyses as $analyse) {
171 jpm 276 
			if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
277 
				$tailles_trouvees[$match[1]] = $analyse['Max_length'];
278 
			}
279 
		}
280 
 
281 
		$champs_erreur = array();
282 
		$champs_attendus = explode(',', $this->manuel['champs']);
283 
		foreach ($champs_attendus as $champ_attendu) {
284 
			if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
285 
				if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
175 jpm 286 
					$champs_erreur[] = array($champ_attendu, $tailles_champs_maxi[$champ_attendu], $tailles_trouvees[$champ_attendu]);
171 jpm 287 
				}
288 
			}
289 
		}
175 jpm 290 
		return $champs_erreur;
171 jpm 291 
	}
292 
 
293 
	/**
294 
	 * Test #06
295 
	 */
296 
	private function testerNumNomSuperieurAZero() {
20 jpm 297 
		$noms_erreur = array();
64 jpm 298 
		foreach ($this->noms as &$nom) {
171 jpm 299 
			if ($nom['num_nom'] <= 0) {
175 jpm 300 
				$noms_erreur[] = array($nom['num_nom']);
20 jpm 301 
			}
302 
		}
175 jpm 303 
		return $noms_erreur;
20 jpm 304 
	}
305 
 
171 jpm 306 
	/**
307 
	 * Test #07
308 
	 */
309 
	private function testerNumNomRetenuSuperieurAZero() {
20 jpm 310 
		$noms_erreur = array();
64 jpm 311 
		foreach ($this->noms as &$nom) {
171 jpm 312 
			if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] <= 0) {
175 jpm 313 
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu']);
20 jpm 314 
			}
315 
		}
176 jpm 316 
		return $noms_erreur;
20 jpm 317 
	}
318 
 
171 jpm 319 
	/**
320 
	 * Test #08
321 
	 */
322 
	private function testerNumTaxSupEgalZeroUnique() {
20 jpm 323 
		$noms_erreur = array();
64 jpm 324 
		foreach ($this->noms as &$nom) {
171 jpm 325 
			if (preg_match('/^0$/', $nom['num_tax_sup'])) {
175 jpm 326 
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
20 jpm 327 
			}
328 
		}
176 jpm 329 
		// Ce test est spécial car le nombre de noms en erreurs doit être supérieur à 1 et non à 0 pour être KO.
330 
		if (count($noms_erreur) == 1) {
177 jpm 331 
			$noms_erreur = array();
20 jpm 332 
		}
176 jpm 333 
		return $noms_erreur;
20 jpm 334 
	}
335 
 
171 jpm 336 
	/**
337 
	 * Test #09
338 
	 */
339 
	private function testerTaxSupPourTaxon() {
20 jpm 340 
		$noms_erreur = array();
64 jpm 341 
		foreach ($this->noms as &$nom) {
171 jpm 342 
			if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['num_tax_sup'] != '') {
175 jpm 343 
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
20 jpm 344 
			}
345 
		}
176 jpm 346 
		return $noms_erreur;
20 jpm 347 
	}
348 
 
171 jpm 349 
	/**
350 
	 * Test #10
351 
	 */
352 
	private function testerExitenceTaxonSuperieur() {
20 jpm 353 
		$noms_erreur = array();
64 jpm 354 
		foreach ($this->noms as &$nom) {
171 jpm 355 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
356 
				if ($nom['num_tax_sup'] != 0 && !isset($this->noms[$nom['num_tax_sup']])) {
175 jpm 357 
					$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
171 jpm 358 
				}
20 jpm 359 
			}
360 
		}
176 jpm 361 
		return $noms_erreur;
20 jpm 362 
	}
363 
 
171 jpm 364 
	/**
365 
	 * Test #11
366 
	 */
367 
	private function testerClassificationRang() {
20 jpm 368 
		$noms_erreur = array();
64 jpm 369 
		foreach ($this->noms as &$nom) {
171 jpm 370 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
371 
				if (isset($this->noms[$nom['num_tax_sup']])) {
372 
					$nom_sup = $this->noms[$nom['num_tax_sup']];
373 
					if ($nom_sup['rang'] >= $nom['rang']) {
374 
						// Prise en compte de l'exception des clades
375 
						if (! ($nom_sup['rang'] == 70 && $nom['rang'] == 70)) {
175 jpm 376 
							$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang']);
171 jpm 377 
						}
378 
					}
20 jpm 379 
				}
380 
			}
381 
		}
176 jpm 382 
		return $noms_erreur;
20 jpm 383 
	}
384 
 
171 jpm 385 
	/**
386 
	 * Test #12
387 
	 */
388 
	private function testerClassification() {
20 jpm 389 
		$noms_erreur = array();
171 jpm 390 
		$this->noms_ok = array();
64 jpm 391 
		foreach ($this->noms as &$nom) {
171 jpm 392 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
393 
				if (isset($this->noms_ok[$nom['num_tax_sup']])) {
394 
					$this->noms_ok[$nom['num_nom']] = true;
395 
				} else {
396 
					$this->detection_boucle_infini = array();
397 
					$classif_ok = $this->remonterClassif($nom);
398 
					unset($this->detection_boucle_infini);
399 
 
175 jpm 400 
					if ($classif_ok === true) {
401 
						$this->noms_ok[$nom['num_nom']] = $classif_ok;
171 jpm 402 
					} else {
175 jpm 403 
						$noms_erreur[] = array($nom['num_nom'], $classif_ok);
171 jpm 404 
					}
20 jpm 405 
				}
406 
			}
407 
		}
171 jpm 408 
		unset($this->noms_ok);
176 jpm 409 
		return $noms_erreur;
20 jpm 410 
	}
411 
 
171 jpm 412 
	private function remonterClassif(&$nom) {
413 
		$this->detection_boucle_infini[$nom['num_nom']] = true;
414 
		if (preg_match('/^[0-9]*$/', $nom['num_tax_sup'])) {
415 
			if (isset($this->noms_ok[$nom['num_tax_sup']])) {
416 
				$this->noms_ok[$nom['num_nom']] = true;
417 
				return true;
418 
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
419 
				$this->noms_ok[$nom['num_nom']] = true;
420 
				return true;
421 
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
175 jpm 422 
				return 'Hiérarchie avec le taxon #'.$nom['num_nom'].' ayant un taxon superieur #'.$nom['num_tax_sup'].' inexistant';
171 jpm 423 
			} else if (isset($this->detection_boucle_infini[$nom['num_tax_sup']])) {
175 jpm 424 
				return 'Boucle infinie pour le taxon #'.$nom['num_tax_sup'];
171 jpm 425 
			} else {
426 
				$retour = $this->remonterClassif($this->noms[$nom['num_tax_sup']]);
427 
				if ($retour === true) {
428 
					$this->noms_ok[$nom['num_tax_sup']] = true;
429 
				}
430 
				return $retour;
431 
			}
432 
		} else {
175 jpm 433 
			return 'Valeur num_tax_sup incorrecte : '.$nom['num_tax_sup'];
171 jpm 434 
		}
435 
	}
436 
 
437 
	/**
438 
	 * Test #13
439 
	 */
440 
	private function testerRang() {
441 
		$rangs = array_flip(explode(',', $this->manuel['rangs']));
442 
 
20 jpm 443 
		// Réalisation du test
444 
		$noms_erreur = array();
64 jpm 445 
		foreach ($this->noms as &$nom) {
171 jpm 446 
			if (!isset($rangs[$nom['rang']])) {
175 jpm 447 
				$noms_erreur[] = array($nom['num_nom'], $nom['rang']);
20 jpm 448 
			}
449 
		}
176 jpm 450 
		return $noms_erreur;
20 jpm 451 
	}
452 
 
171 jpm 453 
	/**
454 
	 * Test #14
455 
	 */
456 
	private function testerNomCompletSupraGenerique() {
20 jpm 457 
		$noms_erreur = array();
64 jpm 458 
		foreach ($this->noms as &$nom) {
171 jpm 459 
			if ($nom['rang'] < $this->manuel['rang_genre']) {
460 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
461 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
462 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
463 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
464 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
465 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
20 jpm 466 
				}
467 
			}
468 
		}
176 jpm 469 
		return $noms_erreur;
20 jpm 470 
	}
471 
 
171 jpm 472 
	/**
473 
	 * Test #15
474 
	 */
475 
	private function testerNomCompletGenre() {
20 jpm 476 
		$noms_erreur = array();
171 jpm 477 
		foreach ($this->noms as &$nom) {
478 
			if ($nom['rang'] == $this->manuel['rang_genre']) {
479 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
480 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
481 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
482 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
483 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
484 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
20 jpm 485 
				}
486 
			}
487 
		}
176 jpm 488 
		return $noms_erreur;
20 jpm 489 
	}
490 
 
171 jpm 491 
	/**
492 
	 * Test #16
493 
	 */
494 
	private function testerNomCompletInfraGenre() {
20 jpm 495 
		$noms_erreur = array();
64 jpm 496 
		foreach ($this->noms as &$nom) {
171 jpm 497 
			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
498 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
499 
				$nom_sci_ideal = '';
500 
				if ($nom['type_epithete'] == 'agg.') {
501 
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
502 
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
503 
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
504 
				} else {
505 
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
506 
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
507 
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
20 jpm 508 
				}
171 jpm 509 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
510 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
511 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
512 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
513 
				}
20 jpm 514 
			}
515 
		}
176 jpm 516 
		return $noms_erreur;
20 jpm 517 
	}
518 
 
171 jpm 519 
	/**
520 
	 * Test #17
521 
	 */
522 
	private function testerNomCompletEspece() {
20 jpm 523 
		$noms_erreur = array();
64 jpm 524 
		foreach ($this->noms as &$nom) {
171 jpm 525 
			if ($nom['rang'] == $this->manuel['rang_sp']) {
526 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
527 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
528 
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_sp']);
529 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
530 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
531 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
532 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
20 jpm 533 
				}
534 
			}
535 
		}
176 jpm 536 
		return $noms_erreur;
20 jpm 537 
	}
538 
 
171 jpm 539 
	/**
540 
	 * Test #18
541 
	 */
542 
	private function testerNomCompletInfraSpecifique() {
158 delphine 543 
		$noms_erreur = array();
544 
		foreach ($this->noms as &$nom) {
171 jpm 545 
			if ($nom['rang'] > $this->manuel['rang_sp']) {
546 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
547 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
548 
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_sp']);
549 
				$nom_sci_ideal .= ' '.strtolower($nom['type_epithete']);
550 
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_infra_sp']);
551 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
552 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
553 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
554 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
555 
				}
158 delphine 556 
			}
557 
		}
176 jpm 558 
		return $noms_erreur;
158 delphine 559 
	}
560 
 
171 jpm 561 
	/**
562 
	 * Test #19
563 
	 */
564 
	private function testerNomSupraGeneriqueEspaces() {
20 jpm 565 
		$noms_erreur = array();
64 jpm 566 
		foreach ($this->noms as &$nom) {
171 jpm 567 
			if ($nom['nom_supra_generique'] != '') {
568 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
569 
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
570 
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
20 jpm 571 
				}
572 
			}
573 
		}
176 jpm 574 
		return $noms_erreur;
20 jpm 575 
	}
576 
 
171 jpm 577 
	/**
578 
	 * Test #20
579 
	 */
580 
	private function testerNomSupraGeneriqueSyntaxe() {
20 jpm 581 
		$noms_erreur = array();
64 jpm 582 
		foreach ($this->noms as &$nom) {
171 jpm 583 
			if ($nom['nom_supra_generique'] != '') {
584 
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
585 
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
586 
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
20 jpm 587 
				}
588 
			}
589 
		}
177 jpm 590 
		return $noms_erreur;
20 jpm 591 
	}
592 
 
171 jpm 593 
	/**
594 
	 * Test #21
595 
	 */
596 
	private function testerNomSupraGeneriqueRang() {
20 jpm 597 
		$noms_erreur = array();
64 jpm 598 
		foreach ($this->noms as &$nom) {
171 jpm 599 
			if ($nom['nom_supra_generique'] != '') {
600 
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
601 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 602 
				}
603 
			}
604 
		}
177 jpm 605 
		return $noms_erreur;
20 jpm 606 
	}
607 
 
171 jpm 608 
	/**
609 
	 * Test #22
610 
	 */
611 
	private function testerGenreEspaces() {
20 jpm 612 
		$noms_erreur = array();
64 jpm 613 
		foreach ($this->noms as &$nom) {
171 jpm 614 
			if ($nom['genre'] != '') {
615 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
616 
					$nom_traite = $this->repererEspace($nom['genre']);
617 
					$noms_erreur[] = array($nom['num_nom'], $nom_traite);
20 jpm 618 
				}
619 
			}
620 
		}
177 jpm 621 
		return $noms_erreur;
20 jpm 622 
	}
623 
 
171 jpm 624 
	/**
625 
	 * Test #23
626 
	 */
627 
	private function testerGenreSyntaxe() {
20 jpm 628 
		$noms_erreur = array();
64 jpm 629 
		foreach ($this->noms as &$nom) {
171 jpm 630 
			if ($nom['genre'] != '') {
631 
				$mots = explode(' ', $nom['genre']);
632 
				foreach ($mots as $mot) {
633 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
634 
						$nom_traite = $this->repererEspace($nom['genre']);
635 
						$noms_erreur[] = array($nom['num_nom'], $nom_traite);
636 
					}
20 jpm 637 
				}
638 
			}
639 
		}
177 jpm 640 
		return $noms_erreur;
20 jpm 641 
	}
642 
 
171 jpm 643 
	/**
644 
	 * Test #24
645 
	 */
646 
	private function testerGenreRang() {
20 jpm 647 
		$noms_erreur = array();
64 jpm 648 
		foreach ($this->noms as &$nom) {
171 jpm 649 
			if ($nom['genre'] != '') {
650 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
651 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 652 
				}
653 
			}
654 
		}
177 jpm 655 
		return $noms_erreur;
20 jpm 656 
	}
657 
 
171 jpm 658 
	/**
659 
	 * Test #25
660 
	 */
661 
	private function testerEpitheteInfraGeneriqueSyntaxe() {
20 jpm 662 
		$noms_erreur = array();
64 jpm 663 
		foreach ($this->noms as &$nom) {
171 jpm 664 
			if ($nom['epithete_infra_generique'] != '') {
665 
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
666 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
667 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
20 jpm 668 
				}
669 
			}
670 
		}
177 jpm 671 
		return $noms_erreur;
20 jpm 672 
	}
673 
 
171 jpm 674 
	/**
675 
	 * Test #26
676 
	 */
677 
	private function testerEpitheteInfraGeneriqueRang() {
20 jpm 678 
		$noms_erreur = array();
64 jpm 679 
		foreach ($this->noms as &$nom) {
171 jpm 680 
			if ($nom['epithete_infra_generique'] != '') {
681 
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
682 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 683 
				}
684 
			}
685 
		}
177 jpm 686 
		return $noms_erreur;
20 jpm 687 
	}
688 
 
171 jpm 689 
	/**
690 
	 * Test #27
691 
	 */
692 
	private function testerEpitheteInfraGeneriqueEspaces() {
20 jpm 693 
		$noms_erreur = array();
64 jpm 694 
		foreach ($this->noms as &$nom) {
171 jpm 695 
			if ($nom['epithete_infra_generique'] != '') {
696 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
697 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
698 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
20 jpm 699 
				}
700 
			}
701 
		}
177 jpm 702 
		return $noms_erreur;
20 jpm 703 
	}
704 
 
171 jpm 705 
	/**
706 
	 * Test #28
707 
	 */
708 
	private function testerEpitheteSpEspaces() {
20 jpm 709 
		$noms_erreur = array();
64 jpm 710 
		foreach ($this->noms as &$nom) {
171 jpm 711 
			if ($nom['epithete_sp'] != '') {
712 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
713 
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
20 jpm 714 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
715 
				}
716 
			}
717 
		}
177 jpm 718 
		return $noms_erreur;
20 jpm 719 
	}
720 
 
171 jpm 721 
	/**
722 
	 * Test #29
723 
	 */
724 
	private function testerEpitheteSpSyntaxe() {
20 jpm 725 
		$noms_erreur = array();
64 jpm 726 
		foreach ($this->noms as &$nom) {
171 jpm 727 
			if ($nom['epithete_sp'] != '') {
728 
				$mots = explode(' ', $nom['epithete_sp']);
729 
				foreach ($mots as $mot) {
730 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot))) {
731 
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
732 
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
733 
					}
734 
				}
20 jpm 735 
			}
736 
		}
177 jpm 737 
		return $noms_erreur;
20 jpm 738 
	}
739 
 
171 jpm 740 
	/**
741 
	 * Test #30
742 
	 */
743 
	private function testerEpitheteSpRang() {
20 jpm 744 
		$noms_erreur = array();
64 jpm 745 
		foreach ($this->noms as &$nom) {
171 jpm 746 
			if ($nom['epithete_sp'] != '') {
747 
				if ($nom['rang'] < $this->manuel['rang_sp']) {
748 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 749 
				}
750 
			}
751 
		}
177 jpm 752 
		return $noms_erreur;
20 jpm 753 
	}
754 
 
171 jpm 755 
	/**
756 
	 * Test #31
757 
	 */
758 
	private function testerTypeEpitheteEspaces() {
20 jpm 759 
		$noms_erreur = array();
64 jpm 760 
		foreach ($this->noms as &$nom) {
171 jpm 761 
			if ($nom['type_epithete'] != '') {
762 
				if (preg_match('/\s+/', $nom['type_epithete'])) {
763 
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
764 
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee);
20 jpm 765 
				}
766 
			}
767 
		}
177 jpm 768 
		return $noms_erreur;
20 jpm 769 
	}
770 
 
171 jpm 771 
	/**
772 
	 * Test #32
773 
	 */
774 
	private function testerTypeEpitheteSyntaxe() {
20 jpm 775 
		$noms_erreur = array();
64 jpm 776 
		foreach ($this->noms as &$nom) {
171 jpm 777 
			if ($nom['type_epithete'] != '') {
778 
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
779 
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete']);
20 jpm 780 
				}
781 
			}
782 
		}
177 jpm 783 
		return $noms_erreur;
20 jpm 784 
	}
785 
 
171 jpm 786 
	/**
787 
	 * Test #33
788 
	 */
789 
	private function testerTypeEpitheteHybridite() {
20 jpm 790 
		$noms_erreur = array();
64 jpm 791 
		foreach ($this->noms as &$nom) {
171 jpm 792 
			if ($nom['type_epithete'] != '') {
793 
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
794 
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']);
20 jpm 795 
				}
796 
			}
797 
		}
177 jpm 798 
		return $noms_erreur;
20 jpm 799 
	}
800 
 
171 jpm 801 
	/**
802 
	 * Test #34
803 
	 */
64 jpm 804 
	private function testerEpitheteInfraSpEspaces() {
20 jpm 805 
		$noms_erreur = array();
64 jpm 806 
		foreach ($this->noms as &$nom) {
20 jpm 807 
			if ($nom['epithete_infra_sp'] != '') {
808 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
809 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
810 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
811 
				}
812 
			}
813 
		}
177 jpm 814 
		return $noms_erreur;
20 jpm 815 
	}
816 
 
171 jpm 817 
	/**
818 
	 * Test #35
819 
	 */
64 jpm 820 
	private function testerEpitheteInfraSpSyntaxe() {
20 jpm 821 
		$noms_erreur = array();
64 jpm 822 
		foreach ($this->noms as &$nom) {
20 jpm 823 
			if ($nom['epithete_infra_sp'] != '') {
824 
				$mots = explode(' ', $nom['epithete_infra_sp']);
825 
				foreach ($mots as $mot) {
826 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
827 
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
828 
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
829 
					}
830 
				}
831 
			}
832 
		}
177 jpm 833 
		return $noms_erreur;
20 jpm 834 
	}
835 
 
171 jpm 836 
	/**
837 
	 * Test #36
838 
	 */
64 jpm 839 
	private function testerEpitheteInfraSpRang() {
20 jpm 840 
		$noms_erreur = array();
64 jpm 841 
		foreach ($this->noms as &$nom) {
20 jpm 842 
			if ($nom['epithete_infra_sp'] != '') {
843 
				if ($nom['rang'] < $this->manuel['rang_sp']) {
149 jpm 844 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 845 
				}
846 
			}
847 
		}
177 jpm 848 
		return $noms_erreur;
20 jpm 849 
	}
850 
 
173 jpm 851 
	/**
852 
	 * Test #37
853 
	 */
854 
	private function testerGroupeCultivarSyntaxe() {
20 jpm 855 
		$noms_erreur = array();
64 jpm 856 
		foreach ($this->noms as &$nom) {
173 jpm 857 
			if ($nom['cultivar_groupe'] != '') {
858 
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
859 
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
860 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
20 jpm 861 
				}
862 
			}
863 
		}
177 jpm 864 
		return $noms_erreur;
20 jpm 865 
	}
866 
 
173 jpm 867 
	/**
868 
	 * Test #38
869 
	 */
870 
	private function testerGroupeCultivarRang() {
20 jpm 871 
		$noms_erreur = array();
64 jpm 872 
		foreach ($this->noms as &$nom) {
173 jpm 873 
			if ($nom['cultivar_groupe'] != '') {
874 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
875 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 876 
				}
877 
			}
878 
		}
177 jpm 879 
		return $noms_erreur;
20 jpm 880 
	}
881 
 
173 jpm 882 
	/**
883 
	 * Test #39
884 
	 */
885 
	private function testerCultivarSyntaxe() {
20 jpm 886 
		$noms_erreur = array();
64 jpm 887 
		foreach ($this->noms as &$nom) {
173 jpm 888 
			if ($nom['cultivar'] != '') {
889 
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
890 
					$epithete_traite = $this->repererEspace($nom['cultivar']);
891 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
20 jpm 892 
				}
893 
			}
894 
		}
177 jpm 895 
		return $noms_erreur;
20 jpm 896 
	}
897 
 
173 jpm 898 
	/**
899 
	 * Test #40
900 
	 */
901 
	private function testerCultivarRang() {
20 jpm 902 
		$noms_erreur = array();
64 jpm 903 
		foreach ($this->noms as &$nom) {
173 jpm 904 
			if ($nom['cultivar'] != '') {
905 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
906 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
171 jpm 907 
				}
20 jpm 908 
			}
909 
		}
177 jpm 910 
		return $noms_erreur;
20 jpm 911 
	}
912 
 
173 jpm 913 
	/**
914 
	 * Test #41
915 
	 */
916 
	private function testerNomCommercialSyntaxe() {
20 jpm 917 
		$noms_erreur = array();
64 jpm 918 
		foreach ($this->noms as &$nom) {
173 jpm 919 
			if ($nom['nom_commercial'] != '') {
920 
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
921 
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
922 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
171 jpm 923 
				}
20 jpm 924 
			}
925 
		}
177 jpm 926 
		return $noms_erreur;
20 jpm 927 
	}
928 
 
173 jpm 929 
	/**
930 
	 * Test #42
931 
	 */
932 
	private function testerNomCommercialPresenceCultivar() {
20 jpm 933 
		$noms_erreur = array();
64 jpm 934 
		foreach ($this->noms as &$nom) {
173 jpm 935 
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
936 
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci']);
20 jpm 937 
			}
938 
		}
177 jpm 939 
		return $noms_erreur;
20 jpm 940 
	}
941 
 
173 jpm 942 
	/**
943 
	 * Test #43
944 
	 */
945 
	private function testerAuteurSyntaxe() {
20 jpm 946 
		$noms_erreur = array();
64 jpm 947 
		foreach ($this->noms as &$nom) {
173 jpm 948 
			if ($nom['auteur'] != '') {
949 
				if (!$this->verifierAuteur($nom['auteur'])) {
950 
					$intitule_traite = $this->repererEspace($nom['auteur']);
951 
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite);
171 jpm 952 
				}
20 jpm 953 
			}
954 
		}
177 jpm 955 
		return $noms_erreur;
20 jpm 956 
	}
957 
 
173 jpm 958 
	/**
959 
	 * Test #44
960 
	 */
961 
	private function testerAnneeSyntaxe() {
20 jpm 962 
		$noms_erreur = array();
64 jpm 963 
		foreach ($this->noms as &$nom) {
173 jpm 964 
			if ($nom['annee'] != '') {
965 
				if (!$this->verifierAnnee($nom['annee'])) {
966 
					$noms_erreur[] = array($nom['num_nom'], $nom['annee']);
171 jpm 967 
				}
20 jpm 968 
			}
969 
		}
177 jpm 970 
		return $noms_erreur;
20 jpm 971 
	}
972 
 
173 jpm 973 
	/**
974 
	 * Test #45
975 
	 */
976 
	private function testerBiblioOrigineSyntaxe() {
20 jpm 977 
		$noms_erreur = array();
64 jpm 978 
		foreach ($this->noms as &$nom) {
173 jpm 979 
			if ($nom['biblio_origine'] != '') {
980 
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
981 
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
982 
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite);
20 jpm 983 
				}
984 
			}
985 
		}
177 jpm 986 
		return $noms_erreur;
20 jpm 987 
	}
988 
 
173 jpm 989 
	/**
990 
	 * Test #46
991 
	 */
992 
	private function testerHomonymieSyntaxe() {
20 jpm 993 
		$noms_erreur = array();
173 jpm 994 
		foreach ($this->noms as &$nom) {
995 
			if ($nom['homonyme'] != '') {
996 
				if (!$this->verifierBooleen($nom['homonyme'])) {
997 
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme']);
161 jpm 998 
				}
20 jpm 999 
			}
1000 
		}
177 jpm 1001 
		return $noms_erreur;
20 jpm 1002 
	}
1003 
 
173 jpm 1004 
	/**
1005 
	 * Test #47
1006 
	 */
1007 
	private function testerHomonymieExistence() {
1008 
		$noms_homonymie = $this->classerNomsParNomComplet();
1009 
 
20 jpm 1010 
		$noms_erreur = array();
64 jpm 1011 
		foreach ($this->noms as &$nom) {
173 jpm 1012 
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
1013 
				if ($noms_homonymie[$nom['nom_sci']] <= 1) {
1014 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci']);
171 jpm 1015 
				}
20 jpm 1016 
			}
1017 
		}
173 jpm 1018 
		$noms_homonymie = null;
177 jpm 1019 
		return $noms_erreur;
20 jpm 1020 
	}
1021 
 
173 jpm 1022 
	/**
1023 
	 * Test #48
1024 
	 */
1025 
	private function testerBasionymeSyntaxe() {
20 jpm 1026 
		$noms_erreur = array();
64 jpm 1027 
		foreach ($this->noms as &$nom) {
173 jpm 1028 
			if ($nom['basionyme'] != '') {
1029 
				if (!$this->verifierNombre($nom['basionyme'])) {
1030 
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
20 jpm 1031 
				}
1032 
			}
1033 
		}
177 jpm 1034 
		return $noms_erreur;
20 jpm 1035 
	}
173 jpm 1036 
 
1037 
	/**
1038 
	 * Test #49
1039 
	 */
1040 
	private function testerBasionymeExistence() {
20 jpm 1041 
		$noms_erreur = array();
64 jpm 1042 
		foreach ($this->noms as &$nom) {
173 jpm 1043 
			if ($nom['basionyme'] != '') {
1044 
				if (!isset($this->noms[$nom['basionyme']])) {
1045 
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
1046 
				}
20 jpm 1047 
			}
1048 
		}
177 jpm 1049 
		return $noms_erreur;
20 jpm 1050 
	}
1051 
 
173 jpm 1052 
	/**
1053 
	 * Test #50
1054 
	 */
1055 
	private function testerSynonymeProparteSyntaxe() {
20 jpm 1056 
		$noms_erreur = array();
64 jpm 1057 
		foreach ($this->noms as &$nom) {
171 jpm 1058 
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1059 
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
1060 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte']);
20 jpm 1061 
				}
1062 
			}
1063 
		}
177 jpm 1064 
		return $noms_erreur;
20 jpm 1065 
	}
1066 
 
173 jpm 1067 
	/**
1068 
	 * Test #51
1069 
	 */
1070 
	private function testerSynonymeProparteExistence() {
20 jpm 1071 
		$noms_erreur = array();
64 jpm 1072 
		foreach ($this->noms as &$nom) {
171 jpm 1073 
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1074 
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
1075 
				$num_nom_en_erreur = array();
1076 
				foreach ($num_nom_a_verifier as $num_nom) {
1077 
					if (!isset($this->noms[$num_nom])) {
1078 
						$num_nom_en_erreur[] = $num_nom;
1079 
					}
20 jpm 1080 
				}
173 jpm 1081 
				if (count($nbre_en_erreur) > 0) {
1082 
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur));
1083 
				}
20 jpm 1084 
			}
1085 
		}
177 jpm 1086 
		return $noms_erreur;
20 jpm 1087 
	}
1088 
 
173 jpm 1089 
	/**
1090 
	 * Test #52
1091 
	 */
1092 
	private function testerSynonymeDouteuxSyntaxe() {
20 jpm 1093 
		$noms_erreur = array();
64 jpm 1094 
		foreach ($this->noms as &$nom) {
173 jpm 1095 
			if ($nom['synonyme_douteux'] != '') {
1096 
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
1097 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux']);
20 jpm 1098 
				}
1099 
			}
1100 
		}
177 jpm 1101 
		return $noms_erreur;
20 jpm 1102 
	}
1103 
 
173 jpm 1104 
	/**
1105 
	 * Test #53
1106 
	 */
1107 
	private function testerSynonymeDouteuxNumNomRetenu() {
20 jpm 1108 
		$noms_erreur = array();
64 jpm 1109 
		foreach ($this->noms as &$nom) {
173 jpm 1110 
			if ($nom['synonyme_douteux'] == 1 && $nom['num_nom_retenu'] != ' ') {
1111 
				$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['num_nom_retenu']);
20 jpm 1112 
			}
1113 
		}
177 jpm 1114 
		return $noms_erreur;
20 jpm 1115 
	}
1116 
 
171 jpm 1117 
	/**
173 jpm 1118 
	 * Test #54
171 jpm 1119 
	 */
173 jpm 1120 
	private function testerSynonymeMalAppliqueSyntaxe() {
20 jpm 1121 
		$noms_erreur = array();
64 jpm 1122 
		foreach ($this->noms as &$nom) {
173 jpm 1123 
			if ($nom['synonyme_mal_applique'] != '') {
1124 
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
1125 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique']);
20 jpm 1126 
				}
1127 
			}
1128 
		}
177 jpm 1129 
		return $noms_erreur;
20 jpm 1130 
	}
1131 
 
171 jpm 1132 
	/**
173 jpm 1133 
	 * Test #55
171 jpm 1134 
	 */
173 jpm 1135 
	private function testerSynonymeOrthographiqueSyntaxe() {
20 jpm 1136 
		$noms_erreur = array();
173 jpm 1137 
		foreach ($this->noms as $nom) {
1138 
			if ($nom['synonyme_orthographique'] != '') {
1139 
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
1140 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique']);
20 jpm 1141 
				}
1142 
			}
1143 
		}
177 jpm 1144 
		return $noms_erreur;
20 jpm 1145 
	}
1146 
 
171 jpm 1147 
	/**
173 jpm 1148 
	 * Test #56
171 jpm 1149 
	 */
173 jpm 1150 
	private function testerSynonymeOrthographiqueExistence() {
20 jpm 1151 
		$noms_erreur = array();
64 jpm 1152 
		foreach ($this->noms as &$nom) {
173 jpm 1153 
			if ($nom['synonyme_orthographique'] != '') {
1154 
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
1155 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique']);
20 jpm 1156 
				}
1157 
			}
1158 
		}
177 jpm 1159 
		return $noms_erreur;
20 jpm 1160 
	}
1161 
 
171 jpm 1162 
	/**
173 jpm 1163 
	 * Test #57
171 jpm 1164 
	 */
173 jpm 1165 
	private function testerHybrideParent01Syntaxe() {
20 jpm 1166 
		$noms_erreur = array();
64 jpm 1167 
		foreach ($this->noms as &$nom) {
173 jpm 1168 
			if ($nom['hybride_parent_01'] != '') {
1169 
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
1170 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']));
20 jpm 1171 
				}
1172 
			}
1173 
		}
177 jpm 1174 
		return $noms_erreur;
20 jpm 1175 
	}
1176 
 
171 jpm 1177 
	/**
173 jpm 1178 
	 * Test #58
171 jpm 1179 
	 */
173 jpm 1180 
	private function testerHybrideParent01Existence() {
20 jpm 1181 
		$noms_erreur = array();
64 jpm 1182 
		foreach ($this->noms as &$nom) {
173 jpm 1183 
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1184 
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
1185 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']));
20 jpm 1186 
				}
1187 
			}
1188 
		}
177 jpm 1189 
		return $noms_erreur;
20 jpm 1190 
	}
171 jpm 1191 
 
1192 
	/**
173 jpm 1193 
	 * Test #59
171 jpm 1194 
	 */
173 jpm 1195 
	private function testerHybrideParent02Syntaxe() {
20 jpm 1196 
		$noms_erreur = array();
64 jpm 1197 
		foreach ($this->noms as &$nom) {
173 jpm 1198 
			if ($nom['hybride_parent_02'] != '') {
1199 
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
1200 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']));
1201 
				}
20 jpm 1202 
			}
1203 
		}
177 jpm 1204 
		return $noms_erreur;
20 jpm 1205 
	}
1206 
 
171 jpm 1207 
	/**
173 jpm 1208 
	 * Test #60
171 jpm 1209 
	 */
173 jpm 1210 
	private function testerHybrideParent02Existence() {
20 jpm 1211 
		$noms_erreur = array();
64 jpm 1212 
		foreach ($this->noms as &$nom) {
173 jpm 1213 
			if ($nom['hybride_parent_02'] != '') {
1214 
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
1215 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']));
20 jpm 1216 
				}
1217 
			}
1218 
		}
177 jpm 1219 
		return $noms_erreur;
20 jpm 1220 
	}
1221 
 
171 jpm 1222 
	/**
173 jpm 1223 
	 * Test #61
171 jpm 1224 
	 */
173 jpm 1225 
	private function testerPresenceSyntaxe() {
20 jpm 1226 
		$noms_erreur = array();
64 jpm 1227 
		foreach ($this->noms as &$nom) {
173 jpm 1228 
			if ($nom['presence'] != '') {
1229 
				if (!$this->verifierPresence($nom['presence'])) {
1230 
					$noms_erreur[] = array($nom['num_nom'], $nom['presence']);
20 jpm 1231 
				}
1232 
			}
1233 
		}
177 jpm 1234 
		return $noms_erreur;
20 jpm 1235 
	}
1236 
 
171 jpm 1237 
	/**
173 jpm 1238 
	 * Test #62
171 jpm 1239 
	 */
173 jpm 1240 
	private function testerStatutOrigineSyntaxe() {
20 jpm 1241 
		$noms_erreur = array();
64 jpm 1242 
		foreach ($this->noms as &$nom) {
173 jpm 1243 
			if ($nom['statut_origine'] != '') {
1244 
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
1245 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine']);
20 jpm 1246 
				}
1247 
			}
1248 
		}
177 jpm 1249 
		return $noms_erreur;
20 jpm 1250 
	}
1251 
 
171 jpm 1252 
	/**
173 jpm 1253 
	 * Test #63
171 jpm 1254 
	 */
173 jpm 1255 
	private function testerStatutIntroductionSyntaxe() {
20 jpm 1256 
		$noms_erreur = array();
64 jpm 1257 
		foreach ($this->noms as &$nom) {
173 jpm 1258 
			if ($nom['statut_introduction'] != '') {
1259 
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
1260 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction']);
20 jpm 1261 
				}
1262 
			}
1263 
		}
177 jpm 1264 
		return $noms_erreur;
20 jpm 1265 
	}
1266 
 
171 jpm 1267 
	/**
173 jpm 1268 
	 * Test #64
171 jpm 1269 
	 */
173 jpm 1270 
	private function testerStatutCultureSyntaxe() {
20 jpm 1271 
		$noms_erreur = array();
64 jpm 1272 
		foreach ($this->noms as &$nom) {
173 jpm 1273 
			if ($nom['statut_culture'] != '') {
1274 
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
1275 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture']);
20 jpm 1276 
				}
1277 
			}
1278 
		}
177 jpm 1279 
		return $noms_erreur;
20 jpm 1280 
	}
1281 
 
171 jpm 1282 
	/**
1283 
	 * Test #65
1284 
	 */
146 delphine 1285 
	private function testerExclureTaxRefSyntaxe() {
1286 
		$noms_erreur = array();
1287 
		foreach ($this->noms as &$nom) {
1288 
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
1289 
				if (!$this->verifierBooleen($nom['exclure_taxref'])) {
1290 
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
1291 
				}
1292 
			}
1293 
		}
177 jpm 1294 
		return $noms_erreur;
146 delphine 1295 
	}
171 jpm 1296 
 
1297 
 
1298 
 
20 jpm 1299 
	//+--------------------------------------------------------------------------------------------------------------+//
1300 
	// MÉTHODES COMMUNES aux TESTS
1301 
 
64 jpm 1302 
	private function verifierPresence(&$valeur) {
20 jpm 1303 
		$codes = $this->manuel['codes_presence'];
1304 
		$ok = $this->verifierStatuts($valeur, $codes);
1305 
		return $ok;
1306 
	}
1307 
 
64 jpm 1308 
	private function verifierStatutOrigine(&$valeur) {
20 jpm 1309 
		$codes = $this->manuel['codes_statuts_origine'];
1310 
		$ok = $this->verifierStatuts($valeur, $codes);
1311 
		return $ok;
1312 
	}
1313 
 
64 jpm 1314 
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 1315 
		$codes = $this->manuel['codes_statuts_introduction'];
1316 
		$ok = $this->verifierStatuts($valeur, $codes);
1317 
		return $ok;
1318 
	}
1319 
 
64 jpm 1320 
	private function verifierStatutCulture(&$valeur) {
20 jpm 1321 
		$codes = $this->manuel['codes_statuts_culture'];
1322 
		$ok = $this->verifierStatuts($valeur, $codes);
1323 
		return $ok;
1324 
	}
1325 
 
64 jpm 1326 
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 1327 
		$ok = true;
1328 
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
1329 
			$ok = false;
1330 
		}
1331 
		return $ok;
1332 
	}
1333 
 
64 jpm 1334 
	private function verifierBooleen(&$valeur) {
20 jpm 1335 
		$ok = true;
1336 
		if (!preg_match('/^1$/', $valeur)) {
1337 
			$ok = false;
1338 
		}
1339 
		return $ok;
1340 
	}
1341 
 
64 jpm 1342 
	private function verifierNombre(&$valeur) {
20 jpm 1343 
		$ok = true;
1344 
		if (!preg_match('/^[0-9]+$/', $valeur)) {
1345 
			$ok = false;
1346 
		}
1347 
		return $ok;
1348 
	}
1349 
 
64 jpm 1350 
	private function verifierNombreSuite(&$valeur) {
20 jpm 1351 
		$ok = true;
1352 
		if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
1353 
			$ok = false;
1354 
		}
1355 
		return $ok;
1356 
	}
1357 
 
64 jpm 1358 
	private function verifierTypeEpithete(&$type) {
20 jpm 1359 
		$ok = false;
1360 
		$rejetes = $this->manuel['type_epithete_rejetes'];
1361 
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
1362 
			$ok = false;
1363 
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
1364 
			$ok = true;
1365 
		}
1366 
		return $ok;
1367 
	}
1368 
 
64 jpm 1369 
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 1370 
		$ok = true;
1371 
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1372 
			$ok = false;// Contient des espaces en trop
1373 
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
1374 
			$ok = false;
1375 
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
1376 
			$ok = false;// Contient une mauvaise suite de caractères
1377 
		}
1378 
		return $ok;
1379 
	}
1380 
 
64 jpm 1381 
	private function verifierAnnee(&$annee) {
20 jpm 1382 
		$ok = true;
1383 
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
1384 
			$ok = false;
1385 
		} else if ($annee < 1753) {
1386 
			$ok = false;
1387 
		}
1388 
		return $ok;
1389 
	}
1390 
 
64 jpm 1391 
	private function verifierAuteur(&$intitule) {
20 jpm 1392 
		$ok = true;
1393 
		$acceptes = $this->manuel['auteur_acceptes'];
1394 
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
1395 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1396 
				$ok = false;// Contient des espaces en trop
1397 
			} else {
1398 
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
1399 
				$mots = explode(' ', $intitule);
1400 
				foreach ($mots as $position => $mot) {
1401 
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1402 
						$ok = false;// Mot rejeté
1403 
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\)-])+|[&])$/u", $mot)) {
1404 
						continue;// Mot de l'intitulé auteur
1405 
					} else {
1406 
						$ok = false;
1407 
					}
1408 
				}
1409 
			}
1410 
		}
1411 
		return $ok;
1412 
	}
1413 
 
64 jpm 1414 
	private function verifierNomCommercial(&$epithete) {
20 jpm 1415 
		$ok = false;
1416 
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
1417 
			$ok = true;
1418 
		}
1419 
		return $ok;
1420 
	}
1421 
 
64 jpm 1422 
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 1423 
		$ok = true;
1424 
		$acceptes = $this->manuel['cultivar_acceptes'];
1425 
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1426 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1427 
				$ok = false;// Contient des espaces en trop
1428 
			} else {
1429 
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
1430 
				$mots_mineurs = $this->manuel['mots_mineurs'];
1431 
				$mots = explode(' ', $epithete);
1432 
				foreach ($mots as $position => $mot) {
1433 
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1434 
						$ok = false;// Mot rejeté
1435 
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1436 
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1437 
					} else {
1438 
						$mots_tiret = explode('-', $mot);
1439 
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1440 
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1441 
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
1442 
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1443 
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
1444 
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1445 
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1446 
							} else {
1447 
								$ok = false;
1448 
							}
1449 
						}
1450 
					}
1451 
				}
1452 
			}
1453 
		}
1454 
		return $ok;
1455 
	}
1456 
 
64 jpm 1457 
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 1458 
		$ok = true;
1459 
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
1460 
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1461 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1462 
				$ok = false;// Contient des espaces en trop
1463 
			} else {
1464 
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
1465 
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
1466 
				$mots_mineurs = $this->manuel['mots_mineurs'];
1467 
				$mots = explode(' ', $epithete);
1468 
				foreach ($mots as $position => $mot) {
1469 
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
1470 
						continue;// Mot accepté
1471 
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1472 
						$ok = false;// Mot rejeté
1473 
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1474 
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1475 
					} else {
1476 
						$mots_tiret = explode('-', $mot);
1477 
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1478 
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1479 
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
1480 
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1481 
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
1482 
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1483 
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1484 
							} else {
1485 
								$ok = false;
1486 
							}
1487 
						}
1488 
					}
1489 
				}
1490 
			}
1491 
		}
1492 
		return $ok;
1493 
	}
1494 
 
64 jpm 1495 
	private function verifierEpitheteSp(&$epithete) {
20 jpm 1496 
		$ok = false;
1497 
		if (preg_match('/^[a-zëï][-a-zëï]+$/', $epithete)) {
1498 
			$ok = true;
1499 
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
1500 
			$ok = true;
1501 
		}
1502 
		return $ok;
1503 
	}
1504 
 
64 jpm 1505 
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 1506 
		$ok = false;
1507 
		if (preg_match('/^[A-ZËÏ](?:[-a-zëï]+|[a-zëï]+-[A-ZËÏ][a-zëï]+)$/', $epithete)) {
1508 
			$ok = true;
1509 
		}
1510 
		return $ok;
1511 
	}
1512 
 
64 jpm 1513 
	private function formaterStyleNomGenre(&$genre) {
20 jpm 1514 
		$genre_fmt = '';
1515 
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
1516 
			$genre_fmt = strtolower($match[1]).' '.ucfirst(strtolower($match[2]));
1517 
		} else {
1518 
			$genre_fmt = ucfirst(strtolower($genre));
1519 
		}
1520 
		return $genre_fmt;
1521 
	}
1522 
 
149 jpm 1523 
	private function repererEspace($nom_sci) {
1524 
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
1525 
		return $nom_sci;
20 jpm 1526 
	}
1527 
 
64 jpm 1528 
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 1529 
		$suffixe = array();
1530 
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
1531 
		$suffixe[] = $this->construireNomCommercial($nom);
1532 
		$suffixe[] = $this->construireNomCultivar($nom);
1533 
		$suffixe = array_filter($suffixe);
1534 
		return implode(' ', $suffixe);
1535 
	}
1536 
 
64 jpm 1537 
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 1538 
		$nom_groupe_cultivar = '';
1539 
		if ($nom['cultivar_groupe'] != '') {
1540 
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
1541 
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
1542 
			} else {
1543 
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
1544 
			}
1545 
		}
1546 
		return $nom_groupe_cultivar;
1547 
	}
1548 
 
64 jpm 1549 
	private function construireNomCommercial(&$nom) {
20 jpm 1550 
		$nom_commercial = '';
1551 
		if ($nom['nom_commercial'] != '') {
1552 
			$nom_commercial =  strtoupper($nom['nom_commercial']);
1553 
		}
1554 
		return $nom_commercial;
1555 
	}
1556 
 
64 jpm 1557 
	private function construireNomCultivar(&$nom) {
20 jpm 1558 
		$nom_cultivar = '';
1559 
		if ($nom['cultivar'] != '') {
1560 
			$nom_cultivar =  "'".$nom['cultivar']."'";
1561 
		}
1562 
		return $nom_cultivar;
1563 
	}
1564 
 
64 jpm 1565 
	private function classerNomsParNomComplet() {
20 jpm 1566 
		$noms_classes = array();
64 jpm 1567 
		foreach ($this->noms as &$nom) {
149 jpm 1568 
			if (!isset($noms_classes[$nom['nom_sci']])) {
1569 
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 1570 
			} else {
149 jpm 1571 
				$noms_classes[$nom['nom_sci']]++;
20 jpm 1572 
			}
1573 
		}
1574 
		return $noms_classes;
1575 
	}
1576 
 
171 jpm 1577 
	private function getInfosTest($numero) {
1578 
		$info = $this->tests[$numero];
175 jpm 1579 
		$info['methode'] = 'tester'.implode('', explode(' ', ucwords($info['abr'])));
171 jpm 1580 
		$info['numero'] = $numero;
1581 
		$info['resultat'] = false;
1582 
		return $info;
1583 
	}
20 jpm 1584 
}
1585 
?>