Subversion Repositories Applications.referentiel

Rev

Rev 252 | Rev 255 | 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;
165 delphine 78 
				case 'test11' :
79 
					$this->recupererDonnees();
80 
					Debug::printr('Départ lancement test 11 :');
199 delphine 81 
					$this->testerExitenceTaxonSuperieurTransmis();
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 
	/**
199 delphine 447 
	 * Test #14
171 jpm 448 
	 */
199 delphine 449 
	private function testerTransmissionTaxonSuperieur() {
450 
		$noms_erreur = array();
451 
		foreach ($this->noms as &$nom) {
452 
			if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0) {
453 
				if ($nom['num_tax_sup'] != 0 && isset($this->noms[$nom['num_tax_sup']])) {
454 
					if ($this->noms[$nom['num_tax_sup']]['exclure_taxref'] != 0) {
455 
						$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $this->noms[$nom['num_tax_sup']]['exclure_taxref']);
456 
					}
457 
				}
458 
			}
459 
		}
460 
		return $noms_erreur;
461 
	}
462 
 
463 
 
464 
	/**
465 
	 * Test #15
466 
	 */
171 jpm 467 
	private function testerClassificationRang() {
20 jpm 468 
		$noms_erreur = array();
64 jpm 469 
		foreach ($this->noms as &$nom) {
171 jpm 470 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
471 
				if (isset($this->noms[$nom['num_tax_sup']])) {
472 
					$nom_sup = $this->noms[$nom['num_tax_sup']];
473 
					if ($nom_sup['rang'] >= $nom['rang']) {
474 
						// Prise en compte de l'exception des clades
475 
						if (! ($nom_sup['rang'] == 70 && $nom['rang'] == 70)) {
183 jpm 476 
							$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang'], $nom['exclure_taxref']);
171 jpm 477 
						}
478 
					}
20 jpm 479 
				}
480 
			}
481 
		}
176 jpm 482 
		return $noms_erreur;
20 jpm 483 
	}
484 
 
171 jpm 485 
	/**
199 delphine 486 
	 * Test #16
171 jpm 487 
	 */
488 
	private function testerClassification() {
20 jpm 489 
		$noms_erreur = array();
171 jpm 490 
		$this->noms_ok = array();
64 jpm 491 
		foreach ($this->noms as &$nom) {
171 jpm 492 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
493 
				if (isset($this->noms_ok[$nom['num_tax_sup']])) {
494 
					$this->noms_ok[$nom['num_nom']] = true;
495 
				} else {
496 
					$this->detection_boucle_infini = array();
497 
					$classif_ok = $this->remonterClassif($nom);
498 
					unset($this->detection_boucle_infini);
499 
 
175 jpm 500 
					if ($classif_ok === true) {
501 
						$this->noms_ok[$nom['num_nom']] = $classif_ok;
171 jpm 502 
					} else {
183 jpm 503 
						$noms_erreur[] = array($nom['num_nom'], $classif_ok, $nom['exclure_taxref']);
171 jpm 504 
					}
20 jpm 505 
				}
506 
			}
507 
		}
171 jpm 508 
		unset($this->noms_ok);
176 jpm 509 
		return $noms_erreur;
20 jpm 510 
	}
511 
 
171 jpm 512 
	private function remonterClassif(&$nom) {
513 
		$this->detection_boucle_infini[$nom['num_nom']] = true;
514 
		if (preg_match('/^[0-9]*$/', $nom['num_tax_sup'])) {
515 
			if (isset($this->noms_ok[$nom['num_tax_sup']])) {
516 
				$this->noms_ok[$nom['num_nom']] = true;
517 
				return true;
518 
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
519 
				$this->noms_ok[$nom['num_nom']] = true;
520 
				return true;
521 
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
175 jpm 522 
				return 'Hiérarchie avec le taxon #'.$nom['num_nom'].' ayant un taxon superieur #'.$nom['num_tax_sup'].' inexistant';
171 jpm 523 
			} else if (isset($this->detection_boucle_infini[$nom['num_tax_sup']])) {
175 jpm 524 
				return 'Boucle infinie pour le taxon #'.$nom['num_tax_sup'];
171 jpm 525 
			} else {
526 
				$retour = $this->remonterClassif($this->noms[$nom['num_tax_sup']]);
527 
				if ($retour === true) {
528 
					$this->noms_ok[$nom['num_tax_sup']] = true;
529 
				}
530 
				return $retour;
531 
			}
532 
		} else {
175 jpm 533 
			return 'Valeur num_tax_sup incorrecte : '.$nom['num_tax_sup'];
171 jpm 534 
		}
535 
	}
536 
 
537 
	/**
199 delphine 538 
	 * Test #17
171 jpm 539 
	 */
540 
	private function testerRang() {
541 
		$rangs = array_flip(explode(',', $this->manuel['rangs']));
542 
 
20 jpm 543 
		// Réalisation du test
544 
		$noms_erreur = array();
64 jpm 545 
		foreach ($this->noms as &$nom) {
171 jpm 546 
			if (!isset($rangs[$nom['rang']])) {
183 jpm 547 
				$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 548 
			}
549 
		}
176 jpm 550 
		return $noms_erreur;
20 jpm 551 
	}
552 
 
171 jpm 553 
	/**
199 delphine 554 
	 * Test #18
171 jpm 555 
	 */
556 
	private function testerNomCompletSupraGenerique() {
20 jpm 557 
		$noms_erreur = array();
64 jpm 558 
		foreach ($this->noms as &$nom) {
171 jpm 559 
			if ($nom['rang'] < $this->manuel['rang_genre']) {
560 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
561 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
562 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
563 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
564 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 565 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 566 
				}
567 
			}
568 
		}
176 jpm 569 
		return $noms_erreur;
20 jpm 570 
	}
571 
 
171 jpm 572 
	/**
199 delphine 573 
	 * Test #19
171 jpm 574 
	 */
575 
	private function testerNomCompletGenre() {
20 jpm 576 
		$noms_erreur = array();
171 jpm 577 
		foreach ($this->noms as &$nom) {
578 
			if ($nom['rang'] == $this->manuel['rang_genre']) {
579 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
580 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
581 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
582 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
583 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 584 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 585 
				}
586 
			}
587 
		}
176 jpm 588 
		return $noms_erreur;
20 jpm 589 
	}
590 
 
171 jpm 591 
	/**
199 delphine 592 
	 * Test #20
171 jpm 593 
	 */
