Subversion Repositories Applications.referentiel

Rev

Rev 175 | Rev 177 | 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();
38 jpm 68
					$this->lancerTests();
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
106
    	foreach (array_keys($this->tests) as $numero) {
107
			$info = $this->getInfosTest($numero);
108
 
109
    		if ($numero < 5) {
110
    			// Tests spéciaux vérifiant la structure de la table
111
    			$resultats[] = $this->lancerTestUnitaire($info);
112
    		} else if ($numero >= 5 && $this->verifierResultats($resultats)) {
113
				// Si la structure est bonne nous lançons les autres tests
114
 
115
    		}
116
		}
117
    }
118
 
119
    public function lancerTestUnitaire($info) {
120
		$methodeDeTest = $info['methode'];
121
    	$erreurs = $this->$methodeDeTest;
122
 
123
    	// Analyse des résultats
124
    	if (isset($erreurs['special'])) {
125
    		$info = $erreurs;
126
    	} else {
176 jpm 127
    		if (count($erreurs) > 0) {
175 jpm 128
				$info['message']['entete'] = explode(',', $info['entete']);
129
				$info['message']['lignes'] = $erreurs;
176 jpm 130
				unset($erreurs);
175 jpm 131
			} else {
132
				$info['resultat'] = true;
133
			}
134
    	}
135
 
136
		$this->traiterResultatTest($info);
137
 
138
		if ($info['numero'] < 5) {
139
			return ($info['resultat'] ? '1' : '0');
140
		}
141
    }
142
 
165 delphine 143
    public function lancerTests() {
20 jpm 144
		// Lancement des tests unitaires
64 jpm 145
		$resultats = array();
175 jpm 146
		$resultats[] = $this->testerNombreDeChamps();
147
		$resultats[] = $this->testerNomDesChamps();
148
		$resultats[] = $this->testerTypeDesChamps();
149
		$resultats[] = $this->testerNumNomClePrimaire();
20 jpm 150
 
64 jpm 151
		// Si la structure est bonne nous lançons les autres tests
152
		Debug::printr($resultats);
153
		if ($this->verifierResultats($resultats)) {
175 jpm 154
			$this->testerTailleDesChamps();
64 jpm 155
 
156
			$this->testerNumNomSuperieurAZero();
157
 
158
			$this->testerNumNomRetenuSuperieurAZero();
159
			$this->testerNumTaxSupEgalZeroUnique();
160
			$this->testerTaxSupPourTaxon();
161
			$this->testerExitenceTaxonSuperieur();
165 delphine 162
			$this->testerClassificationRang();
64 jpm 163
			$this->testerClassification();
164
 
165
			$this->testerRang();
166
 
167
			$this->testerNomCompletSupraGenerique();
168
			$this->testerNomCompletGenre();
169
			$this->testerNomCompletInfraGenre();
170
			$this->testerNomCompletEspece();
171
			$this->testerNomCompletInfraSpecifique();
172
 
173
			$this->testerNomSupraGeneriqueEspaces();
174
			$this->testerNomSupraGeneriqueSyntaxe();
175
			$this->testerNomSupraGeneriqueRang();
176
 
177
			$this->testerGenreEspaces();
178
			$this->testerGenreSyntaxe();
179
			$this->testerGenreRang();
180
 
181
			$this->testerEpitheteInfraGeneriqueEspaces();
182
			$this->testerEpitheteInfraGeneriqueSyntaxe();
183
			$this->testerEpitheteInfraGeneriqueRang();
184
 
185
			$this->testerEpitheteSpEspaces();
186
			$this->testerEpitheteSpSyntaxe();
187
			$this->testerEpitheteSpRang();
188
 
189
			$this->testerTypeEpitheteEspaces();
190
			$this->testerTypeEpitheteSyntaxe();
191
			$this->testerTypeEpitheteHybridite();
192
 
193
			$this->testerEpitheteInfraSpEspaces();
194
			$this->testerEpitheteInfraSpSyntaxe();
195
			$this->testerEpitheteInfraSpRang();
196
 
197
			$this->testerGroupeCultivarSyntaxe();
198
			$this->testerGroupeCultivarRang();
199
 
200
			$this->testerCultivarSyntaxe();
201
			$this->testerCultivarRang();
202
 
203
			$this->testerNomCommercialSyntaxe();
204
			$this->testerNomCommercialPresenceCultivar();
205
 
206
			$this->testerAuteurSyntaxe();
207
 
208
			$this->testerAnneeSyntaxe();
209
 
210
			$this->testerBiblioOrigineSyntaxe();
211
 
212
			$this->testerHomonymieSyntaxe();
213
			$this->testerHomonymieExistence();
214
 
215
			$this->testerBasionymeSyntaxe();
216
			$this->testerBasionymeExistence();
217
 
218
			$this->testerSynonymeProparteSyntaxe();
219
			$this->testerSynonymeProparteExistence();
220
 
221
			$this->testerSynonymeDouteuxSyntaxe();
158 delphine 222
			$this->testerSynonymeDouteuxNumNomRetenu();
64 jpm 223
 
224
			$this->testerSynonymeMalAppliqueSyntaxe();
225
 
226
			$this->testerSynonymeOrthographiqueSyntaxe();
227
			$this->testerSynonymeOrthographiqueExistence();
228
 
229
			$this->testerHybrideParent01Syntaxe();
230
			$this->testerHybrideParent01Existence();
231
			$this->testerHybrideParent02Syntaxe();
232
			$this->testerHybrideParent02Existence();
233
 
234
			$this->testerPresenceSyntaxe();
235
			$this->testerStatutOrigineSyntaxe();
236
			$this->testerStatutIntroductionSyntaxe();
237
			$this->testerStatutCultureSyntaxe();
146 delphine 238
			$this->testerExclureTaxRefSyntaxe();
64 jpm 239
		}
20 jpm 240
	}
175 jpm 241
 
64 jpm 242
	private function verifierResultats($resultats) {
243
		$ok = true;
244
		foreach ($resultats as $resultat) {
245
			if ($resultat == '0') {
246
				$ok = false;
247
				break;
248
			}
249
		}
250
		return $ok;
251
	}
20 jpm 252
 
253
	//+--------------------------------------------------------------------------------------------------------------+//
30 jpm 254
	// Enregistrement des résultats
255
	private function traiterResultatTest($info) {
64 jpm 256
		Debug::printr($info['nom']);
30 jpm 257
		if (isset($info['message'])) {
258
			if (is_array($info['message'])) {
31 jpm 259
				$info['message'] = $this->getVue('tests/squelettes/message_table', $info);
260
			} else {
261
				$info['message'] = $this->getVue('tests/squelettes/message_p', $info);
30 jpm 262
			}
263
		}
264
		$this->resultatDao->ajouter($this->traitement['id_traitement'], $info);
64 jpm 265
		$info = null;
30 jpm 266
	}
267
 
268
	//+--------------------------------------------------------------------------------------------------------------+//
20 jpm 269
	// TESTS
270
 
171 jpm 271
	/**
272
	 * Test #01
273
	 */
175 jpm 274
	private function testerNombreDeChamps() {
171 jpm 275
		$info = $this->getInfosTest(1);
175 jpm 276
		$info['special'] = true;
20 jpm 277
 
175 jpm 278
		$nbre_colonnes = count($this->colonnes);
171 jpm 279
		$info['message'] = $nbre_colonnes;
280
		if ($nbre_colonnes >= 35) {
281
			$info['resultat'] = true;
282
		}
175 jpm 283
 
284
		return $info;
171 jpm 285
	}
286
 
287
	/**
288
	 * Test #02
289
	 */
175 jpm 290
	private function testerNomDesChamps() {
171 jpm 291
		$info = $this->getInfosTest(2);
175 jpm 292
		$info['special'] = true;
171 jpm 293
 
294
		$champs_attendus = explode(',', $this->manuel['champs']);
295
		$champs_presents = array();
175 jpm 296
		foreach ($this->colonnes as $colonne) {
171 jpm 297
			$champs_presents[$colonne['Field']] = $colonne;
298
		}
299
 
300
		$ok = true;
301
		$champs_manquant = array();
302
		foreach ($champs_attendus as $champ_attendu) {
303
			if (!isset($champs_presents[$champ_attendu])) {
304
				$champs_manquant[] = $champ_attendu;
305
				$ok = false;
306
			}
307
		}
175 jpm 308
 
171 jpm 309
		$info['resultat'] = $ok;
310
		if (!$ok) {
311
			$info['message'] = sprintf($info['message'], implode(', ', $champs_manquant));
312
		}
313
 
175 jpm 314
		return $info;
171 jpm 315
	}
316
 
317
	/**
318
	 * Test #03
319
	 */
175 jpm 320
	private function testerTypeDesChamps() {
171 jpm 321
		$champs_attendus = explode(',', $this->manuel['champs_type']);
322
		$champs_presents = array();
175 jpm 323
		foreach ($this->colonnes as $colonne) {
171 jpm 324
			$champs_presents[$colonne['Field']] = $colonne['Type'];
325
		}
326
 
327
		// Recercherche des erreurs
328
		$champs_erreur = array();
329
		foreach ($champs_attendus as $champ_attendu) {
330
			list($champ_attendu_nom, $champ_attendu_type_taille) = explode('=', trim($champ_attendu));
331
			list($champ_attendu_type, $champ_attendu_taille) = explode('|', trim($champ_attendu_type_taille));
332
 
333
			if (isset($champs_presents[$champ_attendu_nom])) {
334
				$champs_present_type = $champs_presents[$champ_attendu_nom];
335
 
336
				if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
337
					|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
338
					|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
339
					|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
175 jpm 340
					$champs_erreur[] = array($champ_attendu, $champ_attendu_type, $champs_present_type);
171 jpm 341
				}
342
			}
343
		}
175 jpm 344
		return $champs_erreur;
171 jpm 345
	}
346
 
347
	/**
348
	 * Test #04
349
	 */
175 jpm 350
	private function testerNumNomClePrimaire() {
171 jpm 351
		$info = $this->getInfosTest(4);
175 jpm 352
		$info['special'] = true;
171 jpm 353
 
175 jpm 354
		foreach ($this->colonnes as $colonne) {
171 jpm 355
			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
356
				$info['resultat'] = true;
357
			}
358
		}
