Subversion Repositories Applications.referentiel

Rev

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

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