594 
	private function testerNomCompletInfraGenre() {
20 jpm 595 
		$noms_erreur = array();
64 jpm 596 
		foreach ($this->noms as &$nom) {
171 jpm 597 
			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
598 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
599 
				$nom_sci_ideal = '';
600 
				if ($nom['type_epithete'] == 'agg.') {
250 delphine 601 
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
602 
						$this->formaterStyleNomGenre($nom['epithete_infra_generique']).' '.
603 
						$nom['type_epithete'];
171 jpm 604 
				} else {
250 delphine 605 
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
606 
						$nom['type_epithete'].' '.
607 
						$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
20 jpm 608 
				}
171 jpm 609 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
610 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
611 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 612 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
171 jpm 613 
				}
20 jpm 614 
			}
615 
		}
176 jpm 616 
		return $noms_erreur;
20 jpm 617 
	}
618 
 
171 jpm 619 
	/**
199 delphine 620 
	 * Test #21
171 jpm 621 
	 */
622 
	private function testerNomCompletEspece() {
20 jpm 623 
		$noms_erreur = array();
250 delphine 624 
		$erreur = '';
64 jpm 625 
		foreach ($this->noms as &$nom) {
171 jpm 626 
			if ($nom['rang'] == $this->manuel['rang_sp']) {
627 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
250 delphine 628 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' ';
629 
				if (strstr($nom['nom_sci'] , ' x ') != false) {
630 
					list($nom_sci_ideal, $erreur) = $this->formaterStyleEpitheteSpHybride($nom_sci_ideal, $nom['epithete_sp']);
631 
				} else {
632 
					$nom_sci_ideal .= utf8_encode(strtolower(utf8_decode($nom['epithete_sp'])));
633 
				}
171 jpm 634 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
194 delphine 635 
				$nom_sci_ideal = trim($nom_sci_ideal);
171 jpm 636 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
637 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
250 delphine 638 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $erreur, $nom['exclure_taxref']);
20 jpm 639 
				}
640 
			}
641 
		}
176 jpm 642 
		return $noms_erreur;
20 jpm 643 
	}
644 
 
171 jpm 645 
	/**
199 delphine 646 
	 * Test #22
171 jpm 647 
	 */
648 
	private function testerNomCompletInfraSpecifique() {
158 delphine 649 
		$noms_erreur = array();
254 aurelien 650 
		$erreur = null;
158 delphine 651 
		foreach ($this->noms as &$nom) {
171 jpm 652 
			if ($nom['rang'] > $this->manuel['rang_sp']) {
250 delphine 653 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '.
654 
					utf8_encode(strtolower(utf8_decode($nom['epithete_sp']))).' '.
655 
					utf8_encode(strtolower(utf8_decode($nom['type_epithete']))).' ';
171 jpm 656 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
250 delphine 657 
				if (strstr($nom['nom_sci'] , ' x ') != false) {
658 
					list($nom_sci_ideal, $erreur) = $this->formaterStyleEpitheteInfraSpHybride($nom_sci_ideal, $nom['epithete_infra_sp'], $nom['genre']);
659 
				} else {
660 
					$nom_sci_ideal .= utf8_encode(strtolower(utf8_decode($nom['epithete_infra_sp'])));
661 
				}
662 
				$nom_sci_ideal = trim($nom_sci_ideal);
171 jpm 663 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
664 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
665 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
250 delphine 666 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $erreur, $nom['exclure_taxref']);
171 jpm 667 
				}
158 delphine 668 
			}
669 
		}
176 jpm 670 
		return $noms_erreur;
158 delphine 671 
	}
672 
 
171 jpm 673 
	/**
199 delphine 674 
	 * Test #23
171 jpm 675 
	 */
676 
	private function testerNomSupraGeneriqueEspaces() {
20 jpm 677 
		$noms_erreur = array();
64 jpm 678 
		foreach ($this->noms as &$nom) {
171 jpm 679 
			if ($nom['nom_supra_generique'] != '') {
680 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
681 
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 682 
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 683 
				}
684 
			}
685 
		}
176 jpm 686 
		return $noms_erreur;
20 jpm 687 
	}
688 
 
171 jpm 689 
	/**
199 delphine 690 
	 * Test #24
171 jpm 691 
	 */
692 
	private function testerNomSupraGeneriqueSyntaxe() {
20 jpm 693 
		$noms_erreur = array();
64 jpm 694 
		foreach ($this->noms as &$nom) {
171 jpm 695 
			if ($nom['nom_supra_generique'] != '') {
696 
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
697 
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 698 
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 699 
				}
700 
			}
701 
		}
177 jpm 702 
		return $noms_erreur;
20 jpm 703 
	}
704 
 
171 jpm 705 
	/**
199 delphine 706 
	 * Test #25
171 jpm 707 
	 */
708 
	private function testerNomSupraGeneriqueRang() {
20 jpm 709 
		$noms_erreur = array();
64 jpm 710 
		foreach ($this->noms as &$nom) {
171 jpm 711 
			if ($nom['nom_supra_generique'] != '') {
712 
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
183 jpm 713 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 714 
				}
715 
			}
716 
		}
177 jpm 717 
		return $noms_erreur;
20 jpm 718 
	}
719 
 
171 jpm 720 
	/**
199 delphine 721 
	 * Test #26
171 jpm 722 
	 */
723 
	private function testerGenreEspaces() {
20 jpm 724 
		$noms_erreur = array();
64 jpm 725 
		foreach ($this->noms as &$nom) {
171 jpm 726 
			if ($nom['genre'] != '') {
727 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
728 
					$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 729 
					$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
20 jpm 730 
				}
731 
			}
732 
		}
177 jpm 733 
		return $noms_erreur;
20 jpm 734 
	}
735 
 
171 jpm 736 
	/**
199 delphine 737 
	 * Test #27
171 jpm 738 
	 */
739 
	private function testerGenreSyntaxe() {
20 jpm 740 
		$noms_erreur = array();
64 jpm 741 
		foreach ($this->noms as &$nom) {
171 jpm 742 
			if ($nom['genre'] != '') {
743 
				$mots = explode(' ', $nom['genre']);
744 
				foreach ($mots as $mot) {
745 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
746 
						$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 747 
						$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
194 delphine 748 
						break;
171 jpm 749 
					}
20 jpm 750 
				}
751 
			}
752 
		}
177 jpm 753 
		return $noms_erreur;
20 jpm 754 
	}
755 
 
171 jpm 756 
	/**
199 delphine 757 
	 * Test #28
171 jpm 758 
	 */