175 jpm 359
		return $info;
171 jpm 360
	}
361
 
362
 
363
	/**
364
	 * Test #05
365
	 */
175 jpm 366
	private function testerTailleDesChamps() {
171 jpm 367
		$tailles_champs_maxi = array();
175 jpm 368
		foreach ($this->colonnes as $colonne) {
171 jpm 369
			if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
370
				$tailles_champs_maxi[$colonne['Field']] = $match[1];
371
			}
372
		}
373
 
374
		$tailles_trouvees = array();
175 jpm 375
		foreach ($this->analyses as $analyse) {
171 jpm 376
			if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
377
				$tailles_trouvees[$match[1]] = $analyse['Max_length'];
378
			}
379
		}
380
 
381
		$champs_erreur = array();
382
		$champs_attendus = explode(',', $this->manuel['champs']);
383
		foreach ($champs_attendus as $champ_attendu) {
384
			if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
385
				if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
175 jpm 386
					$champs_erreur[] = array($champ_attendu, $tailles_champs_maxi[$champ_attendu], $tailles_trouvees[$champ_attendu]);
171 jpm 387
				}
388
			}
389
		}
175 jpm 390
		return $champs_erreur;
171 jpm 391
	}
392
 
393
	/**
394
	 * Test #06
395
	 */
396
	private function testerNumNomSuperieurAZero() {
20 jpm 397
		// Réalisation du test
398
		$noms_erreur = array();
64 jpm 399
		foreach ($this->noms as &$nom) {
171 jpm 400
			if ($nom['num_nom'] <= 0) {
175 jpm 401
				$noms_erreur[] = array($nom['num_nom']);
20 jpm 402
			}
403
		}
175 jpm 404
		return $noms_erreur;
20 jpm 405
	}
406
 
171 jpm 407
	/**
408
	 * Test #07
409
	 */
410
	private function testerNumNomRetenuSuperieurAZero() {
20 jpm 411
		// Réalisation du test
412
		$noms_erreur = array();
64 jpm 413
		foreach ($this->noms as &$nom) {
171 jpm 414
			if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] <= 0) {
175 jpm 415
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu']);
20 jpm 416
			}
417
		}
176 jpm 418
		return $noms_erreur;
20 jpm 419
	}
420
 
171 jpm 421
	/**
422
	 * Test #08
423
	 */
424
	private function testerNumTaxSupEgalZeroUnique() {
20 jpm 425
		// Réalisation du test
426
		$noms_erreur = array();
64 jpm 427
		foreach ($this->noms as &$nom) {
171 jpm 428
			if (preg_match('/^0$/', $nom['num_tax_sup'])) {
175 jpm 429
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
20 jpm 430
			}
431
		}
176 jpm 432
		// Ce test est spécial car le nombre de noms en erreurs doit être supérieur à 1 et non à 0 pour être KO.
433
		if (count($noms_erreur) == 1) {
434
			$noms_erreur[] = array();
20 jpm 435
		}
176 jpm 436
		return $noms_erreur;
20 jpm 437
	}
438
 
171 jpm 439
	/**
440
	 * Test #09
441
	 */
442
	private function testerTaxSupPourTaxon() {
20 jpm 443
		// Réalisation du test
444
		$noms_erreur = array();
64 jpm 445
		foreach ($this->noms as &$nom) {
171 jpm 446
			if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['num_tax_sup'] != '') {
175 jpm 447
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
20 jpm 448
			}
449
		}
176 jpm 450
		return $noms_erreur;
20 jpm 451
	}
452
 
171 jpm 453
	/**
454
	 * Test #10
455
	 */
456
	private function testerExitenceTaxonSuperieur() {
20 jpm 457
		// Réalisation du test
458
		$noms_erreur = array();
64 jpm 459
		foreach ($this->noms as &$nom) {
171 jpm 460
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
461
				if ($nom['num_tax_sup'] != 0 && !isset($this->noms[$nom['num_tax_sup']])) {
175 jpm 462
					$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
171 jpm 463
				}
20 jpm 464
			}
465
		}
176 jpm 466
		return $noms_erreur;
20 jpm 467
	}
468
 
171 jpm 469
	/**
470
	 * Test #11
471
	 */
472
	private function testerClassificationRang() {
20 jpm 473
		// Réalisation du test
474
		$noms_erreur = array();
64 jpm 475
		foreach ($this->noms as &$nom) {
171 jpm 476
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
477
				if (isset($this->noms[$nom['num_tax_sup']])) {
478
					$nom_sup = $this->noms[$nom['num_tax_sup']];
479
					if ($nom_sup['rang'] >= $nom['rang']) {
480
						// Prise en compte de l'exception des clades
481
						if (! ($nom_sup['rang'] == 70 && $nom['rang'] == 70)) {
175 jpm 482
							$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang']);
171 jpm 483
						}
484
					}
20 jpm 485
				}
486
			}
487
		}
176 jpm 488
		return $noms_erreur;
20 jpm 489
	}
490
 
171 jpm 491
	/**
492
	 * Test #12
493
	 */
494
	private function testerClassification() {
20 jpm 495
		// Réalisation du test
496
		$noms_erreur = array();
171 jpm 497
		$this->noms_ok = array();
64 jpm 498
		foreach ($this->noms as &$nom) {
171 jpm 499
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
500
				if (isset($this->noms_ok[$nom['num_tax_sup']])) {
501
					$this->noms_ok[$nom['num_nom']] = true;
502
				} else {
503
					$this->detection_boucle_infini = array();
504
					$classif_ok = $this->remonterClassif($nom);
505
					unset($this->detection_boucle_infini);
506
 
175 jpm 507
					if ($classif_ok === true) {
508
						$this->noms_ok[$nom['num_nom']] = $classif_ok;
171 jpm 509
					} else {
175 jpm 510
						$noms_erreur[] = array($nom['num_nom'], $classif_ok);
171 jpm 511
					}
20 jpm 512
				}
513
			}
514
		}
171 jpm 515
		unset($this->noms_ok);
176 jpm 516
		return $noms_erreur;
20 jpm 517
	}
518
 
171 jpm 519
	private function remonterClassif(&$nom) {
520
		$this->detection_boucle_infini[$nom['num_nom']] = true;
521
		if (preg_match('/^[0-9]*$/', $nom['num_tax_sup'])) {
522
			if (isset($this->noms_ok[$nom['num_tax_sup']])) {
523
				$this->noms_ok[$nom['num_nom']] = true;
524
				return true;
525
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
526
				$this->noms_ok[$nom['num_nom']] = true;
527
				return true;
528
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
175 jpm 529
				return 'Hiérarchie avec le taxon #'.$nom['num_nom'].' ayant un taxon superieur #'.$nom['num_tax_sup'].' inexistant';
171 jpm 530
			} else if (isset($this->detection_boucle_infini[$nom['num_tax_sup']])) {
175 jpm 531
				return 'Boucle infinie pour le taxon #'.$nom['num_tax_sup'];
171 jpm 532
			} else {
533
				$retour = $this->remonterClassif($this->noms[$nom['num_tax_sup']]);
534
				if ($retour === true) {
535
					$this->noms_ok[$nom['num_tax_sup']] = true;
536
				}
537
				return $retour;
538
			}
539
		} else {
175 jpm 540
			return 'Valeur num_tax_sup incorrecte : '.$nom['num_tax_sup'];
171 jpm 541
		}
542
	}
543
 
544
	/**
545
	 * Test #13
546
	 */
547
	private function testerRang() {
548
		$rangs = array_flip(explode(',', $this->manuel['rangs']));
549
 
20 jpm 550
		// Réalisation du test
551
		$noms_erreur = array();
64 jpm 552
		foreach ($this->noms as &$nom) {
171 jpm 553
			if (!isset($rangs[$nom['rang']])) {
175 jpm 554
				$noms_erreur[] = array($nom['num_nom'], $nom['rang']);
20 jpm 555
			}
556
		}
176 jpm 557
		return $noms_erreur;
20 jpm 558
	}
559
 
171 jpm 560
	/**
561
	 * Test #14
562
	 */
563
	private function testerNomCompletSupraGenerique() {
20 jpm 564
		// Réalisation du test
565
		$noms_erreur = array();
64 jpm 566
		foreach ($this->noms as &$nom) {
171 jpm 567
			if ($nom['rang'] < $this->manuel['rang_genre']) {
568
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
569
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
570
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
571
				if ($nom['nom_sci'] != $nom_sci_ideal) {
572
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
573
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
20 jpm 574
				}
575
			}
576
		}
176 jpm 577
		return $noms_erreur;
20 jpm 578
	}
579
 
171 jpm 580
	/**
581
	 * Test #15
582
	 */
583
	private function testerNomCompletGenre() {
20 jpm 584
		// Réalisation du test
585
		$noms_erreur = array();
171 jpm 586
		foreach ($this->noms as &$nom) {
587
			if ($nom['rang'] == $this->manuel['rang_genre']) {
588
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
589
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
590
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
591
				if ($nom['nom_sci'] != $nom_sci_ideal) {
592
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
593
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
20 jpm 594
				}
595
			}
596
		}
176 jpm 597
		return $noms_erreur;
20 jpm 598
	}
599
 
171 jpm 600
	/**
601
	 * Test #16
602
	 */
603
	private function testerNomCompletInfraGenre() {
20 jpm 604
		// Réalisation du test
605
		$noms_erreur = array();
64 jpm 606
		foreach ($this->noms as &$nom) {
171 jpm 607
			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
608
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
609
				$nom_sci_ideal = '';
610
				if ($nom['type_epithete'] == 'agg.') {
611
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
612
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
613
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
614
				} else {
615
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
616
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
617
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
20 jpm 618
				}
171 jpm 619
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
620
				if ($nom['nom_sci'] != $nom_sci_ideal) {
621
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
622
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
623
				}
20 jpm 624
			}
625
		}
176 jpm 626
		return $noms_erreur;
20 jpm 627
	}
628
 
171 jpm 629
	/**
630
	 * Test #17
631
	 */
632
	private function testerNomCompletEspece() {
20 jpm 633
		// Réalisation du test
634
		$noms_erreur = array();
64 jpm 635
		foreach ($this->noms as &$nom) {
171 jpm 636
			if ($nom['rang'] == $this->manuel['rang_sp']) {
637
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
638
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
639
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_sp']);
640
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
641
				if ($nom['nom_sci'] != $nom_sci_ideal) {
642
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
643
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
20 jpm 644
				}
645
			}
646
		}
176 jpm 647
		return $noms_erreur;
20 jpm 648
	}
