Subversion Repositories Applications.referentiel

Rev

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