759 
	private function testerGenreRang() {
20 jpm 760 
		$noms_erreur = array();
64 jpm 761 
		foreach ($this->noms as &$nom) {
171 jpm 762 
			if ($nom['genre'] != '') {
763 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 764 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 765 
				}
766 
			}
767 
		}
177 jpm 768 
		return $noms_erreur;
20 jpm 769 
	}
770 
 
171 jpm 771 
	/**
199 delphine 772 
	 * Test #29
171 jpm 773 
	 */
774 
	private function testerEpitheteInfraGeneriqueSyntaxe() {
20 jpm 775 
		$noms_erreur = array();
64 jpm 776 
		foreach ($this->noms as &$nom) {
171 jpm 777 
			if ($nom['epithete_infra_generique'] != '') {
778 
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
779 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 780 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 781 
				}
782 
			}
783 
		}
177 jpm 784 
		return $noms_erreur;
20 jpm 785 
	}
786 
 
171 jpm 787 
	/**
199 delphine 788 
	 * Test #30
171 jpm 789 
	 */
790 
	private function testerEpitheteInfraGeneriqueRang() {
20 jpm 791 
		$noms_erreur = array();
64 jpm 792 
		foreach ($this->noms as &$nom) {
171 jpm 793 
			if ($nom['epithete_infra_generique'] != '') {
794 
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
183 jpm 795 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 796 
				}
797 
			}
798 
		}
177 jpm 799 
		return $noms_erreur;
20 jpm 800 
	}
801 
 
171 jpm 802 
	/**
199 delphine 803 
	 * Test #31
171 jpm 804 
	 */
805 
	private function testerEpitheteInfraGeneriqueEspaces() {
20 jpm 806 
		$noms_erreur = array();
64 jpm 807 
		foreach ($this->noms as &$nom) {
171 jpm 808 
			if ($nom['epithete_infra_generique'] != '') {
809 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
810 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 811 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 812 
				}
813 
			}
814 
		}
177 jpm 815 
		return $noms_erreur;
20 jpm 816 
	}
817 
 
171 jpm 818 
	/**
199 delphine 819 
	 * Test #32
171 jpm 820 
	 */
821 
	private function testerEpitheteSpEspaces() {
20 jpm 822 
		$noms_erreur = array();
64 jpm 823 
		foreach ($this->noms as &$nom) {
171 jpm 824 
			if ($nom['epithete_sp'] != '') {
825 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
826 
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 827 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 828 
				}
829 
			}
830 
		}
177 jpm 831 
		return $noms_erreur;
20 jpm 832 
	}
833 
 
171 jpm 834 
	/**
199 delphine 835 
	 * Test #33
171 jpm 836 
	 */
837 
	private function testerEpitheteSpSyntaxe() {
20 jpm 838 
		$noms_erreur = array();
64 jpm 839 
		foreach ($this->noms as &$nom) {
171 jpm 840 
			if ($nom['epithete_sp'] != '') {
254 aurelien 841 
				$formule_hybridite = (strpos($nom['epithete_sp'], ' x ') !== false);
171 jpm 842 
				$mots = explode(' ', $nom['epithete_sp']);
843 
				foreach ($mots as $mot) {
252 aurelien 844 
					// TODO: créer un test qui vérifie la formule d'hybridité en la reconstruisant à partir des parents
845 
					// afin que seuls des formules valides parviennent à la fonction
254 aurelien 846 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot) ||
847 
						($formule_hybridite && $this->verifierEpitheteGenre($mot) && !$this->verifierEstAbbreviationInfraSp($mot)))) {
171 jpm 848 
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 849 
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
194 delphine 850 
						break;
171 jpm 851 
					}
852 
				}
20 jpm 853 
			}
854 
		}
177 jpm 855 
		return $noms_erreur;
20 jpm 856 
	}
857 
 
171 jpm 858 
	/**
199 delphine 859 
	 * Test #34
171 jpm 860 
	 */
861 
	private function testerEpitheteSpRang() {
20 jpm 862 
		$noms_erreur = array();
64 jpm 863 
		foreach ($this->noms as &$nom) {
171 jpm 864 
			if ($nom['epithete_sp'] != '') {
865 
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 866 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 867 
				}
868 
			}
869 
		}
177 jpm 870 
		return $noms_erreur;
20 jpm 871 
	}
872 
 
171 jpm 873 
	/**
199 delphine 874 
	 * Test #35
171 jpm 875 
	 */
876 
	private function testerTypeEpitheteEspaces() {
20 jpm 877 
		$noms_erreur = array();
64 jpm 878 
		foreach ($this->noms as &$nom) {
171 jpm 879 
			if ($nom['type_epithete'] != '') {
880 
				if (preg_match('/\s+/', $nom['type_epithete'])) {
881 
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
183 jpm 882 
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee, $nom['exclure_taxref']);
20 jpm 883 
				}
884 
			}
885 
		}
177 jpm 886 
		return $noms_erreur;
20 jpm 887 
	}
888 
 
171 jpm 889 
	/**
199 delphine 890 
	 * Test #36
171 jpm 891 
	 */
892 
	private function testerTypeEpitheteSyntaxe() {
20 jpm 893 
		$noms_erreur = array();
64 jpm 894 
		foreach ($this->noms as &$nom) {
171 jpm 895 
			if ($nom['type_epithete'] != '') {
896 
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
183 jpm 897 
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 898 
				}
899 
			}
900 
		}
177 jpm 901 
		return $noms_erreur;
20 jpm 902 
	}
903 
 
171 jpm 904 
	/**
199 delphine 905 
	 * Test #37
171 jpm 906 
	 */
907 
	private function testerTypeEpitheteHybridite() {
20 jpm 908 
		$noms_erreur = array();
64 jpm 909 
		foreach ($this->noms as &$nom) {
171 jpm 910 
			if ($nom['type_epithete'] != '') {
911 
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
183 jpm 912 
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 913 
				}
914 
			}
915 
		}
177 jpm 916 
		return $noms_erreur;
20 jpm 917 
	}
918 
 
171 jpm 919 
	/**
199 delphine 920 
	 * Test #38
171 jpm 921 
	 */
64 jpm 922 
	private function testerEpitheteInfraSpEspaces() {
20 jpm 923 
		$noms_erreur = array();
64 jpm 924 
		foreach ($this->noms as &$nom) {
20 jpm 925 
			if ($nom['epithete_infra_sp'] != '') {
926 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
927 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
183 jpm 928 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 929 
				}
930 
			}
931 
		}
177 jpm 932 
		return $noms_erreur;
20 jpm 933 
	}
934 
 