649
 
171 jpm 650
	/**
651
	 * Test #18
652
	 */
653
	private function testerNomCompletInfraSpecifique() {
158 delphine 654
		// Réalisation du test
655
		$noms_erreur = array();
656
		foreach ($this->noms as &$nom) {
171 jpm 657
			if ($nom['rang'] > $this->manuel['rang_sp']) {
658
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
659
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
660
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_sp']);
661
				$nom_sci_ideal .= ' '.strtolower($nom['type_epithete']);
662
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_infra_sp']);
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']);
666
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal);
667
				}
158 delphine 668
			}
669
		}
176 jpm 670
		return $noms_erreur;
158 delphine 671
	}
672
 
171 jpm 673
	/**
674
	 * Test #19
675
	 */
676
	private function testerNomSupraGeneriqueEspaces() {
20 jpm 677
		// Réalisation du test
678
		$noms_erreur = array();
64 jpm 679
		foreach ($this->noms as &$nom) {
171 jpm 680
			if ($nom['nom_supra_generique'] != '') {
681
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
682
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
683
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
20 jpm 684
				}
685
			}
686
		}
176 jpm 687
		return $noms_erreur;
20 jpm 688
	}
689
 
171 jpm 690
	/**
691
	 * Test #20
692
	 */
693
	private function testerNomSupraGeneriqueSyntaxe() {
694
		$info = $this->getInfosTest(20);
20 jpm 695
 
696
		// Réalisation du test
697
		$noms_erreur = array();
64 jpm 698
		foreach ($this->noms as &$nom) {
171 jpm 699
			if ($nom['nom_supra_generique'] != '') {
700
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
701
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
702
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
20 jpm 703
				}
704
			}
705
		}
706
 
707
		// Analyse des résultats
708
		if (count($noms_erreur) > 0) {
171 jpm 709
			$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
20 jpm 710
			$info['message']['lignes'] = $noms_erreur;
711
		} else {
712
			$info['resultat'] = true;
713
		}
64 jpm 714
		$noms_erreur = null;
20 jpm 715
 
30 jpm 716
		$this->traiterResultatTest($info);
20 jpm 717
	}
718
 
171 jpm 719
	/**
720
	 * Test #21
721
	 */
722
	private function testerNomSupraGeneriqueRang() {
723
		$info = $this->getInfosTest(21);
724
		$info['nom'] = sprintf($info['nom'], $this->manuel['rang_genre']);
725
		$info['description'] = sprintf($info['description'], $this->manuel['rang_genre']);
20 jpm 726
 
727
		// Réalisation du test
728
		$noms_erreur = array();
64 jpm 729
		foreach ($this->noms as &$nom) {
171 jpm 730
			if ($nom['nom_supra_generique'] != '') {
731
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
732
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 733
				}
734
			}
735
		}
736
 
737
		// Analyse des résultats
738
		if (count($noms_erreur) > 0) {
171 jpm 739
			$info['message']['entete'] = array('num_nom', 'nom_sci', 'rang erroné');
20 jpm 740
			$info['message']['lignes'] = $noms_erreur;
741
		} else {
742
			$info['resultat'] = true;
743
		}
64 jpm 744
		$noms_erreur = null;
20 jpm 745
 
30 jpm 746
		$this->traiterResultatTest($info);
20 jpm 747
	}
748
 
171 jpm 749
	/**
750
	 * Test #22
751
	 */
752
	private function testerGenreEspaces() {
753
		$info = $this->getInfosTest(22);
20 jpm 754
 
755
		// Réalisation du test
756
		$noms_erreur = array();
64 jpm 757
		foreach ($this->noms as &$nom) {
171 jpm 758
			if ($nom['genre'] != '') {
759
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
760
					$nom_traite = $this->repererEspace($nom['genre']);
761
					$noms_erreur[] = array($nom['num_nom'], $nom_traite);
20 jpm 762
				}
763
			}
764
		}
765
 
766
		// Analyse des résultats
767
		if (count($noms_erreur) > 0) {
171 jpm 768
			$info['message']['entete'] = array('num_nom', 'genre erroné');
20 jpm 769
			$info['message']['lignes'] = $noms_erreur;
770
		} else {
771
			$info['resultat'] = true;
772
		}
64 jpm 773
		$noms_erreur = null;
20 jpm 774
 
30 jpm 775
		$this->traiterResultatTest($info);
20 jpm 776
	}
777
 
171 jpm 778
	/**
779
	 * Test #23
780
	 */
781
	private function testerGenreSyntaxe() {
782
		$info = $this->getInfosTest(23);
20 jpm 783
 
784
		// Réalisation du test
785
		$noms_erreur = array();
64 jpm 786
		foreach ($this->noms as &$nom) {
171 jpm 787
			if ($nom['genre'] != '') {
788
				$mots = explode(' ', $nom['genre']);
789
				foreach ($mots as $mot) {
790
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
791
						$nom_traite = $this->repererEspace($nom['genre']);
792
						$noms_erreur[] = array($nom['num_nom'], $nom_traite);
793
					}
20 jpm 794
				}
795
			}
796
		}
797
 
798
		// Analyse des résultats
799
		if (count($noms_erreur) > 0) {
171 jpm 800
			$info['message']['entete'] = array('num_nom', 'genre erroné');
20 jpm 801
			$info['message']['lignes'] = $noms_erreur;
802
		} else {
803
			$info['resultat'] = true;
804
		}
64 jpm 805
		$noms_erreur = null;
20 jpm 806
 
30 jpm 807
		$this->traiterResultatTest($info);
20 jpm 808
	}
809
 
171 jpm 810
	/**
811
	 * Test #24
812
	 */
813
	private function testerGenreRang() {
814
		$info = $this->getInfosTest(24);
815
		$info['nom'] = sprintf($info['nom'], $this->manuel['rang_genre']);
816
		$info['description'] = sprintf($info['description'], $this->manuel['rang_genre']);
20 jpm 817
 
818
		// Réalisation du test
819
		$noms_erreur = array();
64 jpm 820
		foreach ($this->noms as &$nom) {
171 jpm 821
			if ($nom['genre'] != '') {
822
				if ($nom['rang'] < $this->manuel['rang_genre']) {
823
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 824
				}
825
			}
826
		}
827
 
828
		// Analyse des résultats
829
		if (count($noms_erreur) > 0) {
171 jpm 830
			$info['message']['entete'] = array('num_nom', 'nom_sci', 'rang erroné');
20 jpm 831
			$info['message']['lignes'] = $noms_erreur;
832
		} else {
833
			$info['resultat'] = true;
834
		}
64 jpm 835
		$noms_erreur = null;
20 jpm 836
 
30 jpm 837
		$this->traiterResultatTest($info);
20 jpm 838
	}
839
 
171 jpm 840
	/**
841
	 * Test #25
842
	 */
843
	private function testerEpitheteInfraGeneriqueSyntaxe() {
844
		$info = $this->getInfosTest(25);
845
 
20 jpm 846
		// Réalisation du test
847
		$noms_erreur = array();
64 jpm 848
		foreach ($this->noms as &$nom) {
171 jpm 849
			if ($nom['epithete_infra_generique'] != '') {
850
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
851
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
852
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
20 jpm 853
				}
854
			}
855
		}
856
 
857
		// Analyse des résultats
858
		if (count($noms_erreur) > 0) {
171 jpm 859
			$info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné');
20 jpm 860
			$info['message']['lignes'] = $noms_erreur;
861
		} else {
862
			$info['resultat'] = true;
863
		}
64 jpm 864
		$noms_erreur = null;
20 jpm 865
 
30 jpm 866
		$this->traiterResultatTest($info);
20 jpm 867
	}
868
 
171 jpm 869
	/**
870
	 * Test #26
871
	 */
872
	private function testerEpitheteInfraGeneriqueRang() {
873
		$info = $this->getInfosTest(26);
874
		$info['nom'] = sprintf($info['nom'], $this->manuel['rang_genre'], $this->manuel['rang_sp']);
875
		$info['description'] = sprintf($info['description'], $this->manuel['rang_genre'], $this->manuel['rang_sp']);
20 jpm 876
 
877
		// Réalisation du test
878
		$noms_erreur = array();
64 jpm 879
		foreach ($this->noms as &$nom) {
171 jpm 880
			if ($nom['epithete_infra_generique'] != '') {
881
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
882
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 883
				}
884
			}
885
		}
886
 
887
		// Analyse des résultats
888
		if (count($noms_erreur) > 0) {
171 jpm 889
			$info['message']['entete'] = array('num_nom', 'nom_sci', 'rang erroné');
20 jpm 890
			$info['message']['lignes'] = $noms_erreur;
891
		} else {
892
			$info['resultat'] = true;
893
		}
64 jpm 894
		$noms_erreur = null;
20 jpm 895
 
30 jpm 896
		$this->traiterResultatTest($info);
20 jpm 897
	}
898
 
171 jpm 899
	/**
900
	 * Test #27
901
	 */
902
	private function testerEpitheteInfraGeneriqueEspaces() {
903
		$info = $this->getInfosTest(27);
20 jpm 904
 
905
		// Réalisation du test
906
		$noms_erreur = array();
64 jpm 907
		foreach ($this->noms as &$nom) {
171 jpm 908
			if ($nom['epithete_infra_generique'] != '') {
909
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
910
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
911
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
20 jpm 912
				}
913
			}
914
		}
915
 
916
		// Analyse des résultats
917
		if (count($noms_erreur) > 0) {
171 jpm 918
			$info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné');
20 jpm 919
			$info['message']['lignes'] = $noms_erreur;
920
		} else {
921
			$info['resultat'] = true;
922
		}
64 jpm 923
		$noms_erreur = null;
20 jpm 924
 
30 jpm 925
		$this->traiterResultatTest($info);
20 jpm 926
	}
927
 
171 jpm 928
	/**
929
	 * Test #28
930
	 */
