Merge pull request '31.03.26' (#4) from 31.03.26 into master

Reviewed-on: #4

Projet.iml

@@ -7,5 +7,39 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library" scope="TEST">
+      <library name="JUnit6">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter/6.0.0/junit-jupiter-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/6.0.0/junit-jupiter-api-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/6.0.0/junit-platform-commons-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/jspecify/jspecify/1.0.0/jspecify-1.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-params/6.0.0/junit-jupiter-params-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-engine/6.0.0/junit-jupiter-engine-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/6.0.0/junit-platform-engine-6.0.0.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library>
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter/6.0.0/junit-jupiter-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/6.0.0/junit-jupiter-api-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.3.0/opentest4j-1.3.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/6.0.0/junit-platform-commons-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/jspecify/jspecify/1.0.0/jspecify-1.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-params/6.0.0/junit-jupiter-params-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-engine/6.0.0/junit-jupiter-engine-6.0.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/6.0.0/junit-platform-engine-6.0.0.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
   </component>
 </module>

UML/classes.puml

@@ -46,7 +46,7 @@ namespace ecoparasite {
     namespace ecoparasite.poissons {
 
         class Poisson {
-            - String specie
+            - String id
             - Double length
             - Double weight
             - Double infestation

data/Campagne/merlu2018_75164.csv

@@ -1,4 +1,4 @@
-nom.merlu;m.size (mm);number of Anisakis sp L3;m.d15N (<EFBFBD>);m.d13C (<EFBFBD>);m.C/N;m.MeHg (ng g-1 dw);m.IHg (ng g-1 dw);m.THg (ng g-1 dw);m.PCB 101 (ng g-1 dw);m.PCB 118 (ng g-1 dw);m.PCB 138 (ng g-1 dw);m.PCB 149 (ng g-1 dw);m.PCB 153 (ng g-1 dw);m.PCB 180 (ng g-1 dw);m.PCB 194 (ng g-1 dw);m.HHCB (ng g-1 dw);m.AHTN (ng g-1 dw);m.EHMC (ng g-1 dw);;a.d15N (<EFBFBD>);a.d13C (<EFBFBD>);a.CN;a.MeHg (ng g-1 dw);a.IHg (ng g-1 dw);a.THg (ng g-1 dw);a.PCB 101 (ng g-1 dw);a.PCB 118 (ng g-1 dw);a.PCB 138 (ng g-1 dw);a.PCB 149 (ng g-1 dw);a.PCB 153 (ng g-1 dw);a.PCB 180 (ng g-1 dw);a.PCB 194 (ng g-1 dw);a.HHCB (ng g-1 dw);a.AHTN (ng g-1 dw);a.OC (ng g-1 dw)
+nom.merlu;m.size (mm);number of Anisakis sp L3;m.d15N (‰);m.d13C (‰);m.C/N;m.MeHg (ng g-1 dw);m.IHg (ng g-1 dw);m.THg (ng g-1 dw);m.PCB 101 (ng g-1 dw);m.PCB 118 (ng g-1 dw);m.PCB 138 (ng g-1 dw);m.PCB 149 (ng g-1 dw);m.PCB 153 (ng g-1 dw);m.PCB 180 (ng g-1 dw);m.PCB 194 (ng g-1 dw);m.HHCB (ng g-1 dw);m.AHTN (ng g-1 dw);m.EHMC (ng g-1 dw);;a.d15N (‰);a.d13C (‰);a.CN;a.MeHg (ng g-1 dw);a.IHg (ng g-1 dw);a.THg (ng g-1 dw);a.PCB 101 (ng g-1 dw);a.PCB 118 (ng g-1 dw);a.PCB 138 (ng g-1 dw);a.PCB 149 (ng g-1 dw);a.PCB 153 (ng g-1 dw);a.PCB 180 (ng g-1 dw);a.PCB 194 (ng g-1 dw);a.HHCB (ng g-1 dw);a.AHTN (ng g-1 dw);a.OC (ng g-1 dw)
 150318 HKE01;425;237;13.36;-18.23;3.10;610.21;244.26;854.48;2.85;1.59;28.78;9.10;32.84;22.60;3.40;1.26;<LOQ;<LOQ;;10.84;-19.32;5.88;67.69;8.57;76.26;18.26;10.74;45.90;17.54;41.19;32.64;<LOQ;<LOQ;<LOQ;83.21
 150318 HKE08;527;276;13.44;-18.22;3.15;749.39;1110.64;1860.03;3.25;1.32;27.91;8.73;34.12;22.66;1.73;0.19;<LOQ;<LOQ;;11.57;-18.74;5.01;77.88;14.85;92.73;11.56;6.56;31.88;15.19;37.80;21.68;<LOQ;3.38;2.31;63.30
 150318 HKE09;540;454;13.53;-17.99;3.11;796.23;299.18;1095.40;3.74;3.39;25.72;9.04;32.81;13.87;2.80;1.09;0.11;<LOQ;;11.13;-18.69;5.23;86.01;16.39;102.40;10.74;9.06;63.45;22.81;73.25;47.00;<LOQ;1.96;<LOQ;36.78

data/test.csv

@@ -0,0 +1,4 @@
+Sample_code;Station;Latitude;Longitude;Depth;d13C_raw;d13C_corr;d15N;C_N;StandardLength;TrophicLevel;Anisakis_abdominalcavity;Anisakis_Liver;Anisakis_gonads;Anisakis_stomach;NParasitesViscera;Anisakis_Muscle_Right;Anisakis_Muscle_Left;Aniskis_Muscle_total;NParasitesTotal
+TRACTRA_S0575_A0439;S0575;48.8692264;-4.3976635;96.84;-20.09735065;-19.14374028;12.52361179;4.316778148;257;3.117572211;7;1;0;1;9;1;3;4;13
+TRACTRA_S0575_A0440;S0575;48.8692264;-4.3976635;96.84;-20.02738845;-19.42703789;12.25444555;3.959950061;252;3.038405671;263;5;0;21;289;12;11;23;312
+TRACTRA_S0575_A0441;S0575;48.8692264;-4.3976635;96.84;-19.82735569;-18.83090708;12.97020596;4.360049101;254;3.248923438;51;1;12;1;65;2;3;5;70

src/ecoparasite/input/DataParsing.java

@@ -4,7 +4,12 @@ import ecoparasite.poisson.Poisson;
 
 import java.util.HashSet;
 
+/**
+ * Interface définissant la fonction de Parsing des données
+ */
 public interface DataParsing {
 
-    public HashSet<Poisson> parse(RawData data);
+    public static HashSet<Poisson> parse(RawData data) throws RawDataOverflow {
+        return null;
+    }
 }

src/ecoparasite/input/InputFactory.java

@@ -18,6 +18,7 @@ public class InputFactory {
 
     final public static String DATA_MACKEREL = "Campagne/mackerel.97442.csv";
     final public static String DATA_MERLU = "Campagne/merlu2018_75164.csv";
+    final public static String DATA_PARASITES_PERU = "Combinés/ParasitesPeru2021.csv";
 
     /**
      * Construit le chemin vers le fichier de données voulu.

src/ecoparasite/input/RawData.java

@@ -110,7 +110,7 @@ public class RawData {
         HashMap<String,String> entry = new HashMap<>();
 
         for( ArrayList<String> row : data ){
-            if( index > row.size()){
+            if( index >= row.size()){
                 throw new RawDataOverflow( index, row.size() );
             }
             entry.put( row.getFirst(), row.get( index ) );

src/ecoparasite/poisson/Mackerel.java

@@ -2,24 +2,47 @@ package ecoparasite.poisson;
 
 import ecoparasite.input.DataParsing;
 import ecoparasite.input.RawData;
+import ecoparasite.input.RawDataOverflow;
 
+import java.util.HashMap;
 import java.util.HashSet;
 
+import static java.lang.Double.valueOf;
+
 /**
  * Hérite de Poisson.
  * Ajoute les fonctions de Parsing liés aux données collectées sur le Mackerel.
  */
 public class Mackerel extends Poisson implements DataParsing {
-    public Mackerel(String species, Double length, Double infestation) {
+
-        super(species, length, null, infestation);
+    /**
+     * Constructeur de Mackerel
+     * @param length
+     * @param infestation
+     */
+    public Mackerel(String id, Double length, Double infestation) {
+        super(id, length, null, infestation);
     }
 
-    @Override
+    /**
-    public HashSet<Poisson> parse(RawData data) {
+     * Implémentation de la fonction parse de Dataparsing
+     * @param data
+     * @return tableau des poissons
+     */
+    public static HashSet<Poisson> parse(RawData data) throws RawDataOverflow {
+
+        HashMap<String,String> temp = new HashMap<>();
 
         HashSet<Poisson> fishSet;
         fishSet = new HashSet<>();
 
+        for (int i = 0; i < data.getData().getFirst().size(); i++) {
+            temp = data.getEntry(i);
+            Poisson newP = new Mackerel(temp.get("Sample_code"),valueOf(temp.get("StandardLength")),valueOf(temp.get("NParasitesViscera")));
+
+            fishSet.add(newP);
+        }
+
 
         return fishSet;
     }

src/ecoparasite/poisson/Merlu.java

@@ -2,9 +2,13 @@ package ecoparasite.poisson;
 
 import ecoparasite.input.DataParsing;
 import ecoparasite.input.RawData;
+import ecoparasite.input.RawDataOverflow;
 
+import java.util.HashMap;
 import java.util.HashSet;
 
+import static java.lang.Double.valueOf;
+
 /**
  * Hérite de Poisson.
  * Ajoute les fonctions de Parsing liés aux données collectées sur le Merlu.
@@ -16,8 +20,8 @@ public class Merlu extends Poisson implements DataParsing {
      * @param length Un Wrapper Double representant la longueur/taille du poisson
      * @param infestation Un Wrapper Double representant le taux de parasite du poisson
      */
-    public Merlu(Double length, Double infestation) {
+    public Merlu(String id, Double length, Double infestation) {
-        super("Merlu", length, null, infestation);
+        super(id, length, null, infestation);
     }
 
     /**
@@ -25,12 +29,20 @@ public class Merlu extends Poisson implements DataParsing {
      * @param data
      * @return tableau des poissons
      */
-    @Override
+    public static HashSet<Poisson> parse(RawData data) throws RawDataOverflow {
-    public HashSet<Poisson> parse(RawData data) { //TODO
+
+        HashMap<String,String> temp = new HashMap<>();
 
         HashSet<Poisson> fishSet;
         fishSet = new HashSet<>();
 
+        for (int i = 0; i < data.getData().getFirst().size(); i++) {
+            temp = data.getEntry(i);
+            Poisson newP = new Merlu(temp.get("nom.merlu"),valueOf(temp.get("m.size (mm)")),valueOf(temp.get("number of Anisakis sp L3")));
+
+            fishSet.add(newP);
+        }
+
 
         return fishSet;
     }

src/ecoparasite/poisson/Poisson.java

@@ -8,7 +8,7 @@ import java.util.HashSet;
  */
 public class Poisson{
 
-    private String specie;
+    private String id;
     private Double length;
     private Double weight;
     private Double infestation;
@@ -16,13 +16,13 @@ public class Poisson{
 
     /**
      * Constructeur de l'objet Poisson
-     * @param specie Une String representant l'espece du poisson
+     * @param id Une String representant l'espece du poisson
      * @param length Un Wrapper Double representant la longueur/taille du poisson
      * @param weight Un Wrapper Double representant le poids du poisson
      * @param infestation Un Wrapper Double representant le taux de parasite du poisson
      */
-    public Poisson(String specie, Double length, Double weight, Double infestation){
+    public Poisson(String id, Double length, Double weight, Double infestation){
-        this.specie = specie;
+        this.id = id;
         this.length = length;
         this.weight = weight;
         this.infestation = infestation;
@@ -30,11 +30,11 @@ public class Poisson{
     }
 
     /**
-     * Getter de l'attribut specie
+     * Getter de l'attribut Id
-     * @return La string de l'attribut specie
+     * @return La string de l'attribut Id
      */
-    public String getSpecie() {
+    public String getId() {
-        return specie;
+        return id;
     }
 
     /**
@@ -67,7 +67,7 @@ public class Poisson{
      */
     @Override
     public String toString(){
-        String result = "[ %5s : %4d mm, %4d g, %4d taux d'infestation ]";
+        String result = "[ %5s : %4f mm, %4f g, %4f taux d'infestation ]";
-        return String.format(result, this.getClass().getSimpleName(), this.getLength(), this.getWeight(), this.getInfestation());
+        return String.format(result, this.getClass().getSimpleName(), this.getLength(), this.getWeight(), this.getInfestation() );
     }
 }

src/ecoparasite/population/Population.java

@@ -0,0 +1,50 @@
+    package ecoparasite.population;
+
+    import java.util.HashMap;
+    import java.util.HashSet;
+
+    public class Population {
+
+        private String id;
+        private PopulationArgs total;
+        private HashMap<Integer,PopulationArgs> perYear;
+
+        public Population(String id, PopulationArgs total, HashMap<Integer,PopulationArgs> perYear) {
+            this.id = id;
+            this.total = total;
+            this.perYear = perYear;
+        }
+
+        public Population(String id, PopulationArgs total) {
+            this.id = id;
+            this.total = total;
+            this.perYear = new HashMap<>();
+        }
+
+        public Population(String id) {
+            this.id = id;
+            this.total = null;
+            this.perYear = new HashMap<>();
+        }
+
+        public String getId() {
+            return id;
+        }
+
+        public PopulationArgs getTotal() {
+            return total;
+        }
+
+        public HashMap<Integer,PopulationArgs> getPerYear() {
+            return perYear;
+        }
+
+        public void setTotal(PopulationArgs total) {
+            this.total = total;
+        }
+
+        public void setPerYear(HashMap<Integer,PopulationArgs> perYear) {
+            this.perYear = perYear;
+        }
+
+    }

src/ecoparasite/population/PopulationArgInterval.java

@@ -0,0 +1,60 @@
+package ecoparasite.population;
+
+public class PopulationArgInterval {
+
+    private Double min;
+    private Double max;
+
+    private Double mean;
+
+    public PopulationArgInterval(Double min, Double max, Double mean) {
+        this.min = min;
+        this.max = max;
+        this.mean = mean;
+    }
+    public PopulationArgInterval(Double min, Double max) {
+        this.min = min;
+        this.max = max;
+        this.mean = ( this.max + this.min ) / 2;
+    }
+
+    public Double getMin() {
+        return this.min;
+    }
+    public Double getMax() {
+        return this.max;
+    }
+    public Double getMean() {
+        return this.mean;
+    }
+
+    public Double transformToDouble(){
+        if( this.min == this.max )
+            return this.min;
+        return this.mean;
+    }
+
+    public static PopulationArgInterval fromString( String rawValue ){
+
+        if( rawValue.contains( "±" ) ){ // Plus ou moins.
+
+            String[] numbers = rawValue.split("±");
+            Double mean = Double.parseDouble(numbers[0].trim());
+            Double interval = Double.parseDouble(numbers[1].trim());
+            return new PopulationArgInterval(mean - interval, mean + interval, mean);
+
+        } else if( rawValue.contains( "-" ) ){ // Entre.
+
+            String[] numbers = rawValue.split("-");
+            Double min = Double.parseDouble(numbers[0].trim());
+            Double max = Double.parseDouble(numbers[1].trim());
+            return new PopulationArgInterval(min, max);
+
+        } else {
+            Double number =  Double.parseDouble(rawValue);
+            return new PopulationArgInterval(number, number);
+        }
+
+    }
+
+}

src/ecoparasite/population/PopulationArgs.java

@@ -0,0 +1,124 @@
+package ecoparasite.population;
+
+public class PopulationArgs {
+
+    private int year;
+
+    private int number;
+    private PopulationArgInterval length;
+    private PopulationArgInterval width;
+    private PopulationArgInterval prevalence;
+    private PopulationArgInterval ic;
+    private Double intensity;
+    private Double abondance;
+
+    public PopulationArgs(
+            int N,
+            PopulationArgInterval length,
+            PopulationArgInterval width,
+            PopulationArgInterval prevalence,
+            PopulationArgInterval ic,
+            Double intensity,
+            Double abondance
+    ){
+        this.year = 0;
+        this.number = N;
+        this.length = length;
+        this.width = width;
+        this.prevalence = prevalence;
+        this.ic = ic;
+        this.intensity = intensity;
+        this.abondance = abondance;
+    }
+
+    public PopulationArgs(
+            int year,
+            int N,
+            PopulationArgInterval length,
+            PopulationArgInterval width,
+            PopulationArgInterval prevalence,
+            PopulationArgInterval ic,
+            Double intensity,
+            Double abondance
+    ){
+        this.year = year;
+        this.number = N;
+        this.length = length;
+        this.width = width;
+        this.prevalence = prevalence;
+        this.ic = ic;
+        this.intensity = intensity;
+        this.abondance = abondance;
+    }
+
+    public PopulationArgs(
+            int year
+    ){
+        this.year = year;
+    }
+
+    public PopulationArgs(){
+        this.year = 0;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    public PopulationArgInterval getLength() {
+        return length;
+    }
+
+    public PopulationArgInterval getWidth() {
+        return width;
+    }
+
+    public PopulationArgInterval getPrevalence() {
+        return prevalence;
+    }
+
+    public PopulationArgInterval getIc() {
+        return ic;
+    }
+
+    public Double getIntensity() {
+        return intensity;
+    }
+
+    public Double getAbondance() {
+        return abondance;
+    }
+
+    public void setNumber(int number) {
+        this.number = number;
+    }
+
+    public void setLength(PopulationArgInterval length) {
+        this.length = length;
+    }
+
+    public void setWidth(PopulationArgInterval width) {
+        this.width = width;
+    }
+
+    public void setPrevalence(PopulationArgInterval prevalence) {
+        this.prevalence = prevalence;
+    }
+
+    public void setIc(PopulationArgInterval ic) {
+        this.ic = ic;
+    }
+
+    public void setIntensity(Double intensity) {
+        this.intensity = intensity;
+    }
+
+    public void setAbondance(Double abondance) {
+        this.abondance = abondance;
+    }
+
+}

src/ecoparasite/population/PopulationParsing.java

@@ -0,0 +1,97 @@
+package ecoparasite.population;
+
+import ecoparasite.input.RawData;
+import ecoparasite.input.RawDataOverflow;
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class PopulationParsing {
+
+    public static HashMap<String,Population> parseParasitesPeru(RawData peruRawData ){
+
+        HashMap<String,Population> response = new HashMap<>();
+
+        int index = 1;
+        try {
+            while(true){ // Tant que l'on ne fait pas de débordements d'entrées.
+
+                HashMap<String,String> fields = peruRawData.getEntry(index);
+
+                String espece = fields.get("Espèce");
+                System.out.println(espece);
+                String parametre = fields.get("Paramètre");
+
+                Population population = null;
+                if( response.containsKey( espece ) ){
+                    population = response.get(espece);
+                } else {
+                    population = new Population(espece);
+                    response.put(espece, population);
+                }
+
+                // Traiter le total
+                if( fields.containsKey( "Total" ) ){
+                    if( population.getTotal() == null ){
+                        population.setTotal( new PopulationArgs() );
+                    }
+                    PopulationParsing.applyValueForParasitesPeru( population.getTotal(), parametre, fields.get("Total") );
+                }
+
+                // Traiter les années.
+                for( String k:  fields.keySet() ){
+                    if( k.equals( "Total" ) || k.equals("Paramètre") || k.equals("Espèce") ) // Déjà traité. Pas des années.
+                        continue;
+
+                    Integer year = Integer.parseInt(k);
+
+                    PopulationArgs popArgsYear = null;
+                    if( !population.getPerYear().containsKey(year) ){
+                        popArgsYear = new PopulationArgs( year );
+                        population.getPerYear().put(year, popArgsYear);
+                    } else {
+                        popArgsYear = population.getPerYear().get(year);
+                    }
+
+                    PopulationParsing.applyValueForParasitesPeru( popArgsYear, parametre, fields.get(k) );
+                }
+
+                response.put( espece, population );
+                index++;
+            }
+        } catch (RawDataOverflow e){
+            // Stop.
+        }
+
+        return response;
+    }
+
+    private static void applyValueForParasitesPeru( PopulationArgs populationArgs, String column, String value ){
+        switch( column ){
+            case "N":
+                populationArgs.setNumber(Integer.parseInt(value));
+                break;
+            case "Longueur moyenne ± SD (cm)":
+                populationArgs.setLength( PopulationArgInterval.fromString( value ) );
+                break;
+            case "Poids moyen ± SD (g)":
+                populationArgs.setWidth( PopulationArgInterval.fromString( value ) );
+                break;
+            case "Prévalence (%)":
+                populationArgs.setPrevalence( PopulationArgInterval.fromString( value ) );
+                break;
+            case "IC 95%":
+                populationArgs.setIc( PopulationArgInterval.fromString( value ) );
+                break;
+            case "Intensité moyenne (étendue)":
+                populationArgs.setIntensity( Double.parseDouble( value.split( " " )[0] ) );
+                break;
+            case "Abondance moyenne":
+                populationArgs.setAbondance( Double.parseDouble( value ) );
+                break;
+            default:
+                break;
+        }
+    }
+
+}

tests/ecoparasite/input/InputFactoryTest.java

@@ -1,21 +1,36 @@
 package ecoparasite.input;
 
+import static ecoparasite.input.InputFactory.*;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import ecoparasite.input.InputFactory;
+import ecoparasite.input.InputFileException;
+import ecoparasite.input.RawData;
 import org.junit.jupiter.api.Test;
 
-import java.io.IOException;
-
-import static org.junit.jupiter.api.Assertions.*;
-
 class InputFactoryTest {
 
-    // TODO : Test a être effectué par Sébastien.
+    @org.junit.jupiter.api.Test
-    @Test
+    void buildDataPath() {
-    void readFile() throws InputFileException, RawDataOverflow {
+
-        RawData r = InputFactory.readData( InputFactory.DATA_MACKEREL );
+        String d = "data/Campagne/mackerel.97442.csv";
-        System.out.println( r );
+        String e = "data/Campagne/merlu2018_75164.csv";
-        System.out.println( r.getColumnsNames() );
+
-        System.out.println( r.getDataFromColumn( "Sample_codE" ) );
+        assertArrayEquals(d.toCharArray(), InputFactory.buildDataPath("Campagne/mackerel.97442.csv").toCharArray());
-        System.out.println( r.getEntry( 2 ) );
+        assertArrayEquals(e.toCharArray(), InputFactory.buildDataPath("Campagne/merlu2018_75164.csv").toCharArray());
+
+    }
+
+    @org.junit.jupiter.api.Test
+    void readData() throws InputFileException {
+        RawData test = InputFactory.readData("test.csv");
+
+        System.out.println(test.getData());
+
+    }
+
+    @org.junit.jupiter.api.Test
+    void testReadData() {
     }
 
 }

tests/ecoparasite/input/RawDataTest.java

@@ -0,0 +1,42 @@
+package ecoparasite.input;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.HashSet;
+
+class RawDataTest {
+
+
+    @Test
+    void getColumnsNames() throws InputFileException {
+        RawData test = InputFactory.readData("test.csv");
+
+        HashSet<String> d = new HashSet<>();
+
+        for (int i = 0; i < test.getData().size(); i++){
+            d.add(test.getData().get(i).getFirst());
+        }
+
+        System.out.println(test.getColumnsNames());
+        System.out.println(d);
+
+        assertIterableEquals(test.getColumnsNames(),d);
+    }
+
+    @Test
+    void getDataFromColumn() throws InputFileException {
+        RawData test = InputFactory.readData("test.csv");
+
+        System.out.println(test.getDataFromColumn("Sample_code"));
+
+    }
+
+    @Test
+    void getEntry() throws InputFileException, RawDataOverflow {
+        RawData test = InputFactory.readData("test.csv");
+
+        System.out.println(test.getEntry(2));
+    }
+}

tests/ecoparasite/poisson/MackerelTest.java

@@ -0,0 +1,24 @@
+package ecoparasite.poisson;
+
+import ecoparasite.input.InputFactory;
+import ecoparasite.input.InputFileException;
+import ecoparasite.input.RawData;
+import ecoparasite.input.RawDataOverflow;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashSet;
+
+class MackerelTest {
+
+    @Test
+    void parse() throws InputFileException, RawDataOverflow {
+
+        RawData test = InputFactory.readData( InputFactory.DATA_MACKEREL );
+        HashSet<Poisson> fishs = Mackerel.parse( test );
+
+        for( Poisson poisson : fishs){
+            System.out.println(poisson);
+        }
+    }
+
+}

tests/ecoparasite/poisson/MerluTest.java

@@ -0,0 +1,26 @@
+package ecoparasite.poisson;
+
+import ecoparasite.input.InputFactory;
+import ecoparasite.input.InputFileException;
+import ecoparasite.input.RawData;
+import ecoparasite.input.RawDataOverflow;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashSet;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MerluTest {
+
+    @Test
+    void parse() throws InputFileException, RawDataOverflow {
+
+        RawData test = InputFactory.readData( InputFactory.DATA_MERLU );
+        HashSet<Poisson> fishs = Merlu.parse( test );
+
+        for( Poisson poisson : fishs){
+            System.out.println(poisson);
+        }
+    }
+
+}

tests/ecoparasite/population/PopulationParsingTest.java

@@ -0,0 +1,22 @@
+package ecoparasite.population;
+
+import ecoparasite.input.InputFactory;
+import ecoparasite.input.InputFileException;
+import ecoparasite.input.RawData;
+import ecoparasite.input.RawDataOverflow;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class PopulationParsingTest {
+
+    @Test
+    void parseParasitesPeru() throws InputFileException, RawDataOverflow {
+
+        RawData parasitesPeru = InputFactory.readData( InputFactory.DATA_PARASITES_PERU, "," );
+        HashMap<String,Population> populations = PopulationParsing.parseParasitesPeru( parasitesPeru );
+        System.out.println( populations);
+    }
+}