171 jpm 935 
	/**
199 delphine 936 
	 * Test #39
171 jpm 937 
	 */
64 jpm 938 
	private function testerEpitheteInfraSpSyntaxe() {
20 jpm 939 
		$noms_erreur = array();
64 jpm 940 
		foreach ($this->noms as &$nom) {
20 jpm 941 
			if ($nom['epithete_infra_sp'] != '') {
942 
				$mots = explode(' ', $nom['epithete_infra_sp']);
943 
				foreach ($mots as $mot) {
944 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
194 delphine 945 
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
946 
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
947 
						break;
20 jpm 948 
					}
949 
				}
950 
			}
951 
		}
177 jpm 952 
		return $noms_erreur;
20 jpm 953 
	}
954 
 
171 jpm 955 
	/**
199 delphine 956 
	 * Test #40
171 jpm 957 
	 */
64 jpm 958 
	private function testerEpitheteInfraSpRang() {
20 jpm 959 
		$noms_erreur = array();
64 jpm 960 
		foreach ($this->noms as &$nom) {
20 jpm 961 
			if ($nom['epithete_infra_sp'] != '') {
962 
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 963 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 964 
				}
965 
			}
966 
		}
177 jpm 967 
		return $noms_erreur;
20 jpm 968 
	}
969 
 
173 jpm 970 
	/**
199 delphine 971 
	 * Test #41
173 jpm 972 
	 */
973 
	private function testerGroupeCultivarSyntaxe() {
20 jpm 974 
		$noms_erreur = array();
64 jpm 975 
		foreach ($this->noms as &$nom) {
173 jpm 976 
			if ($nom['cultivar_groupe'] != '') {
977 
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
978 
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
183 jpm 979 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 980 
				}
981 
			}
982 
		}
177 jpm 983 
		return $noms_erreur;
20 jpm 984 
	}
985 
 
173 jpm 986 
	/**
199 delphine 987 
	 * Test #42
173 jpm 988 
	 */
989 
	private function testerGroupeCultivarRang() {
20 jpm 990 
		$noms_erreur = array();
64 jpm 991 
		foreach ($this->noms as &$nom) {
173 jpm 992 
			if ($nom['cultivar_groupe'] != '') {
993 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 994 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 995 
				}
996 
			}
997 
		}
177 jpm 998 
		return $noms_erreur;
20 jpm 999 
	}
1000 
 
173 jpm 1001 
	/**
199 delphine 1002 
	 * Test #43
173 jpm 1003 
	 */
1004 
	private function testerCultivarSyntaxe() {
20 jpm 1005 
		$noms_erreur = array();
64 jpm 1006 
		foreach ($this->noms as &$nom) {
173 jpm 1007 
			if ($nom['cultivar'] != '') {
1008 
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
1009 
					$epithete_traite = $this->repererEspace($nom['cultivar']);
183 jpm 1010 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 1011 
				}
1012 
			}
1013 
		}
177 jpm 1014 
		return $noms_erreur;
20 jpm 1015 
	}
1016 
 
173 jpm 1017 
	/**
199 delphine 1018 
	 * Test #44
173 jpm 1019 
	 */
1020 
	private function testerCultivarRang() {
20 jpm 1021 
		$noms_erreur = array();
64 jpm 1022 
		foreach ($this->noms as &$nom) {
173 jpm 1023 
			if ($nom['cultivar'] != '') {
1024 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 1025 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
171 jpm 1026 
				}
20 jpm 1027 
			}
1028 
		}
177 jpm 1029 
		return $noms_erreur;
20 jpm 1030 
	}
1031 
 
173 jpm 1032 
	/**
199 delphine 1033 
	 * Test #45
173 jpm 1034 
	 */
1035 
	private function testerNomCommercialSyntaxe() {
20 jpm 1036 
		$noms_erreur = array();
64 jpm 1037 
		foreach ($this->noms as &$nom) {
173 jpm 1038 
			if ($nom['nom_commercial'] != '') {
1039 
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
1040 
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
183 jpm 1041 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
171 jpm 1042 
				}
20 jpm 1043 
			}
1044 
		}
177 jpm 1045 
		return $noms_erreur;
20 jpm 1046 
	}
1047 
 
173 jpm 1048 
	/**
199 delphine 1049 
	 * Test #46
173 jpm 1050 
	 */
1051 
	private function testerNomCommercialPresenceCultivar() {
20 jpm 1052 
		$noms_erreur = array();
64 jpm 1053 
		foreach ($this->noms as &$nom) {
173 jpm 1054 
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
183 jpm 1055 
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
20 jpm 1056 
			}
1057 
		}
177 jpm 1058 
		return $noms_erreur;
20 jpm 1059 
	}
1060 
 
173 jpm 1061 
	/**
199 delphine 1062 
	 * Test #47
173 jpm 1063 
	 */
1064 
	private function testerAuteurSyntaxe() {
20 jpm 1065 
		$noms_erreur = array();
64 jpm 1066 
		foreach ($this->noms as &$nom) {
173 jpm 1067 
			if ($nom['auteur'] != '') {
1068 
				if (!$this->verifierAuteur($nom['auteur'])) {
1069 
					$intitule_traite = $this->repererEspace($nom['auteur']);
183 jpm 1070 
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite, $nom['exclure_taxref']);
171 jpm 1071 
				}
20 jpm 1072 
			}
1073 
		}
177 jpm 1074 
		return $noms_erreur;
20 jpm 1075 
	}
1076 
 
173 jpm 1077 
	/**
199 delphine 1078 
	 * Test #48
173 jpm 1079 
	 */
1080 
	private function testerAnneeSyntaxe() {
20 jpm 1081 
		$noms_erreur = array();
64 jpm 1082 
		foreach ($this->noms as &$nom) {
173 jpm 1083 
			if ($nom['annee'] != '') {
1084 
				if (!$this->verifierAnnee($nom['annee'])) {
183 jpm 1085 
					$noms_erreur[] = array($nom['num_nom'], $nom['annee'], $nom['exclure_taxref']);
171 jpm 1086 
				}
20 jpm 1087 
			}
1088 
		}
177 jpm 1089 
		return $noms_erreur;
20 jpm 1090 
	}
1091 
 
173 jpm 1092 
	/**
199 delphine 1093 
	 * Test #49
173 jpm 1094 
	 */
1095 
	private function testerBiblioOrigineSyntaxe() {
20 jpm 1096 
		$noms_erreur = array();
64 jpm 1097 
		foreach ($this->noms as &$nom) {
173 jpm 1098 
			if ($nom['biblio_origine'] != '') {
1099 
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
1100 
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
183 jpm 1101 
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite, $nom['exclure_taxref']);
20 jpm 1102 
				}
1103 
			}