931
	private function testerEpitheteSpEspaces() {
932
		$info = $this->getInfosTest(28);
20 jpm 933
 
934
		// Réalisation du test
935
		$noms_erreur = array();
64 jpm 936
		foreach ($this->noms as &$nom) {
171 jpm 937
			if ($nom['epithete_sp'] != '') {
938
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
939
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
20 jpm 940
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
941
				}
942
			}
943
		}
944
 
945
		// Analyse des résultats
946
		if (count($noms_erreur) > 0) {
171 jpm 947
			$info['message']['entete'] = array('num_nom', 'epithete_sp erroné');
20 jpm 948
			$info['message']['lignes'] = $noms_erreur;
949
		} else {
950
			$info['resultat'] = true;
951
		}
64 jpm 952
		$noms_erreur = null;
20 jpm 953
 
30 jpm 954
		$this->traiterResultatTest($info);
20 jpm 955
	}
956
 
171 jpm 957
	/**
958
	 * Test #29
959
	 */
960
	private function testerEpitheteSpSyntaxe() {
961
		$info = $this->getInfosTest(29);
20 jpm 962
 
963
		// Réalisation du test
964
		$noms_erreur = array();
64 jpm 965
		foreach ($this->noms as &$nom) {
171 jpm 966
			if ($nom['epithete_sp'] != '') {
967
				$mots = explode(' ', $nom['epithete_sp']);
968
				foreach ($mots as $mot) {
969
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot))) {
970
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
971
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
972
					}
973
				}
20 jpm 974
			}
975
		}
976
 
977
		// Analyse des résultats
978
		if (count($noms_erreur) > 0) {
171 jpm 979
			$info['message']['entete'] = array('num_nom', 'epithete_sp erroné');
20 jpm 980
			$info['message']['lignes'] = $noms_erreur;
981
		} else {
982
			$info['resultat'] = true;
983
		}
64 jpm 984
		$noms_erreur = null;
20 jpm 985
 
30 jpm 986
		$this->traiterResultatTest($info);
20 jpm 987
	}
988
 
171 jpm 989
	/**
990
	 * Test #30
991
	 */
992
	private function testerEpitheteSpRang() {
993
		$info = $this->getInfosTest(30);
994
		$info['nom'] = sprintf($info['nom'], $this->manuel['rang_sp']);
995
		$info['description'] = sprintf($info['description'], $this->manuel['rang_sp']);
20 jpm 996
 
997
		// Réalisation du test
998
		$noms_erreur = array();
64 jpm 999
		foreach ($this->noms as &$nom) {
171 jpm 1000
			if ($nom['epithete_sp'] != '') {
1001
				if ($nom['rang'] < $this->manuel['rang_sp']) {
1002
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 1003
				}
1004
			}
1005
		}
1006
 
1007
		// Analyse des résultats
1008
		if (count($noms_erreur) > 0) {
171 jpm 1009
			$info['message']['entete'] = array('num_nom', 'nom_sci', 'rang erroné');
20 jpm 1010
			$info['message']['lignes'] = $noms_erreur;
1011
		} else {
1012
			$info['resultat'] = true;
1013
		}
64 jpm 1014
		$noms_erreur = null;
20 jpm 1015
 
30 jpm 1016
		$this->traiterResultatTest($info);
20 jpm 1017
	}
1018
 
171 jpm 1019
	/**
1020
	 * Test #31
1021
	 */
1022
	private function testerTypeEpitheteEspaces() {
1023
		$info = $this->getInfosTest(31);
20 jpm 1024
 
1025
		// Réalisation du test
1026
		$noms_erreur = array();
64 jpm 1027
		foreach ($this->noms as &$nom) {
171 jpm 1028
			if ($nom['type_epithete'] != '') {
1029
				if (preg_match('/\s+/', $nom['type_epithete'])) {
1030
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
1031
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee);
20 jpm 1032
				}
1033
			}
1034
		}
1035
 
1036
		// Analyse des résultats
1037
		if (count($noms_erreur) > 0) {
171 jpm 1038
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
20 jpm 1039
			$info['message']['lignes'] = $noms_erreur;
1040
		} else {
1041
			$info['resultat'] = true;
1042
		}
1043
 
30 jpm 1044
		$this->traiterResultatTest($info);
20 jpm 1045
	}
1046
 
171 jpm 1047
	/**
1048
	 * Test #32
1049
	 */
1050
	private function testerTypeEpitheteSyntaxe() {
1051
		$info = $this->getInfosTest(32);
20 jpm 1052
 
1053
		// Réalisation du test
1054
		$noms_erreur = array();
64 jpm 1055
		foreach ($this->noms as &$nom) {
171 jpm 1056
			if ($nom['type_epithete'] != '') {
1057
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
1058
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete']);
20 jpm 1059
				}
1060
			}
1061
		}
1062
 
1063
		// Analyse des résultats
1064
		if (count($noms_erreur) > 0) {
171 jpm 1065
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
20 jpm 1066
			$info['message']['lignes'] = $noms_erreur;
1067
		} else {
1068
			$info['resultat'] = true;
1069
		}
1070
 
30 jpm 1071
		$this->traiterResultatTest($info);
20 jpm 1072
	}
1073
 
171 jpm 1074
	/**
1075
	 * Test #33
1076
	 */
1077
	private function testerTypeEpitheteHybridite() {
1078
		$info = $this->getInfosTest(33);
20 jpm 1079
 
1080
		// Réalisation du test
1081
		$noms_erreur = array();
64 jpm 1082
		foreach ($this->noms as &$nom) {
171 jpm 1083
			if ($nom['type_epithete'] != '') {
1084
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
1085
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']);
20 jpm 1086
				}
1087
			}
1088
		}
1089
 
1090
		// Analyse des résultats
1091
		if (count($noms_erreur) > 0) {
171 jpm 1092
			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
20 jpm 1093
			$info['message']['lignes'] = $noms_erreur;
1094
		} else {
1095
			$info['resultat'] = true;
1096
		}
1097
 
30 jpm 1098
		$this->traiterResultatTest($info);
20 jpm 1099
	}
1100
 
171 jpm 1101
	/**
1102
	 * Test #34
1103
	 */
64 jpm 1104
	private function testerEpitheteInfraSpEspaces() {
171 jpm 1105
		$info = $this->getInfosTest(34);
20 jpm 1106
 
1107
		// Réalisation du test
1108
		$noms_erreur = array();
64 jpm 1109
		foreach ($this->noms as &$nom) {
20 jpm 1110
			if ($nom['epithete_infra_sp'] != '') {
1111
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
1112
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
1113
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
1114
				}
1115
			}
1116
		}
1117
 
1118
		// Analyse des résultats
1119
		if (count($noms_erreur) > 0) {
1120
			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
1121
			$info['message']['lignes'] = $noms_erreur;
1122
		} else {
1123
			$info['resultat'] = true;
1124
		}
64 jpm 1125
		$noms_erreur = null;
20 jpm 1126
 
30 jpm 1127
		$this->traiterResultatTest($info);
20 jpm 1128
	}
1129
 
171 jpm 1130
	/**
1131
	 * Test #35
1132
	 */
64 jpm 1133
	private function testerEpitheteInfraSpSyntaxe() {
171 jpm 1134
		$info = $this->getInfosTest(35);
20 jpm 1135
 
1136
		// Réalisation du test
1137
		$noms_erreur = array();
64 jpm 1138
		foreach ($this->noms as &$nom) {
20 jpm 1139
			if ($nom['epithete_infra_sp'] != '') {
1140
				$mots = explode(' ', $nom['epithete_infra_sp']);
1141
				foreach ($mots as $mot) {
1142
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
1143
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
1144
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
1145
					}
1146
				}
1147
			}
1148
		}
1149
 
1150
		// Analyse des résultats
1151
		if (count($noms_erreur) > 0) {
1152
			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
1153
			$info['message']['lignes'] = $noms_erreur;
1154
		} else {
1155
			$info['resultat'] = true;
1156
		}
64 jpm 1157
		$noms_erreur = null;
20 jpm 1158
 
30 jpm 1159
		$this->traiterResultatTest($info);
20 jpm 1160
	}
1161
 
171 jpm 1162
	/**
1163
	 * Test #36
1164
	 */
64 jpm 1165
	private function testerEpitheteInfraSpRang() {
171 jpm 1166
		$info = $this->getInfosTest(36);
1167
		$info['nom'] = sprintf($info['nom'], $this->manuel['rang_sp']);
1168
		$info['description'] = sprintf($info['description'], $this->manuel['rang_sp']);
20 jpm 1169
 
1170
		// Réalisation du test
1171
		$noms_erreur = array();
64 jpm 1172
		foreach ($this->noms as &$nom) {
20 jpm 1173
			if ($nom['epithete_infra_sp'] != '') {
1174
				if ($nom['rang'] < $this->manuel['rang_sp']) {
149 jpm 1175
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 1176
				}
1177
			}
1178
		}
1179
 
1180
		// Analyse des résultats
1181
		if (count($noms_erreur) > 0) {
149 jpm 1182
			$info['message']['entete'] = array('num_nom', 'nom_sci', 'rang erroné');
20 jpm 1183
			$info['message']['lignes'] = $noms_erreur;
1184
		} else {
1185
			$info['resultat'] = true;
1186
		}
64 jpm 1187
		$noms_erreur = null;
20 jpm 1188
 
30 jpm 1189
		$this->traiterResultatTest($info);
20 jpm 1190
	}
1191
 
173 jpm 1192
	/**
1193
	 * Test #37
1194
	 */
1195
	private function testerGroupeCultivarSyntaxe() {
174 jpm 1196
		$info = $this->getInfosTest(37);
20 jpm 1197
 
1198
		// Réalisation du test
1199
		$noms_erreur = array();
64 jpm 1200
		foreach ($this->noms as &$nom) {
173 jpm 1201
			if ($nom['cultivar_groupe'] != '') {
1202
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
1203
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
1204
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
20 jpm 1205
				}
1206
			}
1207
		}
1208
 
1209
		// Analyse des résultats
1210
		if (count($noms_erreur) > 0) {
173 jpm 1211
			$info['message']['entete'] = array('num_nom', 'cultivar_groupe erroné');
20 jpm 1212
			$info['message']['lignes'] = $noms_erreur;
1213
		} else {
1214
			$info['resultat'] = true;
1215
		}
171 jpm 1216
		$noms_erreur = null;
20 jpm 1217
 
30 jpm 1218
		$this->traiterResultatTest($info);
20 jpm 1219
	}
1220
 
173 jpm 1221
	/**
1222
	 * Test #38
1223
	 */
1224
	private function testerGroupeCultivarRang() {
174 jpm 1225
		$info = $this->getInfosTest(38);
1226
		$info['nom'] = sprintf($info['nom'], $this->manuel['rang_genre']);
1227
		$info['description'] = sprintf($info['description'], $this->manuel['rang_genre']);
20 jpm 1228
 
1229
		// Réalisation du test
1230
		$noms_erreur = array();
64 jpm 1231
		foreach ($this->noms as &$nom) {
173 jpm 1232
			if ($nom['cultivar_groupe'] != '') {
1233
				if ($nom['rang'] < $this->manuel['rang_genre']) {
1234
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
20 jpm 1235
				}
1236
			}
1237
		}
1238
 
1239
		// Analyse des résultats
1240
		if (count($noms_erreur) > 0) {
173 jpm 1241
			$info['message']['entete'] = array('num_nom', 'nom_sci', 'rang erroné');
20 jpm 1242
			$info['message']['lignes'] = $noms_erreur;
1243
		} else {
1244
			$info['resultat'] = true;
1245
		}
171 jpm 1246
		$noms_erreur = null;
20 jpm 1247
 
30 jpm 1248
		$this->traiterResultatTest($info);
20 jpm 1249
	}
1250
 
173 jpm 1251
	/**
1252
	 * Test #39
1253
	 */
1254
	private function testerCultivarSyntaxe() {
174 jpm 1255
		$info = $this->getInfosTest(39);
1256
 
20 jpm 1257
		// Réalisation du test
1258
		$noms_erreur = array();
64 jpm 1259
		foreach ($this->noms as &$nom) {
173 jpm 1260
			if ($nom['cultivar'] != '') {
1261
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
1262
					$epithete_traite = $this->repererEspace($nom['cultivar']);
1263
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
20 jpm 1264
				}
1265
			}
1266
		}
1267
 
1268
		// Analyse des résultats
1269
		if (count($noms_erreur) > 0) {
173 jpm 1270
			$info['message']['entete'] = array('num_nom', 'cultivar erroné');
20 jpm 1271
			$info['message']['lignes'] = $noms_erreur;
1272
		} else {
1273
			$info['resultat'] = true;
1274
		}
171 jpm 1275
		$noms_erreur = null;
20 jpm 1276
 
30 jpm 1277
		$this->traiterResultatTest($info);
20 jpm 1278
	}
1279
 
173 jpm 1280
	/**
1281
	 * Test #40
1282
	 */
1283
	private function testerCultivarRang() {
174 jpm 1284
		$info = $this->getInfosTest(40);
1285
		$info['nom'] = sprintf($info['nom'], $this->manuel['rang_genre']);
1286
		$info['description'] = sprintf($info['description'], $this->manuel['rang_genre']);
20 jpm 1287
 
1288
		// Réalisation du test
1289
		$noms_erreur = array();
64 jpm 1290
		foreach ($this->noms as &$nom) {
173 jpm 1291
			if ($nom['cultivar'] != '') {
1292
				if ($nom['rang'] < $this->manuel['rang_genre']) {
1293
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang']);
171 jpm 1294
				}
20 jpm 1295
			}
1296
		}
1297
 
1298
		// Analyse des résultats
1299
		if (count($noms_erreur) > 0) {
173 jpm 1300
			$info['message']['entete'] = array('num_nom', 'nom_sci', 'rang erroné');
171 jpm 1301
			$info['message']['lignes'] = $noms_erreur;
20 jpm 1302
		} else {
1303
			$info['resultat'] = true;
1304
		}
171 jpm 1305
		$noms_erreur = null;
20 jpm 1306
 
30 jpm 1307
		$this->traiterResultatTest($info);
20 jpm 1308
	}
1309
 
173 jpm 1310
	/**
1311
	 * Test #41
1312
	 */
1313
	private function testerNomCommercialSyntaxe() {
174 jpm 1314
		$info = $this->getInfosTest(41);
20 jpm 1315
 
1316
		// Réalisation du test
1317
		$noms_erreur = array();
64 jpm 1318
		foreach ($this->noms as &$nom) {
173 jpm 1319
			if ($nom['nom_commercial'] != '') {
1320
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
1321
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
1322
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
171 jpm 1323
				}
20 jpm 1324
			}
1325
		}
1326
 
1327
		// Analyse des résultats
1328
		if (count($noms_erreur) > 0) {
173 jpm 1329
			$info['message']['entete'] = array('num_nom', 'cultivar erroné');
171 jpm 1330
			$info['message']['lignes'] = $noms_erreur;
20 jpm 1331
		} else {
1332
			$info['resultat'] = true;
1333
		}
171 jpm 1334
		$noms_erreur = null;
20 jpm 1335
 
30 jpm 1336
		$this->traiterResultatTest($info);
20 jpm 1337
	}
1338
 
173 jpm 1339
	/**
1340
	 * Test #42
1341
	 */
1342
	private function testerNomCommercialPresenceCultivar() {
174 jpm 1343
		$info = $this->getInfosTest(42);
20 jpm 1344
 
1345
		// Réalisation du test
1346
		$noms_erreur = array();
64 jpm 1347
		foreach ($this->noms as &$nom) {
173 jpm 1348
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
1349
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci']);
20 jpm 1350
			}
1351
		}
1352
 
1353
		// Analyse des résultats
171 jpm 1354
		if (count($noms_erreur) > 0) {
173 jpm 1355
			$info['message']['entete'] = array('num_nom', 'nom_commercial sans cultivar ou cultivar_groupe');
171 jpm 1356
			$info['message']['lignes'] = $noms_erreur;
20 jpm 1357
		} else {
1358
			$info['resultat'] = true;
1359
		}
171 jpm 1360
		$noms_erreur = null;
20 jpm 1361
 
30 jpm 1362
		$this->traiterResultatTest($info);
20 jpm 1363
	}
1364
 
173 jpm 1365
	/**
1366
	 * Test #43
1367
	 */
1368
	private function testerAuteurSyntaxe() {
174 jpm 1369
		$info = $this->getInfosTest(43);
20 jpm 1370
 
1371
		// Réalisation du test
1372
		$noms_erreur = array();
64 jpm 1373
		foreach ($this->noms as &$nom) {
173 jpm 1374
			if ($nom['auteur'] != '') {
1375
				if (!$this->verifierAuteur($nom['auteur'])) {
1376
					$intitule_traite = $this->repererEspace($nom['auteur']);
1377
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite);
171 jpm 1378
				}
20 jpm 1379
			}
1380
		}
1381
 
1382
		// Analyse des résultats
1383
		if (count($noms_erreur) > 0) {
173 jpm 1384
			$info['message']['entete'] = array('num_nom', 'auteur erroné');
171 jpm 1385
			$info['message']['lignes'] = $noms_erreur;
20 jpm 1386
		} else {
1387
			$info['resultat'] = true;
1388
		}
171 jpm 1389
		$noms_erreur = null;
20 jpm 1390
 
30 jpm 1391
		$this->traiterResultatTest($info);
20 jpm 1392
	}
1393
 
173 jpm 1394
	/**
1395
	 * Test #44
1396
	 */
1397
	private function testerAnneeSyntaxe() {
174 jpm 1398
		$info = $this->getInfosTest(44);
20 jpm 1399
 
1400
		// Réalisation du test
1401
		$noms_erreur = array();
64 jpm 1402
		foreach ($this->noms as &$nom) {
173 jpm 1403
			if ($nom['annee'] != '') {
1404
				if (!$this->verifierAnnee($nom['annee'])) {
1405
					$noms_erreur[] = array($nom['num_nom'], $nom['annee']);
171 jpm 1406
				}
20 jpm 1407
			}
1408
		}
1409
 
1410
		// Analyse des résultats
1411
		if (count($noms_erreur) > 0) {
174 jpm 1412
			$info['message']['entete'] = array('num_nom', 'annee erronée');
171 jpm 1413
			$info['message']['lignes'] = $noms_erreur;
20 jpm 1414
		} else {
1415
			$info['resultat'] = true;
1416
		}
171 jpm 1417
		$noms_erreur = null;
20 jpm 1418
 
30 jpm 1419
		$this->traiterResultatTest($info);
20 jpm 1420
	}
1421
 
173 jpm 1422
	/**
1423
	 * Test #45
1424
	 */
1425
	private function testerBiblioOrigineSyntaxe() {
174 jpm 1426
		$info = $this->getInfosTest(45);
20 jpm 1427
 
1428
		// Réalisation du test
1429
		$noms_erreur = array();
64 jpm 1430
		foreach ($this->noms as &$nom) {
173 jpm 1431
			if ($nom['biblio_origine'] != '') {
1432
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
1433
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
1434
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite);
20 jpm 1435
				}
1436
			}
1437
		}
1438
 
1439
		// Analyse des résultats
1440
		if (count($noms_erreur) > 0) {
173 jpm 1441
			$info['message']['entete'] = array('num_nom', 'biblio_origine erroné');
171 jpm 1442
			$info['message']['lignes'] = $noms_erreur;
20 jpm 1443
		} else {
1444
			$info['resultat'] = true;
1445
		}
171 jpm 1446
		$noms_erreur = null;
20 jpm 1447
 
30 jpm 1448
		$this->traiterResultatTest($info);
20 jpm 1449
	}
1450
 
173 jpm 1451
	/**
1452
	 * Test #46
1453
	 */
1454
	private function testerHomonymieSyntaxe() {
174 jpm 1455
		$info = $this->getInfosTest(46);
20 jpm 1456
 
1457
		// Réalisation du test
1458
		$noms_erreur = array();
173 jpm 1459
		foreach ($this->noms as &$nom) {
1460
			if ($nom['homonyme'] != '') {
1461
				if (!$this->verifierBooleen($nom['homonyme'])) {
1462
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme']);
161 jpm 1463
				}
20 jpm 1464
			}
1465
		}
1466
 
1467
		// Analyse des résultats
1468
		if (count($noms_erreur) > 0) {
173 jpm 1469
			$info['message']['entete'] = array('num_nom', 'homonyme erroné');
171 jpm 1470
			$info['message']['lignes'] = $noms_erreur;
20 jpm 1471
		} else {
1472
			$info['resultat'] = true;
1473
		}
171 jpm 1474
		$noms_erreur = null;
20 jpm 1475
 
30 jpm 1476
		$this->traiterResultatTest($info);
20 jpm 1477
	}