1104 
		}
177 jpm 1105 
		return $noms_erreur;
20 jpm 1106 
	}
1107 
 
173 jpm 1108 
	/**
199 delphine 1109 
	 * Test #50
173 jpm 1110 
	 */
1111 
	private function testerHomonymieSyntaxe() {
20 jpm 1112 
		$noms_erreur = array();
173 jpm 1113 
		foreach ($this->noms as &$nom) {
1114 
			if ($nom['homonyme'] != '') {
1115 
				if (!$this->verifierBooleen($nom['homonyme'])) {
183 jpm 1116 
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme'], $nom['exclure_taxref']);
161 jpm 1117 
				}
20 jpm 1118 
			}
1119 
		}
177 jpm 1120 
		return $noms_erreur;
20 jpm 1121 
	}
1122 
 
173 jpm 1123 
	/**
199 delphine 1124 
	 * Test #51
173 jpm 1125 
	 */
1126 
	private function testerHomonymieExistence() {
1127 
		$noms_homonymie = $this->classerNomsParNomComplet();
1128 
 
20 jpm 1129 
		$noms_erreur = array();
64 jpm 1130 
		foreach ($this->noms as &$nom) {
173 jpm 1131 
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
1132 
				if ($noms_homonymie[$nom['nom_sci']] <= 1) {
183 jpm 1133 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
171 jpm 1134 
				}
20 jpm 1135 
			}
1136 
		}
173 jpm 1137 
		$noms_homonymie = null;
177 jpm 1138 
		return $noms_erreur;
20 jpm 1139 
	}
1140 
 
173 jpm 1141 
	/**
199 delphine 1142 
	 * Test #52
173 jpm 1143 
	 */
1144 
	private function testerBasionymeSyntaxe() {
20 jpm 1145 
		$noms_erreur = array();
64 jpm 1146 
		foreach ($this->noms as &$nom) {
173 jpm 1147 
			if ($nom['basionyme'] != '') {
1148 
				if (!$this->verifierNombre($nom['basionyme'])) {
183 jpm 1149 
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
20 jpm 1150 
				}
1151 
			}
1152 
		}
177 jpm 1153 
		return $noms_erreur;
20 jpm 1154 
	}
173 jpm 1155 
 
1156 
	/**
199 delphine 1157 
	 * Test #53
173 jpm 1158 
	 */
1159 
	private function testerBasionymeExistence() {
20 jpm 1160 
		$noms_erreur = array();
64 jpm 1161 
		foreach ($this->noms as &$nom) {
173 jpm 1162 
			if ($nom['basionyme'] != '') {
1163 
				if (!isset($this->noms[$nom['basionyme']])) {
183 jpm 1164 
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
173 jpm 1165 
				}
20 jpm 1166 
			}
1167 
		}
177 jpm 1168 
		return $noms_erreur;
20 jpm 1169 
	}
1170 
 
173 jpm 1171 
	/**
199 delphine 1172 
	 * Test #54
173 jpm 1173 
	 */
1174 
	private function testerSynonymeProparteSyntaxe() {
20 jpm 1175 
		$noms_erreur = array();
64 jpm 1176 
		foreach ($this->noms as &$nom) {
171 jpm 1177 
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1178 
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
183 jpm 1179 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte'], $nom['exclure_taxref']);
20 jpm 1180 
				}
1181 
			}
1182 
		}
177 jpm 1183 
		return $noms_erreur;
20 jpm 1184 
	}
1185 
 
173 jpm 1186 
	/**
199 delphine 1187 
	 * Test #55
173 jpm 1188 
	 */
1189 
	private function testerSynonymeProparteExistence() {
20 jpm 1190 
		$noms_erreur = array();
64 jpm 1191 
		foreach ($this->noms as &$nom) {
171 jpm 1192 
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1193 
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
1194 
				$num_nom_en_erreur = array();
1195 
				foreach ($num_nom_a_verifier as $num_nom) {
1196 
					if (!isset($this->noms[$num_nom])) {
1197 
						$num_nom_en_erreur[] = $num_nom;
1198 
					}
20 jpm 1199 
				}
173 jpm 1200 
				if (count($nbre_en_erreur) > 0) {
183 jpm 1201 
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur), $nom['exclure_taxref']);
173 jpm 1202 
				}
20 jpm 1203 
			}
1204 
		}
177 jpm 1205 
		return $noms_erreur;
20 jpm 1206 
	}
1207 
 
173 jpm 1208 
	/**
199 delphine 1209 
	 * Test #56
173 jpm 1210 
	 */
1211 
	private function testerSynonymeDouteuxSyntaxe() {
20 jpm 1212 
		$noms_erreur = array();
64 jpm 1213 
		foreach ($this->noms as &$nom) {
173 jpm 1214 
			if ($nom['synonyme_douteux'] != '') {
1215 
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
183 jpm 1216 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
20 jpm 1217 
				}
1218 
			}
1219 
		}
177 jpm 1220 
		return $noms_erreur;
20 jpm 1221 
	}
1222 
 
173 jpm 1223 
	/**
199 delphine 1224 
	 * Test #57
173 jpm 1225 
	 */
1226 
	private function testerSynonymeDouteuxNumNomRetenu() {
20 jpm 1227 
		$noms_erreur = array();
64 jpm 1228 
		foreach ($this->noms as &$nom) {
186 delphine 1229 
			if ($nom['synonyme_douteux'] == 1 && !$this->verifierNombre($nom['num_nom_retenu'])) {
1230 
				$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
20 jpm 1231 
			}
1232 
		}
177 jpm 1233 
		return $noms_erreur;
20 jpm 1234 
	}
1235 
 
171 jpm 1236 
	/**
199 delphine 1237 
	 * Test #58
171 jpm 1238 
	 */
173 jpm 1239 
	private function testerSynonymeMalAppliqueSyntaxe() {
20 jpm 1240 
		$noms_erreur = array();
64 jpm 1241 
		foreach ($this->noms as &$nom) {
173 jpm 1242 
			if ($nom['synonyme_mal_applique'] != '') {
1243 
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
183 jpm 1244 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
20 jpm 1245 
				}
1246 
			}
1247 
		}
177 jpm 1248 
		return $noms_erreur;
20 jpm 1249 
	}
1250 
 
171 jpm 1251 
	/**
199 delphine 1252 
	 * Test #59
171 jpm 1253 
	 */