1478
 
173 jpm 1479
	/**
1480
	 * Test #47
1481
	 */
1482
	private function testerHomonymieExistence() {
174 jpm 1483
		$info = $this->getInfosTest(47);
20 jpm 1484
 
173 jpm 1485
		$noms_homonymie = $this->classerNomsParNomComplet();
1486
 
20 jpm 1487
		// Réalisation du test
1488
		$noms_erreur = array();
64 jpm 1489
		foreach ($this->noms as &$nom) {
173 jpm 1490
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
1491
				if ($noms_homonymie[$nom['nom_sci']] <= 1) {
1492
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci']);
171 jpm 1493
				}
20 jpm 1494
			}
1495
		}
173 jpm 1496
		$noms_homonymie = null;
20 jpm 1497
 
1498
		// Analyse des résultats
1499
		if (count($noms_erreur) > 0) {
173 jpm 1500
			$info['message']['entete'] = array('num_nom', 'homonyme introuvable');
171 jpm 1501
			$info['message']['lignes'] = $noms_erreur;
20 jpm 1502
		} else {
1503
			$info['resultat'] = true;
1504
		}
171 jpm 1505
		$noms_erreur = null;
20 jpm 1506
 
30 jpm 1507
		$this->traiterResultatTest($info);
20 jpm 1508
	}
1509
 
173 jpm 1510
	/**
1511
	 * Test #48
1512
	 */
1513
	private function testerBasionymeSyntaxe() {
174 jpm 1514
		$info = $this->getInfosTest(48);
20 jpm 1515
 
1516
		// Réalisation du test
1517
		$noms_erreur = array();
64 jpm 1518
		foreach ($this->noms as &$nom) {
173 jpm 1519
			if ($nom['basionyme'] != '') {
1520
				if (!$this->verifierNombre($nom['basionyme'])) {
1521
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
20 jpm 1522
				}
1523
			}
1524
		}
1525
 
1526
		// Analyse des résultats
1527
		if (count($noms_erreur) > 0) {
173 jpm 1528
			$info['message']['entete'] = array('num_nom', 'basionyme erroné');
20 jpm 1529
			$info['message']['lignes'] = $noms_erreur;
1530
		} else {
1531
			$info['resultat'] = true;
1532
		}
171 jpm 1533
		$noms_erreur = null;
20 jpm 1534
 
30 jpm 1535
		$this->traiterResultatTest($info);
20 jpm 1536
	}
173 jpm 1537
 
1538
	/**
1539
	 * Test #49
1540
	 */
1541
	private function testerBasionymeExistence() {
174 jpm 1542
		$info = $this->getInfosTest(49);
20 jpm 1543
 
1544
		// Réalisation du test
1545
		$noms_erreur = array();
64 jpm 1546
		foreach ($this->noms as &$nom) {
173 jpm 1547
			if ($nom['basionyme'] != '') {
1548
				if (!isset($this->noms[$nom['basionyme']])) {
1549
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme']);
1550
				}
20 jpm 1551
			}
1552
		}
1553
 
1554
		// Analyse des résultats
1555
		if (count($noms_erreur) > 0) {
173 jpm 1556
			$info['message']['entete'] = array('num_nom', 'basionyme introuvable');
20 jpm 1557
			$info['message']['lignes'] = $noms_erreur;
1558
		} else {
1559
			$info['resultat'] = true;
1560
		}
171 jpm 1561
		$noms_erreur = null;
173 jpm 1562
 
30 jpm 1563
		$this->traiterResultatTest($info);
20 jpm 1564
	}
1565
 
173 jpm 1566
	/**
1567
	 * Test #50
1568
	 */
1569
	private function testerSynonymeProparteSyntaxe() {
174 jpm 1570
		$info = $this->getInfosTest(50);
20 jpm 1571
 
1572
		// Réalisation du test
1573
		$noms_erreur = array();
64 jpm 1574
		foreach ($this->noms as &$nom) {
171 jpm 1575
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1576
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
1577
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte']);
20 jpm 1578
				}
1579
			}
1580
		}
1581
 
1582
		// Analyse des résultats
1583
		if (count($noms_erreur) > 0) {
173 jpm 1584
			$info['message']['entete'] = array('num_nom', 'synonyme_proparte erroné');
20 jpm 1585
			$info['message']['lignes'] = $noms_erreur;
1586
		} else {
1587
			$info['resultat'] = true;
1588
		}
64 jpm 1589
		$noms_erreur = null;
20 jpm 1590
 
30 jpm 1591
		$this->traiterResultatTest($info);
20 jpm 1592
	}
1593
 
173 jpm 1594
	/**
1595
	 * Test #51
1596
	 */
1597
	private function testerSynonymeProparteExistence() {
175 jpm 1598
		$info = $this->getInfosTest(51);
20 jpm 1599
 
1600
		// Réalisation du test
1601
		$noms_erreur = array();
64 jpm 1602
		foreach ($this->noms as &$nom) {
171 jpm 1603
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1604
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
1605
				$num_nom_en_erreur = array();
1606
				foreach ($num_nom_a_verifier as $num_nom) {
1607
					if (!isset($this->noms[$num_nom])) {
1608
						$num_nom_en_erreur[] = $num_nom;
1609
					}
20 jpm 1610
				}
173 jpm 1611
				if (count($nbre_en_erreur) > 0) {
1612
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur));
1613
				}
20 jpm 1614
			}
1615
		}
1616
 
1617
		// Analyse des résultats
1618
		if (count($noms_erreur) > 0) {
173 jpm 1619
			$info['message']['entete'] = array('num_nom', 'synonyme_proparte introuvable');
20 jpm 1620
			$info['message']['lignes'] = $noms_erreur;
1621
		} else {
1622
			$info['resultat'] = true;
1623
		}
64 jpm 1624
		$noms_erreur = null;
20 jpm 1625
 
30 jpm 1626
		$this->traiterResultatTest($info);
20 jpm 1627
	}
1628
 
173 jpm 1629
	/**
1630
	 * Test #52
1631
	 */
1632
	private function testerSynonymeDouteuxSyntaxe() {
175 jpm 1633
		$info = $this->getInfosTest(52);
20 jpm 1634
 
1635
		// Réalisation du test
1636
		$noms_erreur = array();
64 jpm 1637
		foreach ($this->noms as &$nom) {
173 jpm 1638
			if ($nom['synonyme_douteux'] != '') {
1639
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
1640
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux']);
20 jpm 1641
				}
1642
			}
1643
		}
1644
 
1645
		// Analyse des résultats
1646
		if (count($noms_erreur) > 0) {
173 jpm 1647
			$info['message']['entete'] = array('num_nom', 'synonyme_douteux erroné');
20 jpm 1648
			$info['message']['lignes'] = $noms_erreur;
1649
		} else {
1650
			$info['resultat'] = true;
1651
		}
64 jpm 1652
		$noms_erreur = null;
20 jpm 1653
 
30 jpm 1654
		$this->traiterResultatTest($info);
20 jpm 1655
	}
1656
 
173 jpm 1657
	/**
1658
	 * Test #53
1659
	 */
1660
	private function testerSynonymeDouteuxNumNomRetenu() {
175 jpm 1661
		$info = $this->getInfosTest(53);
20 jpm 1662
 
1663
		// Réalisation du test
1664
		$noms_erreur = array();
64 jpm 1665
		foreach ($this->noms as &$nom) {
173 jpm 1666
			if ($nom['synonyme_douteux'] == 1 && $nom['num_nom_retenu'] != ' ') {
1667
				$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['num_nom_retenu']);
20 jpm 1668
			}
1669
		}
1670
 
1671
		// Analyse des résultats
1672
		if (count($noms_erreur) > 0) {
173 jpm 1673
			$info['message']['entete'] = array('num_nom', 'synonyme_douteux', 'num_nom_retenu');
20 jpm 1674
			$info['message']['lignes'] = $noms_erreur;
1675
		} else {
1676
			$info['resultat'] = true;
1677
		}
64 jpm 1678
		$noms_erreur = null;
30 jpm 1679
		$this->traiterResultatTest($info);
20 jpm 1680
	}
1681
 
171 jpm 1682
	/**
173 jpm 1683
	 * Test #54
171 jpm 1684
	 */
173 jpm 1685
	private function testerSynonymeMalAppliqueSyntaxe() {
175 jpm 1686
		$info = $this->getInfosTest(54);
20 jpm 1687
 
1688
		// Réalisation du test
1689
		$noms_erreur = array();
64 jpm 1690
		foreach ($this->noms as &$nom) {
173 jpm 1691
			if ($nom['synonyme_mal_applique'] != '') {
1692
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
1693
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique']);
20 jpm 1694
				}
1695
			}
1696
		}
1697
 
1698
		// Analyse des résultats
1699
		if (count($noms_erreur) > 0) {
173 jpm 1700
			$info['message']['entete'] = array('num_nom', 'synonyme_mal_applique erroné');
20 jpm 1701
			$info['message']['lignes'] = $noms_erreur;
1702
		} else {
1703
			$info['resultat'] = true;
1704
		}
64 jpm 1705
		$noms_erreur = null;
20 jpm 1706
 
30 jpm 1707
		$this->traiterResultatTest($info);
20 jpm 1708
	}
1709
 
171 jpm 1710
	/**
173 jpm 1711
	 * Test #55
171 jpm 1712
	 */
173 jpm 1713
	private function testerSynonymeOrthographiqueSyntaxe() {
175 jpm 1714
		$info = $this->getInfosTest(55);
20 jpm 1715
 
1716
		// Réalisation du test
1717
		$noms_erreur = array();
173 jpm 1718
		foreach ($this->noms as $nom) {
1719
			if ($nom['synonyme_orthographique'] != '') {
1720
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
1721
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique']);
20 jpm 1722
				}
1723
			}
1724
		}
1725
 
1726
		// Analyse des résultats
1727
		if (count($noms_erreur) > 0) {
173 jpm 1728
			$info['message']['entete'] = array('num_nom', 'synonyme_orthographique erroné');
20 jpm 1729
			$info['message']['lignes'] = $noms_erreur;
1730
		} else {
1731
			$info['resultat'] = true;
1732
		}
64 jpm 1733
		$noms_erreur = null;
20 jpm 1734
 
30 jpm 1735
		$this->traiterResultatTest($info);
20 jpm 1736
	}
1737
 
171 jpm 1738
	/**
173 jpm 1739
	 * Test #56
171 jpm 1740
	 */
173 jpm 1741
	private function testerSynonymeOrthographiqueExistence() {
175 jpm 1742
		$info = $this->getInfosTest(56);
20 jpm 1743
 
1744
		// Réalisation du test
1745
		$noms_erreur = array();
64 jpm 1746
		foreach ($this->noms as &$nom) {
173 jpm 1747
			if ($nom['synonyme_orthographique'] != '') {
1748
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
1749
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique']);
20 jpm 1750
				}
1751
			}
1752
		}
1753
 
1754
		// Analyse des résultats
1755
		if (count($noms_erreur) > 0) {
173 jpm 1756
			$info['message']['entete'] = array('num_nom', 'synonyme_orthographique introuvable');
20 jpm 1757
			$info['message']['lignes'] = $noms_erreur;
1758
		} else {
1759
			$info['resultat'] = true;
1760
		}
64 jpm 1761
		$noms_erreur = null;
20 jpm 1762
 
30 jpm 1763
		$this->traiterResultatTest($info);
20 jpm 1764
	}
1765
 
171 jpm 1766
	/**
173 jpm 1767
	 * Test #57
171 jpm 1768
	 */
173 jpm 1769
	private function testerHybrideParent01Syntaxe() {
175 jpm 1770
		$info = $this->getInfosTest(57);
20 jpm 1771
 
1772
		// Réalisation du test
1773
		$noms_erreur = array();
64 jpm 1774
		foreach ($this->noms as &$nom) {
173 jpm 1775
			if ($nom['hybride_parent_01'] != '') {
1776
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
1777
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']));
20 jpm 1778
				}
1779
			}
1780
		}
1781
 
1782
		// Analyse des résultats
1783
		if (count($noms_erreur) > 0) {
173 jpm 1784
			$info['message']['entete'] = array('num_nom', 'hybride_parent_01 erroné');
20 jpm 1785
			$info['message']['lignes'] = $noms_erreur;
1786
		} else {
1787
			$info['resultat'] = true;
1788
		}
64 jpm 1789
		$noms_erreur = null;
20 jpm 1790
 
30 jpm 1791
		$this->traiterResultatTest($info);
20 jpm 1792
	}
1793
 
171 jpm 1794
	/**
173 jpm 1795
	 * Test #58
171 jpm 1796
	 */
173 jpm 1797
	private function testerHybrideParent01Existence() {
175 jpm 1798
		$info = $this->getInfosTest(58);
20 jpm 1799
 
1800
		// Réalisation du test
1801
		$noms_erreur = array();
64 jpm 1802
		foreach ($this->noms as &$nom) {
173 jpm 1803
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1804
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
1805
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']));
20 jpm 1806
				}
1807
			}
1808
		}
1809
 
1810
		// Analyse des résultats
1811
		if (count($noms_erreur) > 0) {
173 jpm 1812
			$info['message']['entete'] = array('num_nom', 'hybride_parent_01 introuvable');
20 jpm 1813
			$info['message']['lignes'] = $noms_erreur;
1814
		} else {
1815
			$info['resultat'] = true;
1816
		}
64 jpm 1817
		$noms_erreur = null;
20 jpm 1818
 
30 jpm 1819
		$this->traiterResultatTest($info);
20 jpm 1820
	}
171 jpm 1821
 
1822
	/**
173 jpm 1823
	 * Test #59
171 jpm 1824
	 */
173 jpm 1825
	private function testerHybrideParent02Syntaxe() {
175 jpm 1826
		$info = $this->getInfosTest(59);
20 jpm 1827
 
1828
		// Réalisation du test
1829
		$noms_erreur = array();
64 jpm 1830
		foreach ($this->noms as &$nom) {
173 jpm 1831
			if ($nom['hybride_parent_02'] != '') {
1832
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
1833
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']));
1834
				}
20 jpm 1835
			}
1836
		}
1837
 
1838
		// Analyse des résultats
1839
		if (count($noms_erreur) > 0) {
173 jpm 1840
			$info['message']['entete'] = array('num_nom', 'hybride_parent_02 erroné');
20 jpm 1841
			$info['message']['lignes'] = $noms_erreur;
1842
		} else {
1843
			$info['resultat'] = true;
1844
		}
64 jpm 1845
		$noms_erreur = null;
20 jpm 1846
 
30 jpm 1847
		$this->traiterResultatTest($info);
20 jpm 1848
	}
1849
 
171 jpm 1850
	/**
173 jpm 1851
	 * Test #60
171 jpm 1852
	 */
173 jpm 1853
	private function testerHybrideParent02Existence() {
175 jpm 1854
		$info = $this->getInfosTest(60);
20 jpm 1855
 
1856
		// Réalisation du test
1857
		$noms_erreur = array();
64 jpm 1858
		foreach ($this->noms as &$nom) {
173 jpm 1859
			if ($nom['hybride_parent_02'] != '') {
1860
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
1861
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']));
20 jpm 1862
				}
1863
			}
1864
		}
1865
 
1866
		// Analyse des résultats
1867
		if (count($noms_erreur) > 0) {
173 jpm 1868
			$info['message']['entete'] = array('num_nom', 'hybride_parent_02 introuvable');
20 jpm 1869
			$info['message']['lignes'] = $noms_erreur;
1870
		} else {
1871
			$info['resultat'] = true;
1872
		}
64 jpm 1873
		$noms_erreur = null;
20 jpm 1874
 
30 jpm 1875
		$this->traiterResultatTest($info);
20 jpm 1876
	}
1877
 
171 jpm 1878
	/**
173 jpm 1879
	 * Test #61
171 jpm 1880
	 */
173 jpm 1881
	private function testerPresenceSyntaxe() {
175 jpm 1882
		$info = $this->getInfosTest(61);
20 jpm 1883
 
1884
		// Réalisation du test
1885
		$noms_erreur = array();
64 jpm 1886
		foreach ($this->noms as &$nom) {
173 jpm 1887
			if ($nom['presence'] != '') {
1888
				if (!$this->verifierPresence($nom['presence'])) {
1889
					$noms_erreur[] = array($nom['num_nom'], $nom['presence']);
20 jpm 1890
				}
1891
			}
1892
		}
1893
 
1894
		// Analyse des résultats
1895
		if (count($noms_erreur) > 0) {
173 jpm 1896
			$info['message']['entete'] = array('num_nom', 'presence erroné');
20 jpm 1897
			$info['message']['lignes'] = $noms_erreur;
1898
		} else {
1899
			$info['resultat'] = true;
1900
		}
64 jpm 1901
		$noms_erreur = null;
20 jpm 1902
 
30 jpm 1903
		$this->traiterResultatTest($info);
20 jpm 1904
	}
1905
 
171 jpm 1906
	/**
173 jpm 1907
	 * Test #62
171 jpm 1908
	 */
173 jpm 1909
	private function testerStatutOrigineSyntaxe() {
175 jpm 1910
		$info = $this->getInfosTest(62);
20 jpm 1911
 
1912
		// Réalisation du test
1913
		$noms_erreur = array();
64 jpm 1914
		foreach ($this->noms as &$nom) {
173 jpm 1915
			if ($nom['statut_origine'] != '') {
1916
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
1917
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine']);
20 jpm 1918
				}
1919
			}
1920
		}
1921
 
1922
		// Analyse des résultats
1923
		if (count($noms_erreur) > 0) {
173 jpm 1924
			$info['message']['entete'] = array('num_nom', 'statut_origine erroné');
20 jpm 1925
			$info['message']['lignes'] = $noms_erreur;
1926
		} else {
1927
			$info['resultat'] = true;
1928
		}
64 jpm 1929
		$noms_erreur = null;
20 jpm 1930
 
30 jpm 1931
		$this->traiterResultatTest($info);
20 jpm 1932
	}
1933
 
171 jpm 1934
	/**
173 jpm 1935
	 * Test #63
171 jpm 1936
	 */
173 jpm 1937
	private function testerStatutIntroductionSyntaxe() {
175 jpm 1938
		$info = $this->getInfosTest(63);
20 jpm 1939
 
1940
		// Réalisation du test
1941
		$noms_erreur = array();
64 jpm 1942
		foreach ($this->noms as &$nom) {
173 jpm 1943
			if ($nom['statut_introduction'] != '') {
1944
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
1945
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction']);
20 jpm 1946
				}
1947
			}
1948
		}
1949
 
1950
		// Analyse des résultats
1951
		if (count($noms_erreur) > 0) {
173 jpm 1952
			$info['message']['entete'] = array('num_nom', 'statut_introduction erroné');
20 jpm 1953
			$info['message']['lignes'] = $noms_erreur;
1954
		} else {
1955
			$info['resultat'] = true;
1956
		}
64 jpm 1957
		$noms_erreur = null;
20 jpm 1958
 
30 jpm 1959
		$this->traiterResultatTest($info);
20 jpm 1960
	}
1961
 
171 jpm 1962
	/**
173 jpm 1963
	 * Test #64
171 jpm 1964
	 */
173 jpm 1965
	private function testerStatutCultureSyntaxe() {
175 jpm 1966
		$info = $this->getInfosTest(64);
20 jpm 1967
 
1968
		// Réalisation du test
1969
		$noms_erreur = array();
64 jpm 1970
		foreach ($this->noms as &$nom) {
173 jpm 1971
			if ($nom['statut_culture'] != '') {
1972
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
1973
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture']);
20 jpm 1974
				}
1975
			}
1976
		}
1977
 
1978
		// Analyse des résultats
1979
		if (count($noms_erreur) > 0) {
173 jpm 1980
			$info['message']['entete'] = array('num_nom', 'statut_culture erroné');
20 jpm 1981
			$info['message']['lignes'] = $noms_erreur;
1982
		} else {
1983
			$info['resultat'] = true;
1984
		}
64 jpm 1985
		$noms_erreur = null;