173 jpm 1254 
	private function testerSynonymeOrthographiqueSyntaxe() {
20 jpm 1255 
		$noms_erreur = array();
173 jpm 1256 
		foreach ($this->noms as $nom) {
1257 
			if ($nom['synonyme_orthographique'] != '') {
1258 
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
183 jpm 1259 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1260 
				}
1261 
			}
1262 
		}
177 jpm 1263 
		return $noms_erreur;
20 jpm 1264 
	}
1265 
 
171 jpm 1266 
	/**
199 delphine 1267 
	 * Test #60
171 jpm 1268 
	 */
173 jpm 1269 
	private function testerSynonymeOrthographiqueExistence() {
20 jpm 1270 
		$noms_erreur = array();
64 jpm 1271 
		foreach ($this->noms as &$nom) {
173 jpm 1272 
			if ($nom['synonyme_orthographique'] != '') {
1273 
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
183 jpm 1274 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1275 
				}
1276 
			}
1277 
		}
177 jpm 1278 
		return $noms_erreur;
20 jpm 1279 
	}
1280 
 
171 jpm 1281 
	/**
199 delphine 1282 
	 * Test #61
171 jpm 1283 
	 */
173 jpm 1284 
	private function testerHybrideParent01Syntaxe() {
20 jpm 1285 
		$noms_erreur = array();
64 jpm 1286 
		foreach ($this->noms as &$nom) {
173 jpm 1287 
			if ($nom['hybride_parent_01'] != '') {
1288 
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
183 jpm 1289 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1290 
				}
1291 
			}
1292 
		}
177 jpm 1293 
		return $noms_erreur;
20 jpm 1294 
	}
1295 
 
171 jpm 1296 
	/**
199 delphine 1297 
	 * Test #62
171 jpm 1298 
	 */
173 jpm 1299 
	private function testerHybrideParent01Existence() {
20 jpm 1300 
		$noms_erreur = array();
64 jpm 1301 
		foreach ($this->noms as &$nom) {
173 jpm 1302 
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1303 
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
183 jpm 1304 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1305 
				}
1306 
			}
1307 
		}
177 jpm 1308 
		return $noms_erreur;
20 jpm 1309 
	}
171 jpm 1310 
 
1311 
	/**
199 delphine 1312 
	 * Test #63
171 jpm 1313 
	 */
173 jpm 1314 
	private function testerHybrideParent02Syntaxe() {
20 jpm 1315 
		$noms_erreur = array();
64 jpm 1316 
		foreach ($this->noms as &$nom) {
173 jpm 1317 
			if ($nom['hybride_parent_02'] != '') {
1318 
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
183 jpm 1319 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
173 jpm 1320 
				}
20 jpm 1321 
			}
1322 
		}
177 jpm 1323 
		return $noms_erreur;
20 jpm 1324 
	}
1325 
 
171 jpm 1326 
	/**
199 delphine 1327 
	 * Test #64
171 jpm 1328 
	 */
173 jpm 1329 
	private function testerHybrideParent02Existence() {
20 jpm 1330 
		$noms_erreur = array();
64 jpm 1331 
		foreach ($this->noms as &$nom) {
173 jpm 1332 
			if ($nom['hybride_parent_02'] != '') {
1333 
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
183 jpm 1334 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
20 jpm 1335 
				}
1336 
			}
1337 
		}
177 jpm 1338 
		return $noms_erreur;
20 jpm 1339 
	}
1340 
 
171 jpm 1341 
	/**
199 delphine 1342 
	 * Test #65
171 jpm 1343 
	 */
173 jpm 1344 
	private function testerPresenceSyntaxe() {
20 jpm 1345 
		$noms_erreur = array();
64 jpm 1346 
		foreach ($this->noms as &$nom) {
173 jpm 1347 
			if ($nom['presence'] != '') {
1348 
				if (!$this->verifierPresence($nom['presence'])) {
183 jpm 1349 
					$noms_erreur[] = array($nom['num_nom'], $nom['presence'], $nom['exclure_taxref']);
20 jpm 1350 
				}
1351 
			}
1352 
		}
177 jpm 1353 
		return $noms_erreur;
20 jpm 1354 
	}
1355 
 
171 jpm 1356 
	/**
199 delphine 1357 
	 * Test #66
171 jpm 1358 
	 */
173 jpm 1359 
	private function testerStatutOrigineSyntaxe() {
20 jpm 1360 
		$noms_erreur = array();
64 jpm 1361 
		foreach ($this->noms as &$nom) {
173 jpm 1362 
			if ($nom['statut_origine'] != '') {
1363 
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
183 jpm 1364 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']);
20 jpm 1365 
				}
1366 
			}
1367 
		}
177 jpm 1368 
		return $noms_erreur;
20 jpm 1369 
	}
1370 
 
171 jpm 1371 
	/**
199 delphine 1372 
	 * Test #67
171 jpm 1373 
	 */
173 jpm 1374 
	private function testerStatutIntroductionSyntaxe() {
20 jpm 1375 
		$noms_erreur = array();
64 jpm 1376 
		foreach ($this->noms as &$nom) {
173 jpm 1377 
			if ($nom['statut_introduction'] != '') {
1378 
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
183 jpm 1379 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']);
20 jpm 1380 
				}
1381 
			}
1382 
		}
177 jpm 1383 
		return $noms_erreur;
20 jpm 1384 
	}
1385 
 
171 jpm 1386 
	/**
199 delphine 1387 
	 * Test #68
171 jpm 1388 
	 */
173 jpm 1389 
	private function testerStatutCultureSyntaxe() {
20 jpm 1390 
		$noms_erreur = array();
64 jpm 1391 
		foreach ($this->noms as &$nom) {
173 jpm 1392 
			if ($nom['statut_culture'] != '') {
1393 
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
183 jpm 1394 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']);
20 jpm 1395 
				}
1396 
			}
1397 
		}
177 jpm 1398 
		return $noms_erreur;
20 jpm 1399 
	}
1400 
 
171 jpm 1401 
	/**
199 delphine 1402 
	 * Test #69
171 jpm 1403 
	 */
146 delphine 1404 
	private function testerExclureTaxRefSyntaxe() {
1405 
		$noms_erreur = array();
1406 
		foreach ($this->noms as &$nom) {
1407 
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
183 jpm 1408 
				if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) {
146 delphine 1409 
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
1410 
				}
1411 
			}
1412 
		}
177 jpm 1413 
		return $noms_erreur;
146 delphine 1414 
	}
171 jpm 1415 
 
1416 
 
1417 
 
20 jpm 1418 
	//+--------------------------------------------------------------------------------------------------------------+//
1419 
	// MÉTHODES COMMUNES aux TESTS
1420 
 
64 jpm 1421 
	private function verifierPresence(&$valeur) {
20 jpm 1422 
		$codes = $this->manuel['codes_presence'];
1423 
		$ok = $this->verifierStatuts($valeur, $codes);
1424 
		return $ok;
1425 
	}
1426 
 
64 jpm 1427 
	private function verifierStatutOrigine(&$valeur) {
20 jpm 1428 
		$codes = $this->manuel['codes_statuts_origine'];
1429 
		$ok = $this->verifierStatuts($valeur, $codes);
1430 
		return $ok;
1431 
	}
1432 
 
64 jpm 1433 
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 1434 
		$codes = $this->manuel['codes_statuts_introduction'];
1435 
		$ok = $this->verifierStatuts($valeur, $codes);
1436 
		return $ok;
1437 
	}
1438 
 
64 jpm 1439 
	private function verifierStatutCulture(&$valeur) {
20 jpm 1440 
		$codes = $this->manuel['codes_statuts_culture'];
1441 
		$ok = $this->verifierStatuts($valeur, $codes);
1442 
		return $ok;
1443 
	}
1444 
 
64 jpm 1445 
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 1446 
		$ok = true;
1447 
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
1448 
			$ok = false;
1449 
		}
1450 
		return $ok;
1451 
	}
1452 
 
64 jpm 1453 
	private function verifierBooleen(&$valeur) {
20 jpm 1454 
		$ok = true;
1455 
		if (!preg_match('/^1$/', $valeur)) {
1456 
			$ok = false;
1457 
		}
1458 
		return $ok;
1459 
	}
1460 
 
64 jpm 1461 
	private function verifierNombre(&$valeur) {
20 jpm 1462 
		$ok = true;
1463 
		if (!preg_match('/^[0-9]+$/', $valeur)) {
1464 
			$ok = false;
1465 
		}
1466 
		return $ok;
1467 
	}
1468 
 
64 jpm 1469 
	private function verifierNombreSuite(&$valeur) {
20 jpm 1470 
		$ok = true;
1471 
		if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
1472 
			$ok = false;
1473 
		}
1474 
		return $ok;
1475 
	}
1476 
 
64 jpm 1477 
	private function verifierTypeEpithete(&$type) {
20 jpm 1478 
		$ok = false;
1479 
		$rejetes = $this->manuel['type_epithete_rejetes'];
1480 
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
1481 
			$ok = false;
1482 
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
1483 
			$ok = true;
1484 
		}
1485 
		return $ok;
1486 
	}
1487 
 
64 jpm 1488 
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 1489 
		$ok = true;
1490 
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1491 
			$ok = false;// Contient des espaces en trop
1492 
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
1493 
			$ok = false;
1494 
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
1495 
			$ok = false;// Contient une mauvaise suite de caractères
1496 
		}
1497 
		return $ok;
1498 
	}
1499 
 
64 jpm 1500 
	private function verifierAnnee(&$annee) {
20 jpm 1501 
		$ok = true;
1502 
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
1503 
			$ok = false;
188 delphine 1504 
		} else if ($annee < ANNEE_MINIMUM) {
20 jpm 1505 
			$ok = false;
188 delphine 1506 
		} else if ($annee > ANNEE_EN_COURS) {
186 delphine 1507 
			$ok = false;
20 jpm 1508 
		}
1509 
		return $ok;
1510 
	}
1511 
 
64 jpm 1512 
	private function verifierAuteur(&$intitule) {
20 jpm 1513 
		$ok = true;
1514 
		$acceptes = $this->manuel['auteur_acceptes'];
1515 
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
1516 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1517 
				$ok = false;// Contient des espaces en trop
1518 
			} else {
1519 
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
1520 
				$mots = explode(' ', $intitule);
1521 
				foreach ($mots as $position => $mot) {
1522 
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1523 
						$ok = false;// Mot rejeté
184 jpm 1524 
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) {
20 jpm 1525 
						continue;// Mot de l'intitulé auteur
1526 
					} else {
1527 
						$ok = false;
1528 
					}
1529 
				}
1530 
			}
1531 
		}
1532 
		return $ok;
1533 
	}
1534 
 
64 jpm 1535 
	private function verifierNomCommercial(&$epithete) {
20 jpm 1536 
		$ok = false;
1537 
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
1538 
			$ok = true;
1539 
		}
1540 
		return $ok;
1541 
	}
1542 
 
64 jpm 1543 
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 1544 
		$ok = true;
1545 
		$acceptes = $this->manuel['cultivar_acceptes'];
1546 
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1547 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1548 
				$ok = false;// Contient des espaces en trop
1549 
			} else {
1550 
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
1551 
				$mots_mineurs = $this->manuel['mots_mineurs'];
1552 
				$mots = explode(' ', $epithete);
1553 
				foreach ($mots as $position => $mot) {
1554 
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1555 
						$ok = false;// Mot rejeté
1556 
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1557 
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1558 
					} else {
1559 
						$mots_tiret = explode('-', $mot);
1560 
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1561 
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1562 
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
1563 
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1564 
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
1565 
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1566 
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1567 
							} else {
1568 
								$ok = false;
1569 
							}
1570 
						}
1571 
					}
1572 
				}
1573 
			}
1574 
		}
1575 
		return $ok;
1576 
	}
1577 
 
64 jpm 1578 
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 1579 
		$ok = true;
1580 
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
1581 
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1582 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1583 
				$ok = false;// Contient des espaces en trop
1584 
			} else {
1585 
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
1586 
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
1587 
				$mots_mineurs = $this->manuel['mots_mineurs'];
1588 
				$mots = explode(' ', $epithete);
1589 
				foreach ($mots as $position => $mot) {
1590 
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
1591 
						continue;// Mot accepté
1592 
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1593 
						$ok = false;// Mot rejeté
1594 
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1595 
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1596 
					} else {
1597 
						$mots_tiret = explode('-', $mot);
1598 
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1599 
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1600 
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
1601 
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1602 
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
1603 
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1604 
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1605 
							} else {
1606 
								$ok = false;
1607 
							}
1608 
						}
1609 
					}
1610 
				}
1611 
			}
1612 
		}
1613 
		return $ok;
1614 
	}
1615 
 
64 jpm 1616 
	private function verifierEpitheteSp(&$epithete) {
20 jpm 1617 
		$ok = false;
183 jpm 1618 
		if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
20 jpm 1619 
			$ok = true;
1620 
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
1621 
			$ok = true;
1622 
		}