20 jpm 1986
 
30 jpm 1987
		$this->traiterResultatTest($info);
20 jpm 1988
	}
1989
 
171 jpm 1990
	/**
1991
	 * Test #65
1992
	 */
146 delphine 1993
	private function testerExclureTaxRefSyntaxe() {
171 jpm 1994
		$info = $this->getInfosTest(65);
175 jpm 1995
 
173 jpm 1996
		// Réalisation du testCe n'est pas programmé.
146 delphine 1997
		$noms_erreur = array();
1998
		foreach ($this->noms as &$nom) {
1999
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
2000
				if (!$this->verifierBooleen($nom['exclure_taxref'])) {
2001
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
2002
				}
2003
			}
2004
		}
2005
 
2006
		// Analyse des résultats
2007
		if (count($noms_erreur) > 0) {
2008
			$info['message']['entete'] = array('num_nom', 'exclure_taxref erroné');
2009
			$info['message']['lignes'] = $noms_erreur;
2010
		} else {
2011
			$info['resultat'] = true;
2012
		}
2013
		$noms_erreur = null;
2014
 
2015
		$this->traiterResultatTest($info);
2016
	}
171 jpm 2017
 
2018
 
2019
 
20 jpm 2020
	//+--------------------------------------------------------------------------------------------------------------+//
2021
	// MÉTHODES COMMUNES aux TESTS
2022
 
64 jpm 2023
	private function verifierPresence(&$valeur) {
20 jpm 2024
		$codes = $this->manuel['codes_presence'];
2025
		$ok = $this->verifierStatuts($valeur, $codes);
2026
		return $ok;
2027
	}
2028
 
64 jpm 2029
	private function verifierStatutOrigine(&$valeur) {
20 jpm 2030
		$codes = $this->manuel['codes_statuts_origine'];
2031
		$ok = $this->verifierStatuts($valeur, $codes);
2032
		return $ok;
2033
	}
2034
 
64 jpm 2035
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 2036
		$codes = $this->manuel['codes_statuts_introduction'];
2037
		$ok = $this->verifierStatuts($valeur, $codes);
2038
		return $ok;
2039
	}
2040
 
64 jpm 2041
	private function verifierStatutCulture(&$valeur) {
20 jpm 2042
		$codes = $this->manuel['codes_statuts_culture'];
2043
		$ok = $this->verifierStatuts($valeur, $codes);
2044
		return $ok;
2045
	}
2046
 
64 jpm 2047
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 2048
		$ok = true;
2049
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
2050
			$ok = false;
2051
		}
2052
		return $ok;
2053
	}
2054
 
64 jpm 2055
	private function verifierBooleen(&$valeur) {
20 jpm 2056
		$ok = true;
2057
		if (!preg_match('/^1$/', $valeur)) {
2058
			$ok = false;
2059
		}
2060
		return $ok;
2061
	}
2062
 
64 jpm 2063
	private function verifierNombre(&$valeur) {
20 jpm 2064
		$ok = true;
2065
		if (!preg_match('/^[0-9]+$/', $valeur)) {
2066
			$ok = false;
2067
		}
2068
		return $ok;
2069
	}
2070
 
64 jpm 2071
	private function verifierNombreSuite(&$valeur) {
20 jpm 2072
		$ok = true;
2073
		if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
2074
			$ok = false;
2075
		}
2076
		return $ok;
2077
	}
2078
 
64 jpm 2079
	private function verifierTypeEpithete(&$type) {
20 jpm 2080
		$ok = false;
2081
		$rejetes = $this->manuel['type_epithete_rejetes'];
2082
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
2083
			$ok = false;
2084
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
2085
			$ok = true;
2086
		}
2087
		return $ok;
2088
	}
2089
 
64 jpm 2090
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 2091
		$ok = true;
2092
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
2093
			$ok = false;// Contient des espaces en trop
2094
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
2095
			$ok = false;
2096
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
2097
			$ok = false;// Contient une mauvaise suite de caractères
2098
		}
2099
		return $ok;
2100
	}
2101
 
64 jpm 2102
	private function verifierAnnee(&$annee) {
20 jpm 2103
		$ok = true;
2104
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
2105
			$ok = false;
2106
		} else if ($annee < 1753) {
2107
			$ok = false;
2108
		}
2109
		return $ok;
2110
	}
2111
 
64 jpm 2112
	private function verifierAuteur(&$intitule) {
20 jpm 2113
		$ok = true;
2114
		$acceptes = $this->manuel['auteur_acceptes'];
2115
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
2116
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
2117
				$ok = false;// Contient des espaces en trop
2118
			} else {
2119
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
2120
				$mots = explode(' ', $intitule);
2121
				foreach ($mots as $position => $mot) {
2122
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
2123
						$ok = false;// Mot rejeté
2124
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\)-])+|[&])$/u", $mot)) {
2125
						continue;// Mot de l'intitulé auteur
2126
					} else {
2127
						$ok = false;
2128
					}
2129
				}
2130
			}
2131
		}
2132
		return $ok;
2133
	}
2134
 
64 jpm 2135
	private function verifierNomCommercial(&$epithete) {
20 jpm 2136
		$ok = false;
2137
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
2138
			$ok = true;
2139
		}
2140
		return $ok;
2141
	}
2142
 
64 jpm 2143
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 2144
		$ok = true;
2145
		$acceptes = $this->manuel['cultivar_acceptes'];
2146
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
2147
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
2148
				$ok = false;// Contient des espaces en trop
2149
			} else {
2150
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
2151
				$mots_mineurs = $this->manuel['mots_mineurs'];
2152
				$mots = explode(' ', $epithete);
2153
				foreach ($mots as $position => $mot) {
2154
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
2155
						$ok = false;// Mot rejeté
2156
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
2157
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
2158
					} else {
2159
						$mots_tiret = explode('-', $mot);
2160
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
2161
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
2162
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
2163
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
2164
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
2165
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
2166
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
2167
							} else {
2168
								$ok = false;
2169
							}
2170
						}
2171
					}
2172
				}
2173
			}
2174
		}
2175
		return $ok;
2176
	}
2177
 
64 jpm 2178
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 2179
		$ok = true;
2180
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
2181
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
2182
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
2183
				$ok = false;// Contient des espaces en trop
2184
			} else {
2185
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
2186
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
2187
				$mots_mineurs = $this->manuel['mots_mineurs'];
2188
				$mots = explode(' ', $epithete);
2189
				foreach ($mots as $position => $mot) {
2190
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
2191
						continue;// Mot accepté
2192
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
2193
						$ok = false;// Mot rejeté
2194
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
2195
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
2196
					} else {
2197
						$mots_tiret = explode('-', $mot);
2198
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
2199
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
2200
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
2201
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
2202
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
2203
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
2204
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
2205
							} else {
2206
								$ok = false;
2207
							}
2208
						}
2209
					}
2210
				}
2211
			}
2212
		}
2213
		return $ok;
2214
	}
2215
 
64 jpm 2216
	private function verifierEpitheteSp(&$epithete) {
20 jpm 2217
		$ok = false;
2218
		if (preg_match('/^[a-zëï][-a-zëï]+$/', $epithete)) {
2219
			$ok = true;
2220
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
2221
			$ok = true;
2222
		}
2223
		return $ok;
2224
	}
2225
 
64 jpm 2226
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 2227
		$ok = false;
2228
		if (preg_match('/^[A-ZËÏ](?:[-a-zëï]+|[a-zëï]+-[A-ZËÏ][a-zëï]+)$/', $epithete)) {
2229
			$ok = true;
2230
		}
2231
		return $ok;
2232
	}
2233
 
64 jpm 2234
	private function formaterStyleNomGenre(&$genre) {
20 jpm 2235
		$genre_fmt = '';
2236
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
2237
			$genre_fmt = strtolower($match[1]).' '.ucfirst(strtolower($match[2]));
2238
		} else {
2239
			$genre_fmt = ucfirst(strtolower($genre));
2240
		}
2241
		return $genre_fmt;
2242
	}
2243
 
149 jpm 2244
	private function repererEspace($nom_sci) {
2245
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
2246
		return $nom_sci;
20 jpm 2247
	}
2248
 
64 jpm 2249
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 2250
		$suffixe = array();
2251
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
2252
		$suffixe[] = $this->construireNomCommercial($nom);
2253
		$suffixe[] = $this->construireNomCultivar($nom);
2254
		$suffixe = array_filter($suffixe);
2255
		return implode(' ', $suffixe);
2256
	}
2257
 
64 jpm 2258
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 2259
		$nom_groupe_cultivar = '';
2260
		if ($nom['cultivar_groupe'] != '') {
2261
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
2262
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
2263
			} else {
2264
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
2265
			}
2266
		}
2267
		return $nom_groupe_cultivar;
2268
	}
2269
 
64 jpm 2270
	private function construireNomCommercial(&$nom) {
20 jpm 2271
		$nom_commercial = '';
2272
		if ($nom['nom_commercial'] != '') {
2273
			$nom_commercial =  strtoupper($nom['nom_commercial']);
2274
		}
2275
		return $nom_commercial;
2276
	}
2277
 
64 jpm 2278
	private function construireNomCultivar(&$nom) {
20 jpm 2279
		$nom_cultivar = '';
2280
		if ($nom['cultivar'] != '') {
2281
			$nom_cultivar =  "'".$nom['cultivar']."'";
2282
		}
2283
		return $nom_cultivar;
2284
	}
2285
 
64 jpm 2286
	private function classerNomsParNomComplet() {
20 jpm 2287
		$noms_classes = array();
64 jpm 2288
		foreach ($this->noms as &$nom) {
149 jpm 2289
			if (!isset($noms_classes[$nom['nom_sci']])) {
2290
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 2291
			} else {
149 jpm 2292
				$noms_classes[$nom['nom_sci']]++;
20 jpm 2293
			}
2294
		}
2295
		return $noms_classes;
2296
	}
2297
 
171 jpm 2298
	private function getInfosTest($numero) {
2299
		$info = $this->tests[$numero];
175 jpm 2300
		$info['methode'] = 'tester'.implode('', explode(' ', ucwords($info['abr'])));
171 jpm 2301
		$info['numero'] = $numero;
2302
		$info['resultat'] = false;
2303
		return $info;
2304
	}
20 jpm 2305
}
2306
?>