1623 
		return $ok;
1624 
	}
1625 
 
64 jpm 1626 
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 1627 
		$ok = false;
183 jpm 1628 
		if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) {
20 jpm 1629 
			$ok = true;
1630 
		}
1631 
		return $ok;
1632 
	}
1633 
 
254 aurelien 1634 
	private function verifierEstAbbreviationInfraSp($mot) {
1635 
		$ok = false;
1636 
		if(preg_match($this->manuel['abbr_rangs_infra_specifique'], $mot)) {
1637 
			$ok = true;
1638 
		}
1639 
		return $ok;
1640 
	}
1641 
 
64 jpm 1642 
	private function formaterStyleNomGenre(&$genre) {
20 jpm 1643 
		$genre_fmt = '';
1644 
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
192 delphine 1645 
			$genre_fmt = utf8_encode(strtolower(utf8_decode($match[1]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[2]))));
194 delphine 1646 
		} elseif (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $genre, $match)) {
1647 
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
1648 
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
20 jpm 1649 
		} else {
192 delphine 1650 
			$genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($genre))));
20 jpm 1651 
		}
1652 
		return $genre_fmt;
1653 
	}
1654 
 
250 delphine 1655 
	private function formaterStyleEpitheteSpHybride(&$genre, &$epithete) {
1656 
		$nom_fmt = '';
1657 
		$erreur = '';
1658 
		if (trim($genre) == '') {
1659 
			if ($epithete != '') {
1660 
				$nom_fmt = $this->formaterFormuleHybridite($epithete);
1661 
			} else {
1662 
				$erreur = "Formule d'hybridité sans épithéte spécifique";
1663 
			}
1664 
		} else {
1665 
			$nom_fmt = $this->formaterNomHybride($genre, $epithete);
1666 
		}
1667 
		return array($nom_fmt, $erreur);
1668 
	}
1669 
 
1670 
	private function formaterStyleEpitheteInfraSpHybride(&$nom_sci, &$infra, &$genre = null) {
1671 
		$nom_fmt = '';
1672 
		$erreur = '';
1673 
		if (trim($genre) == '') {
1674 
			if (trim($nom_sci) == '') {
1675 
				if (trim($infra) != '') {
1676 
					$nom_fmt = $this->formaterFormuleHybridite($infra);
1677 
				} else {
1678 
					$erreur = "Formule d'hybridité sans épithéte infraspécifique";
1679 
				}
1680 
			} else {
1681 
				$erreur = "Formule d'hybridité avec épithéte spécifique";
1682 
			}
1683 
		} else {
1684 
			$nom_fmt = $this->formaterNomHybride($nom_sci, $infra);
1685 
		}
1686 
		return array($nom_fmt, $erreur);
1687 
	}
1688 
 
1689 
	private function formaterNomHybride(&$nom_sci, &$epithete) {
1690 
		if (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $epithete, $match) != '') {
1691 
			$nom_fmt = $nom_sci.utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '.
1692 
				utf8_encode(strtolower(utf8_decode($match[2]))).' '.
1693 
				utf8_encode(ucfirst(strtolower(utf8_decode($match[3]))));
1694 
		} elseif (preg_match('/^([x+])\s+(.+)$/i', $epithete, $match) != '') {
1695 
			$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($match[1]))).' '.
1696 
				utf8_encode(strtolower(utf8_decode($match[2])));
1697 
		} else {
1698 
			$nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($epithete)));
1699 
		}
1700 
		return $nom_fmt;
1701 
	}
1702 
 
1703 
	private function formaterFormuleHybridite(&$epithete) {
1704 
		$liste_parents = explode(' x ', $epithete);
1705 
		if (count($liste_parents) == 2) {
1706 
			$nom_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[0])))).' x '.
1707 
			utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[1]))));
1708 
		} else {
1709 
			for ($i=0; $i<count($liste_parents); $i++) {
1710 
				if (strstr(trim($liste_parents[$i]), ' ') == false) {
1711 
					$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode(trim($liste_parents[$i]))))).' x '.
1712 
					utf8_encode(strtolower(utf8_decode(trim($liste_parents[$i+1]))));
1713 
					$i++;
1714 
				} else {
1715 
					$nom[] = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[$i]))));
1716 
				}
1717 
			}
1718 
			$nom_fmt = implode(' x ', $nom);
1719 
		}
1720 
		return $nom_fmt;
1721 
	}
1722 
 
149 jpm 1723 
	private function repererEspace($nom_sci) {
1724 
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
1725 
		return $nom_sci;
20 jpm 1726 
	}
1727 
 
64 jpm 1728 
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 1729 
		$suffixe = array();
1730 
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
1731 
		$suffixe[] = $this->construireNomCommercial($nom);
1732 
		$suffixe[] = $this->construireNomCultivar($nom);
1733 
		$suffixe = array_filter($suffixe);
1734 
		return implode(' ', $suffixe);
1735 
	}
1736 
 
64 jpm 1737 
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 1738 
		$nom_groupe_cultivar = '';
1739 
		if ($nom['cultivar_groupe'] != '') {
1740 
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
1741 
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
1742 
			} else {
1743 
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
1744 
			}
1745 
		}
1746 
		return $nom_groupe_cultivar;
1747 
	}
1748 
 
64 jpm 1749 
	private function construireNomCommercial(&$nom) {
20 jpm 1750 
		$nom_commercial = '';
1751 
		if ($nom['nom_commercial'] != '') {
1752 
			$nom_commercial =  strtoupper($nom['nom_commercial']);
1753 
		}
1754 
		return $nom_commercial;
1755 
	}
1756 
 
64 jpm 1757 
	private function construireNomCultivar(&$nom) {
20 jpm 1758 
		$nom_cultivar = '';
1759 
		if ($nom['cultivar'] != '') {
1760 
			$nom_cultivar =  "'".$nom['cultivar']."'";
1761 
		}
1762 
		return $nom_cultivar;
1763 
	}
1764 
 
64 jpm 1765 
	private function classerNomsParNomComplet() {
20 jpm 1766 
		$noms_classes = array();
64 jpm 1767 
		foreach ($this->noms as &$nom) {
149 jpm 1768 
			if (!isset($noms_classes[$nom['nom_sci']])) {
1769 
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 1770 
			} else {
149 jpm 1771 
				$noms_classes[$nom['nom_sci']]++;
20 jpm 1772 
			}
1773 
		}
1774 
		return $noms_classes;
1775 
	}
1776 
}
1777 
?>