[Observe-commits] 02/03: implantation du service de generation des rapport + test (refs #7498)

3 Sep 2015

This is an automated email from the git hooks/post-receive script.

New commit to branch feature/7498 in repository observe.

See http://git.codelutin.com/observe.git

commit 56de087611267571e3994c9e9bd137849dd6507e
Author: Sylvain Bavencoff <bavencoff@codelutin.com>
Date:   Thu Sep 3 10:11:26 2015 +0200

    implantation du service de generation des rapport + test (refs #7498)
---
 .../report/AbstractReportServiceTopiaTest.java     | 242 ++++++
 .../actions/report/ReportAccessoryCatch2Test.java  | 199 +++++
 .../report/ReportAccessoryCatchByGroup2Test.java   |  68 ++
 .../report/ReportAccessoryCatchByGroupTest.java    | 100 +++
 .../actions/report/ReportAccessoryCatchTest.java   | 156 ++++
 .../report/ReportActivityWithCommentTest.java      | 348 ++++++++
 .../actions/report/ReportAllActivitysTest.java     | 943 +++++++++++++++++++++
 .../actions/report/ReportDailySetAndCatchTest.java | 103 +++
 .../service/actions/report/ReportDcpUsageTest.java | 142 ++++
 .../report/ReportSetByAssociation2Test.java        |  50 ++
 .../actions/report/ReportSetByAssociationTest.java | 128 +++
 .../report/ReportTargetCatchByAssociationTest.java | 116 +++
 .../ReportTargetDiscardedByAssociationTest.java    | 116 +++
 13 files changed, 2711 insertions(+)

diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/AbstractReportServiceTopiaTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/AbstractReportServiceTopiaTest.java
new file mode 100644
index 0000000..302845c
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/AbstractReportServiceTopiaTest.java
@@ -0,0 +1,242 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import fr.ird.observe.services.dto.ReferenceDtos;
+import fr.ird.observe.services.service.AbstractServiceTopiaTest;
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import fr.ird.observe.services.service.actions.report.model.ReportVariable;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Classe abstraite de test d'un report.
+ * <p/>
+ * On définit ici le mécanisme pour tester unitairement un report et son
+ * résultat.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public abstract class AbstractReportServiceTopiaTest extends AbstractServiceTopiaTest {
+
+    /** Logger */
+    private static final Log log = LogFactory.getLog(AbstractReportServiceTopiaTest.class);
+
+    protected ReportService service;
+
+    /** La liste de tous les reports connus. */
+    protected static List<Report> reports;
+
+    /** Le report à tester. */
+    private Report report;
+
+    protected abstract String getReportId();
+
+    @Override
+    public String getScriptName() {
+        return "dataForTestSeine";
+    }
+
+    @Override
+    public Set<String> getTestNamesChangeDataBase() {
+        return ImmutableSet.of();
+    }
+
+    @Before
+    public final void setUp() throws Exception {
+
+        super.setUp();
+
+        service = newService(ReportService.class);
+
+        // recuperation du report à tester
+        report = getReport(log, getReportId());
+
+        if (log.isInfoEnabled()) {
+            log.info("Will use report '" + report + "'");
+        }
+
+    }
+
+
+    /**
+     * L'unique test à lancer.
+     * <p/>
+     * On vérifie :
+     * <ul>
+     * <li>la syntaxe du report via {@link #testReportSyntax(Report)}</li>
+     * <li>le résultat du report via {@link #testReportResult(DataMatrix)}</li>
+     * </ul>
+     *
+     * @throws Exception pour toute erreur lors de l'execution du report
+     */
+    @Test
+    public final void testReport() throws Exception {
+
+        // test de la syntaxe du report
+        testReportSyntax(report);
+
+        // creation de l'executeur de report
+        report = service.populateVariables(report, TRIP_SEINE_ID_1);
+
+        // les variables a utiliser (par defaut, pas de variable)
+        Map<String, Object> variables = new HashMap<String, Object>();
+
+        // preparation des variables
+        prepareVariables();
+
+
+        // on execute le report
+        DataMatrix result = service.executeReport(report, TRIP_SEINE_ID_1);
+
+        if (log.isInfoEnabled()) {
+            log.info("Result :\n" + result.getClipbordContent(true, true));
+        }
+
+        // on verifie le resultat
+        testReportResult(result);
+    }
+
+    protected void prepareVariables() {
+
+    }
+
+    protected void setVariableValue(String variableName, String id) {
+
+        for (ReportVariable variable : report.getVariables()) {
+
+            if (variableName.equals(variable.getName())) {
+
+                Object value = Iterables.find(variable.getValues(), ReferenceDtos.newIdPredicate(id));
+
+                variable.setSelectedValue(value);
+
+            }
+
+        }
+
+    }
+
+    protected abstract void testReportSyntax(Report report);
+
+    protected abstract void testReportResult(DataMatrix result);
+
+    protected static Report getReport(Log log, String reportId) throws IOException {
+        if (reports == null) {
+
+            URL reportLocation =
+                    AbstractReportServiceTopiaTest.class.getResource("/observe-reports.properties");
+
+            if (log.isInfoEnabled()) {
+                log.info("Loading reports from " + reportLocation);
+            }
+
+            ReportBuilder builder = new ReportBuilder();
+
+            reports = builder.load(reportLocation);
+
+            builder.clear();
+
+            Assert.assertNotNull(reports);
+            Assert.assertFalse(reports.isEmpty());
+        }
+
+        Report result = null;
+        // recuperation du report à tester
+        for (Report report : reports) {
+            if (reportId.equals(report.getId())) {
+                result = report;
+                break;
+            }
+        }
+
+        Assert.assertNotNull("Could not find report with id " + reportId, reports);
+        return result;
+    }
+
+    protected void assertReportName(Report report,
+                                    String name,
+                                    String description) {
+        Assert.assertEquals(getReportId(), report.getId());
+        Assert.assertEquals(name, report.getName());
+        Assert.assertEquals(description, report.getDescription());
+    }
+
+    protected void assertReportDimension(Report report,
+                                         int rows,
+                                         int columns,
+                                         String[] columnsHeader,
+                                         String[] rowsHeader) {
+        Assert.assertEquals(rows, report.getRows());
+        Assert.assertEquals(columns, report.getColumns());
+        Assert.assertArrayEquals(columnsHeader, report.getColumnHeaders());
+        Assert.assertArrayEquals(rowsHeader, report.getRowHeaders());
+    }
+
+    protected void assertReportNbRequests(Report report, int nbRequests) {
+        ReportRequest[] requests = report.getRequests();
+        Assert.assertNotNull(requests);
+        Assert.assertEquals(nbRequests, requests.length);
+    }
+
+    protected void assertReportRequestDimension(ReportRequest request,
+                                                ReportRequest.RequestLayout layout,
+                                                int x,
+                                                int y) {
+        Assert.assertEquals(layout, request.getLayout());
+//        Assert.assertEquals(new Point(width, height), request.getLocation());
+        Assert.assertEquals(x, request.getX());
+        Assert.assertEquals(y, request.getY());
+    }
+
+    protected void assertResultDimension(DataMatrix result,
+                                         int width,
+                                         int height,
+                                         int x,
+                                         int y) {
+        Assert.assertEquals(width, result.getWidth());
+        Assert.assertEquals(height, result.getHeight());
+        Assert.assertEquals(x, result.getX());
+        Assert.assertEquals(y, result.getY());
+    }
+
+    protected void assertResultRow(DataMatrix result, int rowId, Object... row) {
+        Object[] actualRow = result.getData()[rowId];
+        Assert.assertArrayEquals(row, actualRow);
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatch2Test.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatch2Test.java
new file mode 100644
index 0000000..0d821da
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatch2Test.java
@@ -0,0 +1,199 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+
+/**
+ * Test du report {@code discardedAccessoire}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportAccessoryCatch2Test extends ReportAccessoryCatchTest {
+
+    @Override
+    protected void prepareVariables() {
+        setVariableValue("speciesGroup", "fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683689#0.12092280503502995");
+    }
+
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 3, 151, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "[FAO]LUK [sc]Selene dorsalis [fr]Selene dorsalis", "-", "-");
+        assertResultRow(result, row++, "[FAO]ABU [sc]Abudefduf saxatilis  [fr]Sergent-major ", "-", "-");
+        assertResultRow(result, row++, "[FAO]ALI [sc]Alepisaurus spp [fr]Lanciers nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]ALS [sc]Carcharhinus albimarginatus [fr]Requin pointe blanche", "-", "-");
+        assertResultRow(result, row++, "[FAO]ALX [sc]Alepisaurus ferox [fr]Lancier longnez", "-", "-");
+        assertResultRow(result, row++, "[FAO]AMB [sc]Seriola dumerili [fr]Purlish amberjack", "-", "-");
+        assertResultRow(result, row++, "[FAO]AML [sc]Carcharhinus amblyrhynchos [fr]Grey reef shark", "-", "-");
+        assertResultRow(result, row++, "[FAO]DDD [sc]Abudefduf vaigiensis [fr]Sergent-major", "-", "-");
+        assertResultRow(result, row++, "[FAO]AVR [sc]Aprion virescens [fr]Job gris", "-", "-");
+        assertResultRow(result, row++, "[FAO]- [sc]Balistes capriscus [fr]Baliste (Atlantique)", "-", "-");
+        assertResultRow(result, row++, "[FAO]AJS [sc]Abalistes stellatus [fr]Baliste étoilé", "-", "+ Effectif : 20 Poids total (t) : 0.01");
+        assertResultRow(result, row++, "[FAO]TRG [sc]Balistes carolinensis [fr]Baliste cabri ", "-", "-");
+        assertResultRow(result, row++, "[FAO]BVP [sc]Balistes punctatus [fr]Baliste à taches bleues", "-", "-");
+        assertResultRow(result, row++, "[FAO]BAR [sc]Sphyraena spp [fr]Barracudas nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]ALN [sc]Aluterus scriptus [fr]Bourse écriture", "+ Effectif : 1 Poids total (t) : 0.00050", "-");
+        assertResultRow(result, row++, "[FAO]ALM [sc]Aluterus monoceros [fr]Bourse loulou", "-", "+ Effectif : 16 Poids total (t) : 0.01060");
+        assertResultRow(result, row++, "[FAO]CNT [sc]Canthidermis maculata [fr]Baliste rude", "+ Effectif : 2 Poids total (t) : 0.00134", "+ Effectif : 2230 Poids total (t) : 1.49359");
+        assertResultRow(result, row++, "[FAO]BAF [sc]Ablennes hians [fr]Orphie plate ", "-", "-");
+        assertResultRow(result, row++, "[FAO]BLR [sc]Carcharhinus melanopterus [fr]Requin pointes noires", "-", "-");
+        assertResultRow(result, row++, "[FAO]BON [sc]Sarda sarda [fr]Bonite à dos rayé", "-", "+ Effectif : 11");
+        assertResultRow(result, row++, "[FAO]BPQ [sc]Brama japonica [fr]Castagnole du Pacific", "-", "-");
+        assertResultRow(result, row++, "[FAO]BRA [sc]Brama spp. [fr]", "-", "-");
+        assertResultRow(result, row++, "[FAO]BRZ [sc]Bramidae [fr]Famille Bramidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]BRO [sc]Carcharhinus brachyurus [fr]Requin cuivre", "-", "-");
+        assertResultRow(result, row++, "[FAO]CAQ [sc]Catharacta lonnbergi [fr]Labbe brun", "-", "-");
+        assertResultRow(result, row++, "[FAO]CBG [sc]Cubiceps gracilis [fr]Libine", "-", "-");
+        assertResultRow(result, row++, "[FAO]DVH [sc]Cyclichthys orbicularis [fr]Cyclichthys orbicularis", "-", "-");
+        assertResultRow(result, row++, "[FAO]CCL [sc]Carcharhinus limbatus [fr]Requin bordé", "-", "-");
+        assertResultRow(result, row++, "[FAO]CCP [sc]Carcharhinus plumbeus [fr]Requin gris", "-", "-");
+        assertResultRow(result, row++, "[FAO]MSD [sc]Decapterus macarellus [fr]Comète maquereau ", "+ Effectif : 47 Poids total (t) : 0.0024", "+ Effectif : 6 Poids total (t) : 0.0027");
+        assertResultRow(result, row++, "[FAO]CLP [sc]Clupeidae  [fr]Famille Clupeidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]NXU [sc]Caranx lugubris [fr]Carangue noire", "-", "-");
+        assertResultRow(result, row++, "[FAO]CFW [sc]Coryphaena equiselis [fr]Coryphène dauphin", "+ Effectif : 2 Poids total (t) : 0.008", "-");
+        assertResultRow(result, row++, "[FAO]DOL [sc]Coryphaena hippurus [fr]Coryphène commun", "+ Effectif : 5 Poids total (t) : 0.03824", "+ Effectif : 107 Poids total (t) : 0.57632");
+        assertResultRow(result, row++, "[FAO]NGT [sc]Carangoides orthogrammus [fr]Carangue des îles ", "-", "-");
+        assertResultRow(result, row++, "[FAO]CXS [sc]Caranx sexfasciatus [fr]Carangue vorace ", "-", "+ Effectif : 22 Poids total (t) : 0.01100");
+        assertResultRow(result, row++, "[FAO]CRU [sc]Crustacea [fr]Crustacés nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]RUB [sc]Caranx crysos [fr]Carangue coubali", "-", "-");
+        assertResultRow(result, row++, "[FAO]3CUH [sc]Uraspis helvola [fr]Carangue coton helvola", "-", "-");
+        assertResultRow(result, row++, "[FAO]CUP [sc]Cubiceps spp [fr]Cubiceps nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]USE [sc]Uraspis secunda [fr]Carangue coton", "-", "-");
+        assertResultRow(result, row++, "[FAO]3CUX [sc]Uraspis spp [fr]Carangue coton", "-", "-");
+        assertResultRow(result, row++, "[FAO]CWZ [sc]Carcharhinus spp [fr]Requins Carcharhinus nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]CWZ [sc]Carcharhinus spp [fr]Requins Carcharhinus nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]DIY [sc]Diodon hystrix [fr]Porc-épic boubou ", "-", "-");
+        assertResultRow(result, row++, "[FAO]DIO [sc]Diodontidae [fr]Famille Diodontidae", "+ Effectif : 1 Poids total (t) : 0.00050", "-");
+        assertResultRow(result, row++, "[FAO]3DEY [sc]Diodon eydouxii [fr]Porc-épic", "-", "-");
+        assertResultRow(result, row++, "[FAO]EAG [sc]Myliobatidae [fr]Aigles de mer nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]EHN [sc]Echeneis naucrates  [fr]Rémora commun ", "+ Effectif : 7 Poids total (t) : 0.00350", "-");
+        assertResultRow(result, row++, "[FAO]RRU [sc]Elagatis bipinnulata [fr]Commère saumon", "-", "+ Effectif : 211 Poids total (t) : 0.45108");
+        assertResultRow(result, row++, "[FAO]HTL [sc]Phtheirichthys lineatus  [fr]Rémora ", "-", "-");
+        assertResultRow(result, row++, "[FAO]TRI [sc]Balistidae [fr]Famille Balistidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]BEN [sc]Belonidae [fr]Famille Belonidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]FBT [sc]Natator depressus [fr]Tortue plate", "-", "-");
+        assertResultRow(result, row++, "[FAO]DOX [sc]Coryphaenidae [fr]Famille Coryphaenidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]CGX [sc]Carangidae [fr]Famille Carangidae", "+ Effectif : 1 Poids total (t) : 0.00050", "+ Effectif : 49 Poids total (t) : 0.02450");
+        assertResultRow(result, row++, "[FAO]ECN [sc]Echeneidae [fr]Famille Echeneidae", "+ Effectif : 2 Poids total (t) : 0.00100", "-");
+        assertResultRow(result, row++, "[FAO]SPA [sc]Ephippidae [fr]Famille Ephippidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]EXQ [sc]Euleptorhamphus velox [fr]Demi-bec volant ", "-", "-");
+        assertResultRow(result, row++, "[FAO]FLY [sc]Exocoetidae [fr]Famille Exocoetidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]FIT [sc]Fistularia spp [fr]Cornettes", "-", "-");
+        assertResultRow(result, row++, "[FAO]FFX [sc]Monacanthidae [fr]Poisson-lime", "-", "-");
+        assertResultRow(result, row++, "[FAO]KYP [sc]Kyphosus spp [fr]Kyphosus calicagères nca ", "-", "-");
+        assertResultRow(result, row++, "[FAO]3MOP [sc]Molidae [fr]Famille Molidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]DSF [sc]Pomacentridae [fr]Famille Pomacentridae", "-", "-");
+        assertResultRow(result, row++, "[FAO]MAX [sc]Scombridae [fr]Famille Scombridae", "-", "-");
+        assertResultRow(result, row++, "[FAO]BSX [sc]Serranidae [fr]Famille Serranidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]PUX [sc]Tetraodontidae [fr]Famille Tetraodontidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]GEP [sc]Gempylidae [fr]Escoliers, rouvets nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]GES [sc]Gempylus serpens [fr]Escolier serpent", "-", "-");
+        assertResultRow(result, row++, "[FAO]JDP [sc]Dasyatis pastinaca [fr]Pastenague commune", "-", "-");
+        assertResultRow(result, row++, "[FAO]KYC [sc]Kyphosus cinerascens [fr]Calicagère bleue ", "-", "-");
+        assertResultRow(result, row++, "[FAO]KYS [sc]Kyphosus sectatrix [fr]Calicagère blanche ", "-", "-");
+        assertResultRow(result, row++, "[FAO]KYV [sc]Kyphosus vaigiensis [fr]Caligagère", "-", "+ Effectif : 5 Poids total (t) : 0.0025");
+        assertResultRow(result, row++, "[FAO]LAG [sc]Lampris guttatus [fr]Opah", "-", "-");
+        assertResultRow(result, row++, "[FAO]LAM [sc]Lampris spp [fr]Saumon des dieux", "-", "-");
+        assertResultRow(result, row++, "[FAO]LAP [sc]Lampris spp [fr]Opah", "-", "-");
+        assertResultRow(result, row++, "[FAO]3LDI [sc]Lactoria diaphana [fr]Lactoria diaphana", "-", "-");
+        assertResultRow(result, row++, "[FAO]LEC [sc]Lepidocybium flavobrunneum [fr]Escolier noir", "-", "-");
+        assertResultRow(result, row++, "[FAO]LGH [sc]Lagocephalus lagocephalus [fr]Compère océanique ", "-", "-");
+        assertResultRow(result, row++, "[FAO]LMA [sc]Isurus paucus [fr]Petite taupe, Mako", "-", "-");
+        assertResultRow(result, row++, "[FAO]LOB [sc]Lobotes surinamensis [fr]Croupia roche ", "-", "+ Effectif : 28 Poids total (t) : 0.06754");
+        assertResultRow(result, row++, "[FAO]LOP [sc]Lophotus capellei [fr]Roi des harengs", "-", "-");
+        assertResultRow(result, row++, "[FAO]LVM [sc]Luvarus imperialis [fr]Luvar ", "-", "-");
+        assertResultRow(result, row++, "[FAO]MRW [sc]Masturus lanceolatus [fr]Poisson-lune à queue pointue", "-", "-");
+        assertResultRow(result, row++, "[FAO]MAW [sc]Scomberomorus tritor [fr]Thazard blanc", "-", "-");
+        assertResultRow(result, row++, "[FAO]MAZ [sc]Scomber spp [fr]Maquereaux scomber nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]MOX [sc]Mola mola [fr]Poisson lune", "-", "-");
+        assertResultRow(result, row++, "[FAO]MOP [sc]Mola spp [fr]Poissons lunes nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]MZZ [sc]Osteichthyes [fr]Poissons marins nca ", "-", "-");
+        assertResultRow(result, row++, "[FAO]NAU [sc]Naucrates ductor [fr]Poisson pilote", "+ Effectif : 1 Poids total (t) : 0.00050", "-");
+        assertResultRow(result, row++, "[FAO]NEN [sc]Nesiarchus nasutus [fr]Escolier long nez", "-", "-");
+        assertResultRow(result, row++, "[FAO]NXI [sc]Caranx ignobilis [fr]Carangue têtue", "-", "-");
+        assertResultRow(result, row++, "[FAO]OMZ [sc]Ommastrephidae [fr]Encornets Ommastrephidae nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]OOT [sc]Oreosoma atlanticum  [fr]Oreosoma atlanticum ", "-", "-");
+        assertResultRow(result, row++, "[FAO]OSF [sc]Stegostoma fasciatum [fr]Requin zèbre", "-", "-");
+        assertResultRow(result, row++, "[FAO]PFM [sc]Pristipomoides filamentosus [fr]Colas fil", "-", "-");
+        assertResultRow(result, row++, "[FAO]BAT [sc]Platax spp [fr]Poules d'eau ", "-", "-");
+        assertResultRow(result, row++, "[FAO]BAO [sc]Platax teira [fr]Poule d'eau", "-", "-");
+        assertResultRow(result, row++, "[FAO]POA [sc]Brama brama [fr]Grande castagnole", "-", "-");
+        assertResultRow(result, row++, "[FAO]PRP [sc]Promethichthys prometheus [fr]Escolier clair", "-", "-");
+        assertResultRow(result, row++, "[FAO]PSC [sc]Psenes cyanophrys [fr]Psenes cyanophrys", "-", "-");
+        assertResultRow(result, row++, "[FAO]PSK [sc]Pseudocarcharias kamoharai [fr]Requin crocodile", "-", "-");
+        assertResultRow(result, row++, "[FAO]RAJ [sc]Rajidae [fr]Rajidés nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]RZV [sc]Ranzania laevis [fr]Ranzania", "-", "-");
+        assertResultRow(result, row++, "[FAO]3RAU [sc]Remora australis [fr]Rémora", "-", "-");
+        assertResultRow(result, row++, "[FAO]RDB [sc]Dasyatis benneti [fr]Bennett s stingray", "-", "-");
+        assertResultRow(result, row++, "[FAO]RDX [sc]Dasyatis ushiei [fr]Cow stingray", "-", "-");
+        assertResultRow(result, row++, "[FAO]RDZ [sc]Dasyatis zugei [fr]Pale-edged stingray", "-", "-");
+        assertResultRow(result, row++, "[FAO]RRL [sc]Remorina albescens [fr]Rémora blanche", "-", "-");
+        assertResultRow(result, row++, "[FAO]REO [sc]Remora remora [fr]Rémora", "+ Effectif : 2 Poids total (t) : 0.001", "-");
+        assertResultRow(result, row++, "[FAO]REZ [sc]Remora osteochir [fr]Rémora des marlins ", "-", "-");
+        assertResultRow(result, row++, "[FAO]REY [sc]Remora brachyptera [fr]Rémora des espadons ", "-", "-");
+        assertResultRow(result, row++, "[FAO]RMH [sc]Mobula hypostoma [fr]Mante diable", "-", "-");
+        assertResultRow(result, row++, "[FAO]OIL [sc]Ruvettus pretiosus [fr]Rouvet", "-", "-");
+        assertResultRow(result, row++, "[FAO]RXX [sc]Rexea spp. [fr]Rexea spp.", "-", "-");
+        assertResultRow(result, row++, "[FAO]SBF [sc]Thunnus maccoyii [fr]Thon rouge du Sud", "-", "-");
+        assertResultRow(result, row++, "[FAO]SDX [sc]Decapterus spp [fr]Comètes nca ", "-", "-");
+        assertResultRow(result, row++, "[FAO]YTL [sc]Seriola rivoliana [fr]Sériole limon ", "-", "-");
+        assertResultRow(result, row++, "[FAO]MAS [sc]Scomber japonicus [fr]Maquereau espagnol", "-", "-");
+        assertResultRow(result, row++, "[FAO]SKH [sc]Selachimorpha [fr]Requins divers nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]SKX [sc]Elasmobranchii [fr]Requins, raies, etc. nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]SLP [sc]Hydrurga leptonyx [fr]Léopard de mer", "-", "-");
+        assertResultRow(result, row++, "[FAO]SNK [sc]Thyrsites atun [fr]Escolier", "-", "-");
+        assertResultRow(result, row++, "[FAO]GBA [sc]Sphyraena barracuda [fr]Barracuda", "-", "+ Effectif : 26 Poids total (t) : 0.11222");
+        assertResultRow(result, row++, "[FAO]BAZ [sc]Sphyraenidae [fr]Famille Sphyraenidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]SPN [sc]Sphyrna spp [fr]Requins marteau nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]SQC [sc]Loligo spp [fr]Calmars Loligo nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]MAC [sc]Scomber scombrus [fr]Maquereau commun", "-", "-");
+        assertResultRow(result, row++, "[FAO]SXH [sc]Scombrolabrax heterolepis [fr]Escolier aile longue", "-", "-");
+        assertResultRow(result, row++, "[FAO]TAL [sc]Taractichthys longipinnis [fr]Big-scale pomfret", "-", "-");
+        assertResultRow(result, row++, "[FAO]BTS [sc]Tylosurus crocodilus [fr]Aiguille crocodile ", "-", "+ Effectif : 1 Poids total (t) : 0.00050");
+        assertResultRow(result, row++, "[FAO]TCR [sc]Taractes rubescens [fr]Keeltail pomfret", "-", "-");
+        assertResultRow(result, row++, "[FAO]THM [sc]Thyrsitoides merleyi [fr]Escolier gracile", "-", "-");
+        assertResultRow(result, row++, "[FAO]TJZ [sc]Trachipterus jacksonensis [fr]", "-", "-");
+        assertResultRow(result, row++, "[FAO]TRE [sc]Caranx spp [fr]Chinchards, carangues nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]TRQ [sc]Trachipterus trachipterus [fr]Mediterranean dealfish", "-", "-");
+        assertResultRow(result, row++, "[FAO]TRW [sc]Trachipterus ishikawae [fr]", "-", "-");
+        assertResultRow(result, row++, "[FAO]TST [sc]Taractichtys steindachneri [fr]Castagnole fauchoire", "-", "-");
+        assertResultRow(result, row++, "[FAO]TUS [sc]Thunnus spp [fr]Thons Thunnus nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]UBP [sc]Cubiceps capensis [fr]Dérivant", "-", "-");
+        assertResultRow(result, row++, "[FAO]URU [sc]Uraspis uraspis [fr]Carangue paia ", "-", "-");
+        assertResultRow(result, row++, "[FAO]VLF* [sc]Very long fish nei [fr]Très longs poissons nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]VVL* [sc]Very very long fish nei [fr]Très très longs poissons nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]WAH [sc]Acanthocybium solandri [fr]Thazard bâtard", "-", "+ Effectif : 90 Poids total (t) : 0.6800");
+        assertResultRow(result, row++, "[FAO]WHH [sc]Tetrapturus spp [fr]Makaires Tetrapturus nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]9XXX [sc]Indéterminé [fr]Indéterminé", "-", "-");
+        assertResultRow(result, row++, "[FAO]XXX* [sc] [fr]", "-", "-");
+        assertResultRow(result, row++, "[FAO]YMO [sc]Sthenoteuthis oualaniensis [fr]Encornet bande violette", "-", "-");
+        assertResultRow(result, row++, "[FAO]YTC [sc]Seriola lalandi [fr]Sériole chicard", "-", "-");
+        assertResultRow(result, row++, "[FAO]ZAO [sc]Zanclus cornutus [fr]Zanclus cornutus", "-", "-");
+    }
+
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroup2Test.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroup2Test.java
new file mode 100644
index 0000000..09c5776
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroup2Test.java
@@ -0,0 +1,68 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+
+/**
+ * Pour tester le report {@code discardedAccessoireByGroup}
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportAccessoryCatchByGroup2Test extends ReportAccessoryCatchByGroupTest {
+
+    @Override
+    protected void prepareVariables() {
+        setVariableValue("speciesGroup", "fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683689#0.12092280503502995");
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 11, 21, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "[FAO]AJS [sc]Abalistes stellatus [fr]Baliste étoilé", "0", "20", "0", "0", "0", "20", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]ALN [sc]Aluterus scriptus [fr]Bourse écriture", "1", "0", "0", "0", "0", "1", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]ALM [sc]Aluterus monoceros [fr]Bourse loulou", "0", "16", "0", "0", "2", "14", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]CNT [sc]Canthidermis maculata [fr]Baliste rude", "2", "2230", "0", "0", "185", "1981", "0", "0", "66", "0.0");
+        assertResultRow(result, row++, "[FAO]BON [sc]Sarda sarda [fr]Bonite à dos rayé", "0", "11", "0", "0", "0", "11", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]MSD [sc]Decapterus macarellus [fr]Comète maquereau ", "47", "6", "0", "0", "0", "6", "0", "0", "47", "0.0");
+        assertResultRow(result, row++, "[FAO]CFW [sc]Coryphaena equiselis [fr]Coryphène dauphin", "2", "0", "0", "0", "0", "2", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]DOL [sc]Coryphaena hippurus [fr]Coryphène commun", "5", "107", "0", "0", "1", "59", "0", "37", "15", "0.0");
+        assertResultRow(result, row++, "[FAO]CXS [sc]Caranx sexfasciatus [fr]Carangue vorace ", "0", "22", "0", "0", "1", "18", "0", "0", "3", "0.0");
+        assertResultRow(result, row++, "[FAO]DIO [sc]Diodontidae [fr]Famille Diodontidae", "1", "0", "0", "0", "1", "0", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]EHN [sc]Echeneis naucrates  [fr]Rémora commun ", "7", "0", "0", "0", "6", "1", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]RRU [sc]Elagatis bipinnulata [fr]Commère saumon", "0", "211", "0", "0", "25", "177", "0", "0", "9", "0.0");
+        assertResultRow(result, row++, "[FAO]CGX [sc]Carangidae [fr]Famille Carangidae", "1", "49", "0", "0", "7", "43", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]ECN [sc]Echeneidae [fr]Famille Echeneidae", "2", "0", "0", "0", "2", "0", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]KYV [sc]Kyphosus vaigiensis [fr]Caligagère", "0", "5", "0", "0", "0", "5", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]LOB [sc]Lobotes surinamensis [fr]Croupia roche ", "0", "28", "0", "0", "1", "26", "0", "0", "1", "0.0");
+        assertResultRow(result, row++, "[FAO]NAU [sc]Naucrates ductor [fr]Poisson pilote", "1", "0", "0", "0", "1", "0", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]REO [sc]Remora remora [fr]Rémora", "2", "0", "0", "0", "2", "0", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]GBA [sc]Sphyraena barracuda [fr]Barracuda", "0", "26", "0", "0", "3", "23", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]BTS [sc]Tylosurus crocodilus [fr]Aiguille crocodile ", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]WAH [sc]Acanthocybium solandri [fr]Thazard bâtard", "0", "90", "0", "0", "3", "85", "0", "0", "2", "0.0");
+
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroupTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroupTest.java
new file mode 100644
index 0000000..21fa2c1
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchByGroupTest.java
@@ -0,0 +1,100 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+import fr.ird.observe.services.service.actions.report.AbstractReportServiceTopiaTest;
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+/**
+ * Pour tester le report {@code discardedAccessoireByGroup}
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportAccessoryCatchByGroupTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Dénombrement des captures accessoires et devenir, filtrés par groupe",
+                "Afficher les nombres de captures accessoires par groupe d'espèce selon le type de banc et le devenir"
+        );
+
+        assertReportDimension(
+                report,
+                -1,
+                11,
+                new String[]{"Espèce",
+                             "Total BL",
+                             "Total BO",
+                             "Sorti vivant/échappé",
+                             "Sorti mort",
+                             "Rejeté vivant",
+                             "Rejeté mort",
+                             "Partiellement conservé",
+                             "Cuve",
+                             "Cuisine",
+                             "Autre"
+                },
+                null
+        );
+
+        assertReportNbRequests(report, 1);
+
+        ReportRequest[] requests = report.getRequests();
+
+        assertReportRequestDimension(
+                requests[0],
+                ReportRequest.RequestLayout.row,
+                0,
+                0
+        );
+    }
+
+    @Override
+    protected String getReportId() {
+        return "accessoryCatchByGroup";
+    }
+
+    @Override
+    protected void prepareVariables() {
+        setVariableValue("speciesGroup", "fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683689#0.7120116158620075");
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 11, 6, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "[FAO]FAL [sc]Carcharhinus falciformis [fr]Requin soyeux", "0", "17", "0", "0", "10", "7", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]OCS [sc]Carcharhinus longimanus [fr]Requin océanique", "1", "0", "0", "0", "1", "0", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]RSK [sc]Carcharhinidae spp [fr]Famille Carcharhinidae", "0", "11", "0", "0", "5", "6", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]STT [sc]Dasyatidae [fr]Famille Dasyatidae", "7", "0", "0", "0", "6", "0", "0", "0", "0", "1.0");
+        assertResultRow(result, row++, "[FAO]SPY [sc]Sphyrnidae [fr]Famille Sphyrnidae", "0", "1", "0", "0", "1", "0", "0", "0", "0", "0.0");
+        assertResultRow(result, row++, "[FAO]RMB [sc]Manta birostris [fr]Mante atlantique", "9", "0", "0", "0", "9", "0", "0", "0", "0", "0.0");
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchTest.java
new file mode 100644
index 0000000..dbfe11c
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAccessoryCatchTest.java
@@ -0,0 +1,156 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+
+import fr.ird.observe.services.service.actions.report.AbstractReportServiceTopiaTest;
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+/**
+ * Test du report {@code accessoryCatch}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportAccessoryCatchTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Liste des captures accessoires selon le type de banc, filtrées par groupe",
+                "Afficher les captures accessoires par groupe d'espèce\n" +
+                "Les poids sont exprimés en tonnes."
+        );
+
+        assertReportDimension(
+                report,
+                -1,
+                3,
+                new String[]{"Espèce",
+                             "Banc libre",
+                             "Banc objet",
+                },
+                null
+        );
+
+        assertReportNbRequests(report, 3);
+
+        ReportRequest[] requests = report.getRequests();
+
+        assertReportRequestDimension(
+                requests[0],
+                ReportRequest.RequestLayout.row,
+                0,
+                0
+        );
+        assertReportRequestDimension(
+                requests[1],
+                ReportRequest.RequestLayout.row,
+                1,
+                0
+        );
+        assertReportRequestDimension(
+                requests[2],
+                ReportRequest.RequestLayout.row,
+                2,
+                0
+        );
+    }
+
+    @Override
+    protected String getReportId() {
+        return "accessoryCatch";
+    }
+
+    @Override
+    protected void prepareVariables() {
+        setVariableValue("speciesGroup", "fr.ird.observe.entities.referentiel.SpeciesGroup#1239832683689#0.7120116158620075");
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 3, 54, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "[FAO]MAE [sc]Aetobatus narinari [fr]Aigle de mer léopard", "-", "-");
+        assertResultRow(result, row++, "[FAO]PTH [sc]Alopias pelagicus [fr]Renard pélagique", "-", "-");
+        assertResultRow(result, row++, "[FAO]BTH [sc]Alopias superciliosus [fr]Renard à gros yeux", "-", "-");
+        assertResultRow(result, row++, "[FAO]ALV [sc]Alopias vulpinus [fr]Renard", "-", "-");
+        assertResultRow(result, row++, "[FAO]WSH [sc]Carcharodon carcharias [fr]Grand requin blanc", "-", "-");
+        assertResultRow(result, row++, "[FAO]CCE [sc]Carcharhinus leucas [fr]Requin-bouledogue", "-", "-");
+        assertResultRow(result, row++, "[FAO]FAL [sc]Carcharhinus falciformis [fr]Requin soyeux", "-", "+ Effectif : 17 Poids total (t) : 0.1753");
+        assertResultRow(result, row++, "[FAO]OCS [sc]Carcharhinus longimanus [fr]Requin océanique", "+ Effectif : 1 Poids total (t) : 0.0447", "-");
+        assertResultRow(result, row++, "[FAO]DUS [sc]Carcharhinus obscurus [fr]Requin sombre", "-", "-");
+        assertResultRow(result, row++, "[FAO]PLS [sc]Dasyatys (Pteroplatytrygon) violacea [fr]Pastenague violette", "-", "-");
+        assertResultRow(result, row++, "[FAO]SHL [sc]Etmopterus spp [fr]Genre Etmopterus", "-", "-");
+        assertResultRow(result, row++, "[FAO]THR [sc]Alopias spp [fr]Renards de mer nca ", "-", "-");
+        assertResultRow(result, row++, "[FAO]RSK [sc]Carcharhinidae spp [fr]Famille Carcharhinidae", "-", "+ Effectif : 11 Poids total (t) : 0.55");
+        assertResultRow(result, row++, "[FAO]STT [sc]Dasyatidae [fr]Famille Dasyatidae", "+ Effectif : 7 Poids total (t) : 0.015", "-");
+        assertResultRow(result, row++, "[FAO]MSK [sc]Lamnidae [fr]Famille Lamnidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]2FOD [sc]Odontaspididae [fr]Odontaspididae", "-", "-");
+        assertResultRow(result, row++, "[FAO]- [sc]Rhincodontidae [fr]Famille Rhincodontidae", "-", "-");
+        assertResultRow(result, row++, "[FAO]SPY [sc]Sphyrnidae [fr]Famille Sphyrnidae", "-", "+ Effectif : 1");
+        assertResultRow(result, row++, "[FAO]TIG [sc]Galeocerdo cuvier [fr]Requin tigre commun", "-", "-");
+        assertResultRow(result, row++, "[FAO]ISB [sc]Isistius brasiliensis [fr]Squalelet féroce", "-", "-");
+        assertResultRow(result, row++, "[FAO]SMA [sc]Isurus oxyrinchus [fr]Taupe bleu", "-", "-");
+        assertResultRow(result, row++, "[FAO]MAK [sc]Isurus spp [fr]Taupes", "-", "-");
+        assertResultRow(result, row++, "[FAO]MAN [sc]Mobulidae  [fr]Mantes, diables de mer nca ", "-", "-");
+        assertResultRow(result, row++, "[FAO]MYL [sc]Myliobatis aquila [fr]Aigle commun", "-", "-");
+        assertResultRow(result, row++, "[FAO]RMB [sc]Manta birostris [fr]Mante atlantique", "+ Effectif : 9 Poids total (t) : 1.1824", "-");
+        assertResultRow(result, row++, "[FAO]RMT [sc]Mobula tarapacana [fr]Diable géant de Guinée", "-", "-");
+        assertResultRow(result, row++, "[FAO]MNT [sc]Manta spp [fr]Raies manta", "-", "-");
+        assertResultRow(result, row++, "[FAO]RMM [sc]Mobula mobular [fr]Mante mobula", "-", "-");
+        assertResultRow(result, row++, "[FAO]LMP [sc]Megachasma pelagios [fr]Requin grande gueule", "-", "-");
+        assertResultRow(result, row++, "[FAO]RMJ [sc]Mobula japanica [fr]Mante aiguillat", "-", "-");
+        assertResultRow(result, row++, "[FAO]CVX [sc]Carcharhiniformes [fr]Ordre Carcharhiniformes", "-", "-");
+        assertResultRow(result, row++, "[FAO]HDQ [sc]Heterodontiformes [fr]Ordre Heterodontiformes", "-", "-");
+        assertResultRow(result, row++, "[FAO]HXW [sc]Hexanchiformes [fr]Ordre Hexanchiformes", "-", "-");
+        assertResultRow(result, row++, "[FAO]LMZ [sc]Lamniformes [fr]Ordre Lamniformes", "-", "-");
+        assertResultRow(result, row++, "[FAO]OCX [sc]Orectolobiformes [fr]Ordre Orectolobiformes", "-", "-");
+        assertResultRow(result, row++, "[FAO]PWS [sc]Pristiophorus spp [fr]Requins-scies nca ", "-", "-");
+        assertResultRow(result, row++, "[FAO]SHX [sc]Squaliformes [fr]Ordre Squaliformes", "-", "-");
+        assertResultRow(result, row++, "[FAO]ASK [sc]Squatinidae [fr]Anges de mer nca ", "-", "-");
+        assertResultRow(result, row++, "[FAO]BSH [sc]Prionace glauca [fr]Peau bleue", "-", "-");
+        assertResultRow(result, row++, "[FAO]POR [sc]Lamna nasus [fr]Requin taupe commun", "-", "-");
+        assertResultRow(result, row++, "[FAO]SRX [sc]Raie non identifiée [fr]Raie non identifiée", "-", "-");
+        assertResultRow(result, row++, "[FAO]2REX [sc]Requin non identifié [fr]Requin non identifié", "-", "-");
+        assertResultRow(result, row++, "[FAO]- [sc]Rhinopteridae [fr]Famille Rhinopteridae", "-", "-");
+        assertResultRow(result, row++, "[FAO]NZX [sc]Rhinoptera spp [fr]Mourines", "-", "-");
+        assertResultRow(result, row++, "[FAO]RMA [sc]Manta alfredi [fr]Manta Alfredi", "-", "-");
+        assertResultRow(result, row++, "[FAO]RMC [sc]Mobula coilloti  [fr]Mobula coilloti ", "-", "-");
+        assertResultRow(result, row++, "[FAO]RMO [sc]Mobula thurstoni [fr]Mobula", "-", "-");
+        assertResultRow(result, row++, "[FAO]RMV [sc]Mobula spp [fr]Mobula nca", "-", "-");
+        assertResultRow(result, row++, "[FAO]BSK [sc]Cetorhinus maximus [fr]Requin pèlerin", "-", "-");
+        assertResultRow(result, row++, "[FAO]RHN [sc]Rhincodon typus [fr]Requin baleine", "-", "-");
+        assertResultRow(result, row++, "[FAO]SPL [sc]Sphyrna lewini [fr]Requin marteau halicorne", "-", "-");
+        assertResultRow(result, row++, "[FAO]SPK [sc]Sphyrna mokarran [fr]Grand requin marteau", "-", "-");
+        assertResultRow(result, row++, "[FAO]SPZ [sc]Sphyrna zygaena [fr]Requin marteau commun", "-", "-");
+        assertResultRow(result, row++, "[FAO]TOD [sc]Torpedinidae [fr]Torpilles, raies électriq. nca ", "-", "-");
+
+
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportActivityWithCommentTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportActivityWithCommentTest.java
new file mode 100644
index 0000000..39e6e80
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportActivityWithCommentTest.java
@@ -0,0 +1,348 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+
+/**
+ * Pour tester le report {@code dailySetAndCapture}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportActivityWithCommentTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected String getReportId() {
+        return "activityWithComment";
+    }
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Activités avec comment et leurs positions",
+                "Afficher les activités avec comment et leurs positions géographiques"
+        );
+
+        assertReportDimension(
+                report,
+                -1,
+                5,
+                new String[]{"Jour - Heure observation",
+                             "Latitude",
+                             "Longitude",
+                             "Activité",
+                             "Commentaire"
+                },
+                null
+        );
+
+        assertReportNbRequests(report, 1);
+
+        ReportRequest[] requests = report.getRequests();
+
+        assertReportRequestDimension(
+                requests[0],
+                ReportRequest.RequestLayout.row,
+                0,
+                0
+        );
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 5, 265, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "25/1/2013 19:0", "-19.833473", "57.466805", "Fin de veille", "Pas de fin de veille, toujours en transit 01.");
+        assertResultRow(result, row++, "26/1/2013 10:25", "-16.35014", "57.616802", "Transit (route sans recherche)", "");
+        assertResultRow(result, row++, "26/1/2013 11:24", "-16.083473", "57.800137", "Transit (route sans recherche)", "");
+        assertResultRow(result, row++, "26/1/2013 19:0", "-14.233473", "58.066803", "Autres (à préciser dans les notes)", "Fin de journée toujours en transit.");
+        assertResultRow(result, row++, "27/1/2013 7:20", "-11.0", "58.716805", "Route vers des systèmes observés", "Listao trop rapide.");
+        assertResultRow(result, row++, "27/1/2013 9:24", "-10.616806", "58.766804", "Route vers des systèmes observés", "Listao trop rapide et petit banc");
+        assertResultRow(result, row++, "27/1/2013 15:12", "-9.60014", "58.700138", "Recherche (général)", "albacore de 3 à 4 kg poissons dispersés et trop petits");
+        assertResultRow(result, row++, "28/1/2013 6:0", "-9.250139", "56.800137", "Recherche (général)", "Transit la nuit, arrété prés d'une épave mais au petit matin pas de poisson donc nous sommes reparti directement sans toucher à l'épave.");
+        assertResultRow(result, row++, "28/1/2013 11:51", "-8.450139", "56.716805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "28/1/2013 16:52", "-7.8501387", "57.53347", "Recherche (général)", "Rencontre d'un thonier espagnol visible à l'oeil nu.");
+        assertResultRow(result, row++, "29/1/2013 7:0", "-7.883472", "58.166805", "Recherche (général)", "au moins 5 thoniers visibles au radar (français et espagnols)");
+        assertResultRow(result, row++, "29/1/2013 10:5", "-7.7334723", "58.566803", "Route vers des systèmes observés", "marsouins et oiseaux.");
+        assertResultRow(result, row++, "29/1/2013 11:5", "-7.650139", "58.633472", "Route vers des systèmes observés", "Pas de calée car plus de marsouins que de thons.\nSuivi d'un nouveaux système: oiseaux à 3.0 milles");
+        assertResultRow(result, row++, "29/1/2013 12:5", "-7.650139", "58.800137", "Recherche (général)", "oiseaux mais pas de thons");
+        assertResultRow(result, row++, "29/1/2013 17:36", "-7.800139", "58.516804", "Thonier arrivant sur le système détecté", "retour au radeau posé le matin meme");
+        assertResultRow(result, row++, "30/1/2013 5:58", "-6.8334723", "57.966805", "Recherche (général)", "Présence de 7 autres navires thoniers français (CFTO) et espagnols");
+        assertResultRow(result, row++, "30/1/2013 6:27", "-6.766805", "57.90014", "Thonier arrivant sur le système détecté", "Présence de marsouin, impossible de tourner la senne");
+        assertResultRow(result, row++, "30/1/2013 7:16", "-6.783472", "57.716805", "Recherche (général)", "");
+        assertResultRow(result, row++, "30/1/2013 9:58", "-6.766805", "57.73347", "Route vers des systèmes observés", "Présence de marsouins, impossible de tourner la senne.");
+        assertResultRow(result, row++, "30/1/2013 10:8", "-6.800139", "57.716805", "Recherche (général)", "");
+        assertResultRow(result, row++, "30/1/2013 12:33", "-6.483472", "58.200138", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "30/1/2013 12:50", "-6.4668055", "58.200138", "Début de pêche (larguage du skiff)", "Aucunes espèces accessoires, aucuns rejets de thon lors du shiftage le 31.01.2013 sauf erreur de ma part deux listao de 67 et 71 cm!");
+        assertResultRow(result, row++, "31/1/2013 6:6", "-7.766805", "58.450138", "Recherche (général)", "");
+        assertResultRow(result, row++, "31/1/2013 7:57", "-7.533472", "58.65014", "Recherche (général)", "");
+        assertResultRow(result, row++, "31/1/2013 9:28", "-7.4168053", "58.866802", "Route vers des systèmes observés", "présence de marsouins");
+        assertResultRow(result, row++, "31/1/2013 9:59", "-7.3668056", "58.966805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "31/1/2013 10:53", "-7.3168054", "59.100136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "31/1/2013 12:23", "-7.2501388", "58.90014", "Route vers des systèmes observés", "couple de frégattes");
+        assertResultRow(result, row++, "31/1/2013 13:0", "-7.2668056", "58.816803", "Recherche (général)", "");
+        assertResultRow(result, row++, "31/1/2013 15:15", "-7.2668056", "58.316803", "Recherche (général)", "Shiftage du 30.01.2013 réalisé à 14h. Observation de marsouins dont non calée lors du shiftage.");
+        assertResultRow(result, row++, "31/1/2013 17:59", "-7.3668056", "57.766804", "Route vers des systèmes observés", "frégattes\nNon coup de senne : changement de câble de la senne.");
+        assertResultRow(result, row++, "31/1/2013 18:25", "-7.283472", "57.73347", "Recherche (général)", "");
+        assertResultRow(result, row++, "1/2/2013 14:54", "-6.5668054", "57.53347", "Recherche (général)", "");
+        assertResultRow(result, row++, "1/2/2013 15:52", "-6.4501386", "57.53347", "Recherche (général)", "");
+        assertResultRow(result, row++, "2/2/2013 5:54", "-6.433472", "57.68347", "Recherche (général)", "7 thoniers autour de nous visibles au radar et à l'oeil nu");
+        assertResultRow(result, row++, "2/2/2013 6:47", "-6.4501386", "57.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 8:5", "-6.400139", "57.550137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 8:26", "-6.433472", "57.53347", "Recherche (général)", "Rencontre avec le DOLOMIEUX, flotte SAPMER, pour récupérer les balises du BERNICA récupérées à MAHE aux Seychelles.");
+        assertResultRow(result, row++, "2/2/2013 11:50", "-6.516805", "57.550137", "Fin de pêche (remontée du skiff)", "Coup nul, filet déchiré et emmélé.");
+        assertResultRow(result, row++, "2/2/2013 12:48", "-6.433472", "57.58347", "Recherche (général)", "");
+        assertResultRow(result, row++, "2/2/2013 13:36", "-6.4168053", "57.750137", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "2/2/2013 13:41", "-6.433472", "57.766804", "Thonier arrivant sur le système détecté", "Présence marsouin");
+        assertResultRow(result, row++, "2/2/2013 14:50", "-6.483472", "57.98347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 15:20", "-6.533472", "58.08347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 15:48", "-6.550139", "58.116802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 16:53", "-6.433472", "58.28347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 18:10", "-6.5001388", "58.166805", "Thonier arrivant sur le système détecté", "perte du système");
+        assertResultRow(result, row++, "2/2/2013 18:20", "-6.483472", "58.15014", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 18:50", "-6.5668054", "58.08347", "Fin de veille", "3 bateaux dans la zone. On reste sur zone jusqu'à demain car présence de \"nourriture\" aux sonars");
+        assertResultRow(result, row++, "3/2/2013 6:1", "-6.533472", "58.100136", "Recherche (général)", "un autre thonier dans la zone visible au radar.");
+        assertResultRow(result, row++, "3/2/2013 6:59", "-6.633472", "58.100136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 8:18", "-6.4501386", "58.15014", "Thonier arrivant sur le système détecté", "Haut fond à 292 m, risque de perdre le filet si coup de senne");
+        assertResultRow(result, row++, "3/2/2013 11:22", "-6.516805", "58.15014", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 11:33", "-6.550139", "58.166805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 11:43", "-6.550139", "58.166805", "Recherche (général)", "");
+        assertResultRow(result, row++, "3/2/2013 12:44", "-6.6168056", "58.300137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 13:22", "-6.6001387", "58.383472", "Route vers des systèmes observés", "Tâche au sonar, ne savent pas ce que c'est!");
+        assertResultRow(result, row++, "3/2/2013 13:24", "-6.6001387", "58.383472", "Route vers des systèmes observés", "Balbaya visible à l'oeil nu. Autre système que celui observé à 13h22.");
+        assertResultRow(result, row++, "3/2/2013 13:37", "-6.6168056", "58.383472", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 13:40", "-6.6168056", "58.40014", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 16:32", "-6.7501388", "58.28347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 17:20", "-6.800139", "58.28347", "Route vers des systèmes observés", "Présence de marsouins donc non calée.");
+        assertResultRow(result, row++, "3/2/2013 17:53", "-6.8668056", "58.216805", "Thonier arrivant sur le système détecté", "Balise appartenant au Glénan, bateau de la SAPMER");
+        assertResultRow(result, row++, "3/2/2013 18:1", "-6.883472", "58.18347", "Route vers des systèmes observés", "Banc de listao. Présence d'un palangrier et de thoniers au radar et à l'oeil nu.");
+        assertResultRow(result, row++, "3/2/2013 18:15", "-6.883472", "58.18347", "Thonier arrivant sur le système détecté", "Banc de listao, Albacore recherché!");
+        assertResultRow(result, row++, "4/2/2013 5:49", "-6.7334723", "58.166805", "Recherche (général)", "2 thoniers visibles au radar.");
+        assertResultRow(result, row++, "4/2/2013 7:48", "-6.5834723", "58.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 8:0", "-6.5834723", "58.0", "Récupération d'une épave n'appartenant pas au bateau", "");
+        assertResultRow(result, row++, "4/2/2013 8:31", "-6.533472", "58.066803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 9:52", "-6.433472", "58.23347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 10:17", "-6.4501386", "58.28347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 12:32", "-6.550139", "57.966805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 12:50", "-6.5668054", "57.90014", "Thonier arrivant sur le système détecté", "Il ya des thons albacores partout tout autour du navire. Ils sautent, vont dans tous les sens le banc est énorme mais dispersé et il ne garde pas le même cap!");
+        assertResultRow(result, row++, "4/2/2013 13:50", "-6.5834723", "57.816803", "Thonier arrivant sur le système détecté", "Même banc que précédemment! dispersé et trop rapide.");
+        assertResultRow(result, row++, "4/2/2013 14:17", "-6.650139", "57.816803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 14:20", "-6.650139", "57.816803", "Route vers des systèmes observés", "Même banc qu'à 12h50 ENORME!");
+        assertResultRow(result, row++, "4/2/2013 15:36", "-6.533472", "57.766804", "Thonier arrivant sur le système détecté", "Poissons dispersés et trop rapide. Ne gardent pas le même cap, sautent dans tous les sens!");
+        assertResultRow(result, row++, "4/2/2013 16:24", "-6.483472", "57.750137", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "4/2/2013 16:31", "-6.5001388", "57.766804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 16:39", "-6.483472", "57.766804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 16:59", "-6.4501386", "57.750137", "Thonier arrivant sur le système détecté", "Présence de globicéphales.");
+        assertResultRow(result, row++, "4/2/2013 17:12", "-6.4668055", "57.800137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 17:36", "-6.433472", "57.850136", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "4/2/2013 19:43", "-6.433472", "57.916805", "Fin de pêche (remontée du skiff)", "Coup Nul.");
+        assertResultRow(result, row++, "5/2/2013 5:43", "-6.4501386", "58.18347", "Thonier arrivant sur le système détecté", "Route de nuit vers le DCP mis la veille.");
+        assertResultRow(result, row++, "5/2/2013 9:29", "-6.6001387", "58.016804", "Thonier arrivant sur le système détecté", "Présence de marsouins");
+        assertResultRow(result, row++, "5/2/2013 10:30", "-6.683472", "57.83347", "Thonier arrivant sur le système détecté", "Présence de Marsouins!");
+        assertResultRow(result, row++, "5/2/2013 11:13", "-6.800139", "57.750137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "5/2/2013 16:17", "-7.9501386", "57.516804", "Route vers des systèmes observés", "Listao");
+        assertResultRow(result, row++, "5/2/2013 16:28", "-8.0", "57.516804", "Thonier arrivant sur le système détecté", "Listao");
+        assertResultRow(result, row++, "5/2/2013 17:42", "-8.316806", "57.43347", "Recherche (général)", "Marsouins observé mais nous les avons laissé au loin sur tribord sans prendre leur direction");
+        assertResultRow(result, row++, "6/2/2013 6:31", "-11.766806", "56.53347", "Route vers des systèmes observés", "Banc de listao");
+        assertResultRow(result, row++, "6/2/2013 6:37", "-11.800139", "56.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 7:34", "-12.016806", "56.550137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 7:47", "-12.016806", "56.550137", "Recherche (général)", "Shiftage de la calée du 05.02.13 réalisée à 8H");
+        assertResultRow(result, row++, "6/2/2013 8:51", "-12.233473", "56.200138", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 9:41", "-12.366806", "56.200138", "Route vers des systèmes observés", "Zone avec pleins de petits balbaya. 3 thoniers français sur zone.");
+        assertResultRow(result, row++, "6/2/2013 9:43", "-12.366806", "56.18347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 12:49", "-12.416806", "56.050137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 13:26", "-12.416806", "56.133472", "Route vers des systèmes observés", "Pleins de petits banc d'YFT et de SKJ");
+        assertResultRow(result, row++, "6/2/2013 14:20", "-12.450139", "56.0", "Thonier arrivant sur le système détecté", "listao + baleine");
+        assertResultRow(result, row++, "6/2/2013 14:30", "-12.450139", "56.050137", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "6/2/2013 15:51", "-12.366806", "56.03347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 16:22", "-12.400139", "56.03347", "Route vers des systèmes observés", "une dizaine de poisson (petit banc).");
+        assertResultRow(result, row++, "6/2/2013 16:25", "-12.400139", "56.016804", "Thonier arrivant sur le système détecté", "Plusieurs bancs, dont un plus interessant.");
+        assertResultRow(result, row++, "7/2/2013 6:6", "-12.183473", "56.116802", "Route vers des systèmes observés", "Présence de marsouins, nous continuons notre route.");
+        assertResultRow(result, row++, "7/2/2013 6:34", "-12.200139", "56.133472", "Thonier arrivant sur le système détecté", "Banc de listao");
+        assertResultRow(result, row++, "7/2/2013 7:9", "-12.266806", "56.133472", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 7:13", "-12.266806", "56.18347", "Route vers des systèmes observés", "Listao + baleines");
+        assertResultRow(result, row++, "7/2/2013 7:25", "-12.300139", "56.216805", "Thonier arrivant sur le système détecté", "Listao + 3 baleines");
+        assertResultRow(result, row++, "7/2/2013 7:32", "-12.333472", "56.200138", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "7/2/2013 8:11", "-12.383472", "56.050137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 11:46", "-12.383472", "55.98347", "Route vers des systèmes observés", "Nombre impressionnant de thons! gros balbaya!");
+        assertResultRow(result, row++, "7/2/2013 12:47", "-12.416806", "56.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 13:8", "-12.35014", "56.03347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 16:43", "-12.266806", "55.966805", "Route vers des systèmes observés", "Banc de Listao");
+        assertResultRow(result, row++, "7/2/2013 16:45", "-12.283473", "55.950138", "Thonier arrivant sur le système détecté", "Banc de listao trop rapide, banc de gros albacore visé!");
+        assertResultRow(result, row++, "7/2/2013 16:52", "-12.283473", "55.98347", "Route vers des systèmes observés", "Banc de listao vu directement aux jumelles nous continuons donc notre route!");
+        assertResultRow(result, row++, "7/2/2013 17:39", "-12.250139", "55.98347", "Route vers des systèmes observés", "Listao + baleine");
+        assertResultRow(result, row++, "7/2/2013 18:1", "-12.283473", "55.916805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 6:58", "-12.333472", "55.93347", "Route vers des systèmes observés", "Pleins de \"petits bouillons\" partout tout autour de nous, petits bancs rapides!");
+        assertResultRow(result, row++, "8/2/2013 7:17", "-12.316806", "55.950138", "Thonier arrivant sur le système détecté", "Banc de listao + marsouins+ oiseaux");
+        assertResultRow(result, row++, "8/2/2013 7:29", "-12.283473", "56.0", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 7:50", "-12.216805", "56.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 8:2", "-12.250139", "56.03347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 8:4", "-12.250139", "56.03347", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "8/2/2013 8:21", "-12.200139", "56.100136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 8:27", "-12.200139", "56.116802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 9:15", "-12.250139", "56.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 12:30", "-12.183473", "56.066803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 12:59", "-12.183473", "56.116802", "Thonier arrivant sur le système détecté", "listao + albacore trop petits");
+        assertResultRow(result, row++, "9/2/2013 6:35", "-12.166806", "56.100136", "Route vers des systèmes observés", "Banc de listao, pas interessant, nous continuons notre route sans s'arrêter!");
+        assertResultRow(result, row++, "9/2/2013 6:53", "-12.133472", "56.15014", "Thonier arrivant sur le système détecté", "Présence de \"marsouins\" et banc trop petit");
+        assertResultRow(result, row++, "9/2/2013 7:12", "-12.150139", "56.116802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "9/2/2013 7:59", "-12.266806", "56.03347", "Thonier arrivant sur le système détecté", "Banc de listao");
+        assertResultRow(result, row++, "9/2/2013 8:24", "-12.366806", "56.050137", "Thonier arrivant sur le système détecté", "Pleins de petits bancs partout");
+        assertResultRow(result, row++, "9/2/2013 11:12", "-12.35014", "56.03347", "Thonier arrivant sur le système détecté", "Listao trop rapide et pas interessant pour le capitaine.");
+        assertResultRow(result, row++, "9/2/2013 11:31", "-12.316806", "56.03347", "Thonier arrivant sur le système détecté", "Listao + baleine");
+        assertResultRow(result, row++, "9/2/2013 11:32", "-12.316806", "56.050137", "Route vers des systèmes observés", "pleins de petits \"bouts\" partout");
+        assertResultRow(result, row++, "9/2/2013 15:15", "-12.283473", "55.966805", "Thonier arrivant sur le système détecté", "Shiftage de 14h à 15h.");
+        assertResultRow(result, row++, "9/2/2013 15:48", "-12.316806", "56.050137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "10/2/2013 5:55", "-12.316806", "55.916805", "Thonier arrivant sur le système détecté", "épave balisée la veille.");
+        assertResultRow(result, row++, "10/2/2013 7:58", "-12.316806", "55.916805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "10/2/2013 11:21", "-12.450139", "55.850136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "10/2/2013 12:6", "-12.400139", "55.816803", "Route vers des systèmes observés", "Banc de Listao.");
+        assertResultRow(result, row++, "10/2/2013 12:16", "-12.383472", "55.850136", "Thonier arrivant sur le système détecté", "Banc de Listao");
+        assertResultRow(result, row++, "10/2/2013 14:17", "-12.033473", "55.600136", "Recherche (général)", "Shiftage de 14h à 16h06!");
+        assertResultRow(result, row++, "10/2/2013 19:4", "-12.216805", "55.48347", "Fin de veille", "");
+        assertResultRow(result, row++, "11/2/2013 6:56", "-12.433473", "55.48347", "Route vers des systèmes observés", "Poissons \"étalés\"");
+        assertResultRow(result, row++, "11/2/2013 7:17", "-12.466805", "55.53347", "Thonier arrivant sur le système détecté", "Nous sommes 5 sur la zone avec notamment le Glénan (CFTO), le Dolomieu (SAPMER) et Franche-Terre (SAPMER)");
+        assertResultRow(result, row++, "11/2/2013 11:23", "-12.433473", "55.516804", "Début de pêche (larguage du skiff)", "Shiftage du 10.02.2013 de 11h10 à 11h30");
+        assertResultRow(result, row++, "11/2/2013 14:8", "-12.416806", "55.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "11/2/2013 14:33", "-12.366806", "55.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "12/2/2013 5:50", "-12.516806", "55.450138", "Recherche (général)", "Nous sommes à côté d'un épave.");
+        assertResultRow(result, row++, "12/2/2013 6:47", "-12.366806", "55.53347", "Thonier arrivant sur le système détecté", "Poissons étalés, Mélange Listao et Albacore");
+        assertResultRow(result, row++, "12/2/2013 6:59", "-12.35014", "55.550137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "12/2/2013 7:20", "-12.333472", "55.566803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "12/2/2013 9:36", "-12.300139", "55.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "12/2/2013 15:0", "-11.300139", "55.600136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 5:52", "-9.016806", "55.250137", "Thonier arrivant sur le système détecté", "Route de nuit vers ce radeau.");
+        assertResultRow(result, row++, "13/2/2013 7:0", "-8.983473", "55.450138", "Recherche (général)", "Présence du Glénan (CFTO)");
+        assertResultRow(result, row++, "13/2/2013 7:32", "-8.950139", "55.516804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 8:35", "-8.950139", "55.68347", "Route vers des systèmes observés", "Nous n'avons pas trouvé le radeau à cause de la pluie, nous ne l'avons pas retrouvé!");
+        assertResultRow(result, row++, "13/2/2013 10:20", "-9.016806", "56.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 11:29", "-9.0", "56.23347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 13:55", "-8.983473", "56.73347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "");
+        assertResultRow(result, row++, "13/2/2013 14:20", "-9.0", "56.766804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 16:24", "-9.250139", "57.133472", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 18:57", "-8.783473", "57.350136", "Fin de veille", "Route jusqu'à 23h.");
+        assertResultRow(result, row++, "14/2/2013 6:5", "-7.9501386", "57.68347", "Recherche (général)", "Pluie.");
+        assertResultRow(result, row++, "14/2/2013 7:2", "-7.7501388", "57.73347", "Route vers des systèmes observés", "Présence de marsouins, nous n'allons pas vers le système observé, nous reprnons notre cap sans se rendre sur zone. Pluie");
+        assertResultRow(result, row++, "14/2/2013 7:5", "-7.7334723", "57.73347", "Recherche (général)", "Pluie");
+        assertResultRow(result, row++, "14/2/2013 10:19", "-7.150139", "58.0", "Thonier arrivant sur le système détecté", "\"Balbaya de Marsouins\" pas d'YFT.");
+        assertResultRow(result, row++, "14/2/2013 18:23", "-6.633472", "57.48347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "14/2/2013 18:52", "-6.633472", "57.383472", "Fin de veille", "Route toute la nuit.");
+        assertResultRow(result, row++, "15/2/2013 16:54", "-5.7334723", "54.33347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "15/2/2013 17:46", "-5.5834723", "54.33347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "15/2/2013 19:1", "-5.433472", "54.166805", "Route de nuit vers objet", "Route vers un radeau balisé du bateau au nord apperçu sur un logiciel du bateau.");
+        assertResultRow(result, row++, "16/2/2013 6:0", "-4.2168055", "53.850136", "Recherche (général)", "Nous n'avons pas retrouvé le radeau balisé appartenant au navire, nous reprenons notre route vers l'ouest");
+        assertResultRow(result, row++, "16/2/2013 8:5", "-4.383472", "53.716805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "16/2/2013 8:39", "-4.4668055", "53.666805", "Route vers des systèmes observés", "\"Chicanneurs");
+        assertResultRow(result, row++, "16/2/2013 8:48", "-4.5001388", "53.666805", "Thonier arrivant sur le système détecté", "\"Chicaneurs\" vus \"sur l'eau\" en surface puis ils ont plongés.");
+        assertResultRow(result, row++, "16/2/2013 9:43", "-4.633472", "53.766804", "Thonier arrivant sur le système détecté", "\"chicaneurs\"");
+        assertResultRow(result, row++, "16/2/2013 11:3", "-4.633472", "53.550137", "Route vers des systèmes observés", "Frégates observées.");
+        assertResultRow(result, row++, "16/2/2013 11:21", "-4.5834723", "53.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "16/2/2013 16:40", "-4.6168056", "53.08347", "Recherche (général)", "Erreur de ma part sur l'horraire, j'ai cru que le nid de pie avait vu quelque chose hors il n'y avait rien.");
+        assertResultRow(result, row++, "16/2/2013 19:8", "-4.783472", "52.68347", "Fin de veille", "Route jusqu'à 20h");
+        assertResultRow(result, row++, "17/2/2013 6:12", "-4.8168054", "52.550137", "Recherche (général)", "");
+        assertResultRow(result, row++, "17/2/2013 7:22", "-4.7168055", "52.350136", "Route vers des systèmes observés", "Listao, la distance est trop importante, nous allons voir \"point de volaille\" moins loin.");
+        assertResultRow(result, row++, "17/2/2013 7:41", "-4.7168055", "52.28347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "17/2/2013 7:43", "-4.7168055", "52.28347", "Route vers des systèmes observés", "\"Chicaneurs\", même système observé que celui de 07h22");
+        assertResultRow(result, row++, "17/2/2013 7:50", "-4.7334723", "52.266804", "Thonier arrivant sur le système détecté", "Pas de thons mais des \"Marsouins\"");
+        assertResultRow(result, row++, "17/2/2013 9:9", "-4.5834723", "52.03347", "Route vers des systèmes observés", "Tâche au sonar, nous prenons le cap puis confirmation des jumelles comme quoi c'est un balbaya de \"marsouins\" et non de \"gros\" nous reprenons notre cap directement sans aller jusqu'au système observé.");
+        assertResultRow(result, row++, "17/2/2013 13:45", "-4.4668055", "51.73347", "Recherche (général)", "Shiftage de la calée duy 16.02.2013 de 14h à 14h57");
+        assertResultRow(result, row++, "17/2/2013 14:22", "-4.483472", "51.700138", "Début de pêche (larguage du skiff)", "Environ 10 globicéphales autour du bateau");
+        assertResultRow(result, row++, "17/2/2013 19:15", "-4.7001386", "51.466805", "Fin de veille", "Pas de route cette nuit. Nous sommes stoppés.");
+        assertResultRow(result, row++, "18/2/2013 7:59", "-4.7001386", "51.066803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "18/2/2013 8:0", "-4.7001386", "51.066803", "Recherche (général)", "Shiftage de 8h30 à 10h36J'ai loupé la rencontre avec un objet flottant, voilà le détail: Aux positions 4'42 et 50'53 il y a eut récupération d'une balise 98 et  pose d'une balise 04 sur un radeau (bambou filet) appartenant à un autre armement");
+        assertResultRow(result, row++, "18/2/2013 17:50", "-4.2168055", "49.40014", "Recherche (général)", "Changement d'heure (-1 heure!)");
+        assertResultRow(result, row++, "18/2/2013 18:23", "-4.183472", "49.300137", "Fin de veille", "Nous faisons route toute la nuit seuf si rencontre avec d'autres navires, nous stoppons.");
+        assertResultRow(result, row++, "19/2/2013 6:35", "-3.6168058", "48.116802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "19/2/2013 7:47", "-3.550139", "47.93347", "Route vers des systèmes observés", "Présence de \"Marsousins\" et de Listao vu aux jumelle avant d'être arrivé sur le système observé, nous reprenons directement notre cap!");
+        assertResultRow(result, row++, "19/2/2013 9:28", "-3.4668057", "47.766804", "Début de pêche (larguage du skiff)", "Présence du bteau TREVIGNON");
+        assertResultRow(result, row++, "19/2/2013 16:40", "-3.4668057", "47.78347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "19/2/2013 16:53", "-3.4834723", "47.83347", "Route vers des systèmes observés", "Vu mattes aux jumelles, direction du système observé puis avant d'y arriver sur le système observé nous avons repris notre cap car c'était des listao!");
+        assertResultRow(result, row++, "19/2/2013 17:18", "-3.550139", "47.766804", "Route vers des systèmes observés", "Gleurre");
+        assertResultRow(result, row++, "19/2/2013 17:36", "-3.6168058", "47.716805", "Thonier arrivant sur le système détecté", "Gleurre en plus");
+        assertResultRow(result, row++, "19/2/2013 17:40", "-3.6168058", "47.700138", "Début de pêche (larguage du skiff)", "Gleurre en plus");
+        assertResultRow(result, row++, "20/2/2013 7:3", "-3.450139", "47.716805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "20/2/2013 8:45", "-3.2168057", "47.700138", "Recherche (général)", "Shiftage de la première calée du 19.02.2013 de 8h à 10h05");
+        assertResultRow(result, row++, "20/2/2013 11:30", "-2.900139", "47.416805", "Route vers des systèmes observés", "Matte observée, route vers système observé, puis changement de cap avant d'arriver sur le système observé car listao aperçu. Reprenons notre cap sans se rendre sur le système observé.");
+        assertResultRow(result, row++, "20/2/2013 14:37", "-2.6334722", "47.93347", "Recherche (général)", "Shiftage de la deuxième calée du 19.02.2013 de 14h à 15h30");
+        assertResultRow(result, row++, "20/2/2013 18:20", "-2.2168057", "48.300137", "Fin de veille", "Stopper pour la nuit à partir de 20h.");
+        assertResultRow(result, row++, "21/2/2013 8:0", "-2.150139", "48.700138", "Recherche (général)", "shiftage de la 3 ème calée du 19.02.2013");
+        assertResultRow(result, row++, "21/2/2013 12:41", "-1.6168056", "49.316803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "21/2/2013 14:2", "-1.5501388", "49.53347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "");
+        assertResultRow(result, row++, "21/2/2013 16:0", "-1.5334722", "49.800137", "Route vers des systèmes observés", "L'épave n'était pas à 1 milles mais plus près, nous l'avons dépassé sans la voir donc nous ne sommes pas aller sur le système observé, de plus aucun oiseaux n'avaient été vu a proximité de l'épave. Nous avons repris directement notre cap.");
+        assertResultRow(result, row++, "21/2/2013 18:11", "-1.3001388", "50.066803", "Fin de veille", "Route toute la nuit.");
+        assertResultRow(result, row++, "22/2/2013 7:21", "-0.25013888", "52.23347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "YFT de 70 kg environ mélangé avec beaucoup de \"marsouins\" impossible de pêcher.");
+        assertResultRow(result, row++, "22/2/2013 7:59", "-0.18347223", "52.316803", "Thonier arrivant sur le système détecté", "Albacore de 70 kg environ mélangés avec \"marsouins\" impossible de pêcher!");
+        assertResultRow(result, row++, "22/2/2013 8:19", "-0.1501389", "52.366802", "Route vers des systèmes observés", "Vu matte au loin, prenons direction du système observé mais en cours de route les matelots aux jumelles s'apperçoivent qu'il y a des \"marsouins\" avec les YFT, nous ^reprnons notre cap sans nous être rendu sur le système observé");
+        assertResultRow(result, row++, "22/2/2013 8:35", "-0.10013889", "52.350136", "Route vers des systèmes observés", "YFT + \"marsouins\", reprise du cap sans nous rendre sur le système observé.");
+        assertResultRow(result, row++, "22/2/2013 10:22", "-0.16680557", "52.616802", "Thonier arrivant sur le système détecté", "YFT mélangés avec\"Marsouins\"");
+        assertResultRow(result, row++, "22/2/2013 15:4", "-0.26680556", "53.23347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "Changement d'heur: +1h (heure de l'île maurice, de la réunion et des seychelles!)");
+        assertResultRow(result, row++, "22/2/2013 15:13", "-0.26680556", "53.250137", "Route vers des systèmes observés", "YFT + \"Marsouins\" mais vu lors du transit en allant sur le système observé, reprise du cap!");
+        assertResultRow(result, row++, "22/2/2013 17:41", "-0.5501389", "53.566803", "Recherche (général)", "Marsouins observé à 2 mioles mais nous n'allons pas sur le système observé");
+        assertResultRow(result, row++, "22/2/2013 18:58", "-0.7501389", "53.40014", "Fin de veille", "Route de nuit.");
+        assertResultRow(result, row++, "23/2/2013 7:4", "-2.350139", "51.03347", "Thonier arrivant sur le système détecté", "Listao + présence d'un cordage pose d'un radeau activité suivante.");
+        assertResultRow(result, row++, "23/2/2013 7:35", "-2.3334723", "50.98347", "Route vers des systèmes observés", "volaille apperçu aux jumelles, nous prenons la direction pour en cours de route on observe que ce sont des listao, on reprend notre cap initial sans se rendre sur le système observé.");
+        assertResultRow(result, row++, "23/2/2013 8:41", "-2.2834723", "50.750137", "Route vers des systèmes observés", "vu au sonar!");
+        assertResultRow(result, row++, "23/2/2013 12:40", "-2.250139", "50.65014", "Thonier arrivant sur le système détecté", "Plusieurs bancs plus ou moins gros!");
+        assertResultRow(result, row++, "23/2/2013 13:1", "-2.250139", "50.633472", "Route vers des systèmes observés", "Poissons allant trop vite re tour sur système observé précédément");
+        assertResultRow(result, row++, "23/2/2013 13:28", "-2.2334723", "50.65014", "Thonier arrivant sur le système détecté", "Petit banc et dispérsé");
+        assertResultRow(result, row++, "23/2/2013 13:30", "-2.2334723", "50.65014", "Recherche (général)", "");
+        assertResultRow(result, row++, "23/2/2013 13:47", "-2.2334723", "50.68347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "23/2/2013 16:6", "-2.2668056", "50.616802", "Recherche (général)", "");
+        assertResultRow(result, row++, "23/2/2013 16:34", "-2.2668056", "50.716805", "Route vers des systèmes observés", "En train de mesurer lorsque le système a été apperçu aux jumelles!");
+        assertResultRow(result, row++, "23/2/2013 19:1", "-2.300139", "50.68347", "Fin de pêche (remontée du skiff)", "Changement d'heure - 1h");
+        assertResultRow(result, row++, "24/2/2013 5:27", "-2.350139", "50.616802", "Recherche (général)", "shiftage du 23.02.2013 de 5h35 à 12h33 puis après calée!");
+        assertResultRow(result, row++, "24/2/2013 8:26", "-2.3168056", "50.716805", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "24/2/2013 8:42", "-2.2668056", "50.73347", "Thonier arrivant sur le système détecté", "Mélangé avec \"Marsouins\" (je pense des dauphins longirostre).");
+        assertResultRow(result, row++, "24/2/2013 8:48", "-2.2668056", "50.716805", "Route vers des systèmes observés", "Le poisson se déplace trop vite, nous n'allons pas sur le système observé");
+        assertResultRow(result, row++, "24/2/2013 9:59", "-2.2834723", "50.68347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "24/2/2013 11:27", "-2.5834723", "50.716805", "Route vers des systèmes observés", "Dauphins longirostre. On fait se séparer les thons et les dauphins en suivant ces derniers.\n");
+        assertResultRow(result, row++, "24/2/2013 11:30", "-2.5834723", "50.716805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "24/2/2013 11:57", "-2.600139", "50.716805", "Route vers des systèmes observés", "Arrivés sur le système à 12h03 (oublies de le noter sur le formulaire route!)");
+        assertResultRow(result, row++, "24/2/2013 15:19", "-2.6168058", "50.766804", "Route vers des systèmes observés", "2 mattes");
+        assertResultRow(result, row++, "24/2/2013 15:32", "-2.5834723", "50.800137", "Thonier arrivant sur le système détecté", "Mélange SKJ + YFT.");
+        assertResultRow(result, row++, "24/2/2013 15:58", "-2.5168056", "50.816803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "24/2/2013 16:58", "-2.3334723", "50.73347", "Route vers des systèmes observés", "\"Marsouins\" apperçu après avoir pris la direction du système observé, reprise du cap sans se rendre sur le système.");
+        assertResultRow(result, row++, "24/2/2013 18:12", "-2.5168056", "50.616802", "Fin de veille", "Stopper pour la nuit.");
+        assertResultRow(result, row++, "25/2/2013 5:52", "-2.7168057", "50.53347", "Route vers des systèmes observés", "Balbya de \"Marsouins\", reprise du cap sans s'être rendu sur le système observé.");
+        assertResultRow(result, row++, "25/2/2013 6:12", "-2.7668056", "50.58347", "Recherche (général)", "Shiftage du 23 et 24.02.2013 jusqu'à 14h20");
+        assertResultRow(result, row++, "25/2/2013 6:24", "-2.8168056", "50.58347", "Route vers des systèmes observés", "Banc trop petit et inintéressant, recherche général sans se rendre sur le système observé.");
+        assertResultRow(result, row++, "25/2/2013 12:35", "-3.4168057", "50.600136", "Route vers des systèmes observés", "\"Marsouins\" vu en coursz de route, reprise directement du cap, sans se rendre sur le système observé");
+        assertResultRow(result, row++, "25/2/2013 14:31", "-3.5834723", "50.90014", "Route vers des systèmes observés", "Fin du shiftage du 23 et 24.02.2013 à 14h 20");
+        assertResultRow(result, row++, "25/2/2013 16:22", "-3.5668056", "51.050137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "26/2/2013 6:3", "-4.300139", "52.98347", "Début de pêche (larguage du skiff)", "Sachant que nous débarquons le lendemain aux Seychelles, il n'y aura pas de shiftage, les poissons restent en saumure!");
+        assertResultRow(result, row++, "26/2/2013 9:53", "-4.3501387", "53.166805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "26/2/2013 10:35", "-4.433472", "53.23347", "Thonier arrivant sur le système détecté", "Trombe d'eau apparçu à 5 milles");
+        assertResultRow(result, row++, "26/2/2013 12:4", "-4.6001387", "53.366802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "26/2/2013 13:7", "-4.6668053", "53.58347", "Recherche (général)", "Shiftage du 25.02.2013 de 13h à 16h35");
+        assertResultRow(result, row++, "26/2/2013 18:22", "-5.3168054", "54.566803", "Fin de veille", "Stopper pour la nuit.");
+        assertResultRow(result, row++, "27/2/2013 15:36", "-4.5834723", "55.48347", "Autres (à préciser dans les notes)", "En attente pour rentrer au port avec le pilote");
+        assertResultRow(result, row++, "27/2/2013 16:22", "-4.6168056", "55.450138", "Au port", "Fin de la première partie de calée.Loch totale marée: 5953.03");
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAllActivitysTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAllActivitysTest.java
new file mode 100644
index 0000000..969788f
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportAllActivitysTest.java
@@ -0,0 +1,943 @@
+package fr.ird.observe.services.service.actions.report;
+
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2014 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+
+import fr.ird.observe.services.service.actions.report.AbstractReportServiceTopiaTest;
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+/**
+ * Created on 7/4/14.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 3.5
+ */
+public class ReportAllActivitysTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected String getReportId() {
+        return "allActivitys";
+    }
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Toutes les activités et leurs positions",
+                "Afficher toutes les activités et leurs positions géographiques"
+        );
+
+        assertReportDimension(
+                report,
+                -1,
+                5,
+                new String[]{"Jour - Heure observation", "Latitude", "Longitude", "Activité", "Commentaire",
+                },
+                null
+        );
+
+        assertReportNbRequests(report, 1);
+
+        ReportRequest[] requests = report.getRequests();
+
+        assertReportRequestDimension(
+                requests[0],
+                ReportRequest.RequestLayout.row,
+                0,
+                0
+        );
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 5, 862, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "25/1/2013 16:50", "-20.166805", "57.466805", "Au port", null);
+        assertResultRow(result, row++, "25/1/2013 17:50", "-20.083473", "57.466805", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "25/1/2013 19:0", "-19.833473", "57.466805", "Fin de veille", "Pas de fin de veille, toujours en transit 01.");
+        assertResultRow(result, row++, "26/1/2013 6:18", "-17.416805", "57.466805", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 7:15", "-17.20014", "57.466805", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 8:23", "-16.900139", "57.516804", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 9:21", "-16.650139", "57.566803", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 10:25", "-16.35014", "57.616802", "Transit (route sans recherche)", "");
+        assertResultRow(result, row++, "26/1/2013 11:24", "-16.083473", "57.800137", "Transit (route sans recherche)", "");
+        assertResultRow(result, row++, "26/1/2013 12:26", "-15.800139", "57.73347", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 13:35", "-15.500139", "57.800137", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 14:26", "-15.283473", "57.83347", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 15:26", "-15.016806", "57.883472", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 16:22", "-14.883472", "57.916805", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 17:28", "-14.633472", "58.0", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 18:22", "-14.400139", "58.03347", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "26/1/2013 19:0", "-14.233473", "58.066803", "Autres (à préciser dans les notes)", "Fin de journée toujours en transit.");
+        assertResultRow(result, row++, "27/1/2013 6:0", "-11.283473", "58.666805", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 7:0", "-11.066806", "58.716805", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 7:20", "-11.0", "58.716805", "Route vers des systèmes observés", "Listao trop rapide.");
+        assertResultRow(result, row++, "27/1/2013 8:0", "-10.916806", "58.78347", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 9:0", "-10.700139", "58.78347", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 9:24", "-10.616806", "58.766804", "Route vers des systèmes observés", "Listao trop rapide et petit banc");
+        assertResultRow(result, row++, "27/1/2013 10:0", "-10.516806", "58.766804", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 11:0", "-10.366806", "58.800137", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 11:25", "-10.266806", "58.800137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "27/1/2013 11:34", "-10.250139", "58.800137", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 12:29", "-10.050139", "58.78347", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 13:30", "-9.866806", "58.750137", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 14:30", "-9.666806", "58.68347", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 15:0", "-9.616806", "58.700138", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "27/1/2013 15:12", "-9.60014", "58.700138", "Recherche (général)", "albacore de 3 à 4 kg poissons dispersés et trop petits");
+        assertResultRow(result, row++, "27/1/2013 16:9", "-9.433473", "58.600136", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 17:11", "-9.333472", "58.450138", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 18:11", "-9.316806", "58.250137", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/1/2013 18:56", "-9.300139", "58.08347", "Fin de veille", null);
+        assertResultRow(result, row++, "28/1/2013 6:0", "-9.250139", "56.800137", "Recherche (général)", "Transit la nuit, arrété prés d'une épave mais au petit matin pas de poisson donc nous sommes reparti directement sans toucher à l'épave.");
+        assertResultRow(result, row++, "28/1/2013 7:0", "-9.10014", "56.666805", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 7:30", "-9.050139", "56.616802", "Récupération d'une épave n'appartenant pas au bateau", null);
+        assertResultRow(result, row++, "28/1/2013 7:39", "-9.050139", "56.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 8:34", "-8.900139", "56.500137", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 9:35", "-8.733473", "56.366802", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 10:36", "-8.566806", "56.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 11:27", "-8.450139", "56.68347", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 11:51", "-8.450139", "56.716805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "28/1/2013 12:52", "-8.283473", "56.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 13:52", "-8.216805", "57.066803", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 14:54", "-8.083472", "57.200138", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 15:52", "-7.933472", "57.350136", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 16:52", "-7.8501387", "57.53347", "Recherche (général)", "Rencontre d'un thonier espagnol visible à l'oeil nu.");
+        assertResultRow(result, row++, "28/1/2013 17:52", "-7.7334723", "57.73347", "Recherche (général)", null);
+        assertResultRow(result, row++, "28/1/2013 18:52", "-7.7001386", "57.766804", "Fin de veille", null);
+        assertResultRow(result, row++, "29/1/2013 6:0", "-7.9834723", "58.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "29/1/2013 7:0", "-7.883472", "58.166805", "Recherche (général)", "au moins 5 thoniers visibles au radar (français et espagnols)");
+        assertResultRow(result, row++, "29/1/2013 7:43", "-7.7334723", "58.216805", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "29/1/2013 7:52", "-7.7334723", "58.200138", "Recherche (général)", null);
+        assertResultRow(result, row++, "29/1/2013 8:52", "-7.8168054", "58.40014", "Recherche (général)", null);
+        assertResultRow(result, row++, "29/1/2013 9:5", "-7.800139", "58.416805", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "29/1/2013 10:5", "-7.7334723", "58.566803", "Route vers des systèmes observés", "marsouins et oiseaux.");
+        assertResultRow(result, row++, "29/1/2013 11:5", "-7.650139", "58.633472", "Route vers des systèmes observés", "Pas de calée car plus de marsouins que de thons.\nSuivi d'un nouveaux système: oiseaux à 3.0 milles");
+        assertResultRow(result, row++, "29/1/2013 12:5", "-7.650139", "58.800137", "Recherche (général)", "oiseaux mais pas de thons");
+        assertResultRow(result, row++, "29/1/2013 13:5", "-7.7501388", "58.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "29/1/2013 14:5", "-7.9168053", "59.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "29/1/2013 15:5", "-8.050139", "58.866802", "Recherche (général)", null);
+        assertResultRow(result, row++, "29/1/2013 16:5", "-7.9834723", "58.716805", "Recherche (général)", null);
+        assertResultRow(result, row++, "29/1/2013 17:5", "-7.9668055", "58.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "29/1/2013 17:36", "-7.800139", "58.516804", "Thonier arrivant sur le système détecté", "retour au radeau posé le matin meme");
+        assertResultRow(result, row++, "29/1/2013 18:46", "-7.6001387", "58.43347", "Fin de veille", null);
+        assertResultRow(result, row++, "30/1/2013 5:58", "-6.8334723", "57.966805", "Recherche (général)", "Présence de 7 autres navires thoniers français (CFTO) et espagnols");
+        assertResultRow(result, row++, "30/1/2013 6:23", "-6.766805", "57.90014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "30/1/2013 6:27", "-6.766805", "57.90014", "Thonier arrivant sur le système détecté", "Présence de marsouin, impossible de tourner la senne");
+        assertResultRow(result, row++, "30/1/2013 7:16", "-6.783472", "57.716805", "Recherche (général)", "");
+        assertResultRow(result, row++, "30/1/2013 8:16", "-6.8168054", "58.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "30/1/2013 9:16", "-6.7501388", "58.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "30/1/2013 9:58", "-6.766805", "57.73347", "Route vers des systèmes observés", "Présence de marsouins, impossible de tourner la senne.");
+        assertResultRow(result, row++, "30/1/2013 10:8", "-6.800139", "57.716805", "Recherche (général)", "");
+        assertResultRow(result, row++, "30/1/2013 11:8", "-6.7168055", "58.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "30/1/2013 12:8", "-6.550139", "58.133472", "Recherche (général)", null);
+        assertResultRow(result, row++, "30/1/2013 12:33", "-6.483472", "58.200138", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "30/1/2013 12:50", "-6.4668055", "58.200138", "Début de pêche (larguage du skiff)", "Aucunes espèces accessoires, aucuns rejets de thon lors du shiftage le 31.01.2013 sauf erreur de ma part deux listao de 67 et 71 cm!");
+        assertResultRow(result, row++, "30/1/2013 15:14", "-6.483472", "58.200138", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "30/1/2013 15:31", "-6.4668055", "58.23347", "Recherche (général)", null);
+        assertResultRow(result, row++, "30/1/2013 16:33", "-6.483472", "58.200138", "Recherche (général)", null);
+        assertResultRow(result, row++, "30/1/2013 17:33", "-6.683472", "58.200138", "Recherche (général)", null);
+        assertResultRow(result, row++, "30/1/2013 18:53", "-6.9834723", "58.266804", "Fin de veille", null);
+        assertResultRow(result, row++, "31/1/2013 5:46", "-7.766805", "58.450138", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "31/1/2013 6:6", "-7.766805", "58.450138", "Recherche (général)", "");
+        assertResultRow(result, row++, "31/1/2013 7:6", "-7.6168056", "58.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "31/1/2013 7:40", "-7.516805", "58.633472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "31/1/2013 7:42", "-7.533472", "58.65014", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "31/1/2013 7:57", "-7.533472", "58.65014", "Recherche (général)", "");
+        assertResultRow(result, row++, "31/1/2013 8:59", "-7.4668055", "58.78347", "Recherche (général)", null);
+        assertResultRow(result, row++, "31/1/2013 9:12", "-7.433472", "58.816803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "31/1/2013 9:28", "-7.4168053", "58.866802", "Route vers des systèmes observés", "présence de marsouins");
+        assertResultRow(result, row++, "31/1/2013 9:59", "-7.3668056", "58.966805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "31/1/2013 10:0", "-7.3668056", "58.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "31/1/2013 10:53", "-7.3168054", "59.100136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "31/1/2013 11:23", "-7.283472", "59.100136", "Recherche (général)", null);
+        assertResultRow(result, row++, "31/1/2013 12:23", "-7.2501388", "58.90014", "Route vers des systèmes observés", "couple de frégattes");
+        assertResultRow(result, row++, "31/1/2013 12:42", "-7.2501388", "58.850136", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "31/1/2013 12:55", "-7.2668056", "58.800137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "31/1/2013 13:0", "-7.2668056", "58.816803", "Recherche (général)", "");
+        assertResultRow(result, row++, "31/1/2013 15:15", "-7.2668056", "58.316803", "Recherche (général)", "Shiftage du 30.01.2013 réalisé à 14h. Observation de marsouins dont non calée lors du shiftage.");
+        assertResultRow(result, row++, "31/1/2013 16:15", "-7.3501387", "58.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "31/1/2013 17:19", "-7.3668056", "57.883472", "Recherche (général)", null);
+        assertResultRow(result, row++, "31/1/2013 17:59", "-7.3668056", "57.766804", "Route vers des systèmes observés", "frégattes\nNon coup de senne : changement de câble de la senne.");
+        assertResultRow(result, row++, "31/1/2013 18:25", "-7.283472", "57.73347", "Recherche (général)", "");
+        assertResultRow(result, row++, "31/1/2013 18:59", "-7.3501387", "57.666805", "Fin de veille", null);
+        assertResultRow(result, row++, "1/2/2013 5:42", "-6.3334723", "57.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "1/2/2013 6:15", "-6.3501387", "57.550137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "1/2/2013 6:22", "-6.3334723", "57.550137", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "1/2/2013 6:40", "-6.3501387", "57.550137", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "1/2/2013 8:25", "-6.3501387", "57.566803", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "1/2/2013 8:31", "-6.3501387", "57.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "1/2/2013 8:56", "-6.3668056", "57.58347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "1/2/2013 9:2", "-6.4168053", "57.58347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "1/2/2013 9:30", "-6.400139", "57.566803", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "1/2/2013 11:20", "-6.383472", "57.566803", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "1/2/2013 11:25", "-6.400139", "57.550137", "Recherche (général)", null);
+        assertResultRow(result, row++, "1/2/2013 12:30", "-6.383472", "57.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "1/2/2013 13:30", "-6.5834723", "57.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "1/2/2013 14:30", "-6.6001387", "57.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "1/2/2013 14:37", "-6.6168056", "57.53347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "1/2/2013 14:44", "-6.5668054", "57.53347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "1/2/2013 14:54", "-6.5668054", "57.53347", "Recherche (général)", "");
+        assertResultRow(result, row++, "1/2/2013 15:42", "-6.4668055", "57.53347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "1/2/2013 15:52", "-6.4501386", "57.53347", "Recherche (général)", "");
+        assertResultRow(result, row++, "1/2/2013 16:55", "-6.2668056", "57.43347", "Recherche (général)", null);
+        assertResultRow(result, row++, "1/2/2013 17:55", "-6.300139", "57.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "1/2/2013 18:56", "-6.4168053", "57.600136", "Fin de veille", null);
+        assertResultRow(result, row++, "2/2/2013 5:54", "-6.433472", "57.68347", "Recherche (général)", "7 thoniers autour de nous visibles au radar et à l'oeil nu");
+        assertResultRow(result, row++, "2/2/2013 6:45", "-6.4501386", "57.550137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 6:47", "-6.4501386", "57.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 6:48", "-6.4501386", "57.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 7:48", "-6.383472", "57.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 8:0", "-6.400139", "57.53347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 8:5", "-6.400139", "57.550137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 8:13", "-6.400139", "57.550137", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 8:26", "-6.433472", "57.53347", "Recherche (général)", "Rencontre avec le DOLOMIEUX, flotte SAPMER, pour récupérer les balises du BERNICA récupérées à MAHE aux Seychelles.");
+        assertResultRow(result, row++, "2/2/2013 8:59", "-6.5001388", "57.550137", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "2/2/2013 9:4", "-6.5001388", "57.550137", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 9:8", "-6.516805", "57.550137", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "2/2/2013 9:12", "-6.533472", "57.550137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 9:18", "-6.533472", "57.516804", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "2/2/2013 9:20", "-6.533472", "57.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 9:22", "-6.516805", "57.516804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 9:24", "-6.516805", "57.53347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "2/2/2013 9:37", "-6.516805", "57.53347", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "2/2/2013 11:50", "-6.516805", "57.550137", "Fin de pêche (remontée du skiff)", "Coup nul, filet déchiré et emmélé.");
+        assertResultRow(result, row++, "2/2/2013 11:52", "-6.516805", "57.550137", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 12:31", "-6.4501386", "57.550137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 12:37", "-6.433472", "57.566803", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "2/2/2013 12:48", "-6.433472", "57.58347", "Recherche (général)", "");
+        assertResultRow(result, row++, "2/2/2013 13:36", "-6.4168053", "57.750137", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "2/2/2013 13:41", "-6.433472", "57.766804", "Thonier arrivant sur le système détecté", "Présence marsouin");
+        assertResultRow(result, row++, "2/2/2013 14:41", "-6.4668055", "57.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 14:45", "-6.4668055", "57.98347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 14:50", "-6.483472", "57.98347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 14:51", "-6.483472", "58.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 15:13", "-6.5001388", "58.066803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 15:20", "-6.533472", "58.08347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 15:24", "-6.533472", "58.066803", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 15:42", "-6.5668054", "58.08347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 15:48", "-6.550139", "58.116802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 15:53", "-6.550139", "58.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 16:49", "-6.4501386", "58.28347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 16:53", "-6.433472", "58.28347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 16:56", "-6.433472", "58.300137", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 17:56", "-6.533472", "58.18347", "Recherche (général)", null);
+        assertResultRow(result, row++, "2/2/2013 18:10", "-6.5001388", "58.166805", "Thonier arrivant sur le système détecté", "perte du système");
+        assertResultRow(result, row++, "2/2/2013 18:12", "-6.5001388", "58.166805", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "2/2/2013 18:20", "-6.483472", "58.15014", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "2/2/2013 18:50", "-6.5668054", "58.08347", "Fin de veille", "3 bateaux dans la zone. On reste sur zone jusqu'à demain car présence de \"nourriture\" aux sonars");
+        assertResultRow(result, row++, "3/2/2013 6:1", "-6.533472", "58.100136", "Recherche (général)", "un autre thonier dans la zone visible au radar.");
+        assertResultRow(result, row++, "3/2/2013 6:56", "-6.6168056", "58.08347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 6:59", "-6.633472", "58.100136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 7:5", "-6.6168056", "58.08347", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 7:57", "-6.483472", "58.15014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 7:59", "-6.483472", "58.15014", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "3/2/2013 8:18", "-6.4501386", "58.15014", "Thonier arrivant sur le système détecté", "Haut fond à 292 m, risque de perdre le filet si coup de senne");
+        assertResultRow(result, row++, "3/2/2013 8:22", "-6.4501386", "58.166805", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 8:50", "-6.483472", "58.166805", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 9:0", "-6.483472", "58.133472", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "3/2/2013 9:3", "-6.483472", "58.133472", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "3/2/2013 10:41", "-6.4668055", "58.15014", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "3/2/2013 10:43", "-6.4668055", "58.15014", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 11:18", "-6.5001388", "58.133472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 11:22", "-6.516805", "58.15014", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 11:23", "-6.516805", "58.15014", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 11:29", "-6.516805", "58.15014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 11:33", "-6.550139", "58.166805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 11:43", "-6.550139", "58.166805", "Recherche (général)", "");
+        assertResultRow(result, row++, "3/2/2013 12:17", "-6.6001387", "58.23347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 12:44", "-6.6168056", "58.300137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 13:17", "-6.6001387", "58.383472", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 13:22", "-6.6001387", "58.383472", "Route vers des systèmes observés", "Tâche au sonar, ne savent pas ce que c'est!");
+        assertResultRow(result, row++, "3/2/2013 13:24", "-6.6001387", "58.383472", "Route vers des systèmes observés", "Balbaya visible à l'oeil nu. Autre système que celui observé à 13h22.");
+        assertResultRow(result, row++, "3/2/2013 13:37", "-6.6168056", "58.383472", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 13:38", "-6.6168056", "58.40014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 13:40", "-6.6168056", "58.40014", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 13:44", "-6.633472", "58.383472", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 13:45", "-6.633472", "58.383472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 13:57", "-6.683472", "58.33347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "3/2/2013 14:21", "-6.6668053", "58.366802", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "3/2/2013 16:8", "-6.683472", "58.350136", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "3/2/2013 16:14", "-6.7001386", "58.33347", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 16:19", "-6.7168055", "58.33347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 16:32", "-6.7501388", "58.28347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "3/2/2013 16:39", "-6.7501388", "58.266804", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 17:20", "-6.800139", "58.28347", "Route vers des systèmes observés", "Présence de marsouins donc non calée.");
+        assertResultRow(result, row++, "3/2/2013 17:41", "-6.8501387", "58.250137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "3/2/2013 17:53", "-6.8668056", "58.216805", "Thonier arrivant sur le système détecté", "Balise appartenant au Glénan, bateau de la SAPMER");
+        assertResultRow(result, row++, "3/2/2013 17:54", "-6.8668056", "58.216805", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 18:1", "-6.883472", "58.18347", "Route vers des systèmes observés", "Banc de listao. Présence d'un palangrier et de thoniers au radar et à l'oeil nu.");
+        assertResultRow(result, row++, "3/2/2013 18:15", "-6.883472", "58.18347", "Thonier arrivant sur le système détecté", "Banc de listao, Albacore recherché!");
+        assertResultRow(result, row++, "3/2/2013 18:25", "-6.8668056", "58.166805", "Recherche (général)", null);
+        assertResultRow(result, row++, "3/2/2013 18:53", "-6.766805", "58.18347", "Fin de veille", null);
+        assertResultRow(result, row++, "4/2/2013 5:49", "-6.7334723", "58.166805", "Recherche (général)", "2 thoniers visibles au radar.");
+        assertResultRow(result, row++, "4/2/2013 6:49", "-6.6001387", "58.15014", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 7:43", "-6.6001387", "58.016804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 7:48", "-6.5834723", "58.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 7:59", "-6.5834723", "58.0", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "4/2/2013 8:0", "-6.5834723", "58.0", "Récupération d'une épave n'appartenant pas au bateau", "");
+        assertResultRow(result, row++, "4/2/2013 8:13", "-6.5668054", "58.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 8:14", "-6.5668054", "58.016804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 8:31", "-6.533472", "58.066803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 8:49", "-6.533472", "58.08347", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 9:49", "-6.4168053", "58.23347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 9:52", "-6.433472", "58.23347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 10:0", "-6.433472", "58.23347", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 10:6", "-6.4501386", "58.250137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 10:17", "-6.4501386", "58.28347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 10:21", "-6.4501386", "58.28347", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 11:21", "-6.5834723", "58.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 12:9", "-6.550139", "58.03347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 12:32", "-6.550139", "57.966805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 12:36", "-6.550139", "57.950138", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 12:50", "-6.5668054", "57.90014", "Thonier arrivant sur le système détecté", "Il ya des thons albacores partout tout autour du navire. Ils sautent, vont dans tous les sens le banc est énorme mais dispersé et il ne garde pas le même cap!");
+        assertResultRow(result, row++, "4/2/2013 13:50", "-6.5834723", "57.816803", "Thonier arrivant sur le système détecté", "Même banc que précédemment! dispersé et trop rapide.");
+        assertResultRow(result, row++, "4/2/2013 14:8", "-6.6168056", "57.816803", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 14:9", "-6.6168056", "57.816803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 14:17", "-6.650139", "57.816803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 14:20", "-6.650139", "57.816803", "Route vers des systèmes observés", "Même banc qu'à 12h50 ENORME!");
+        assertResultRow(result, row++, "4/2/2013 14:36", "-6.5834723", "57.78347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "4/2/2013 15:36", "-6.533472", "57.766804", "Thonier arrivant sur le système détecté", "Poissons dispersés et trop rapide. Ne gardent pas le même cap, sautent dans tous les sens!");
+        assertResultRow(result, row++, "4/2/2013 16:24", "-6.483472", "57.750137", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "4/2/2013 16:31", "-6.5001388", "57.766804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 16:32", "-6.5001388", "57.766804", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 16:33", "-6.5001388", "57.766804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 16:39", "-6.483472", "57.766804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 16:46", "-6.483472", "57.78347", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 16:57", "-6.4501386", "57.766804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 16:59", "-6.4501386", "57.750137", "Thonier arrivant sur le système détecté", "Présence de globicéphales.");
+        assertResultRow(result, row++, "4/2/2013 17:4", "-6.4501386", "57.766804", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 17:6", "-6.4501386", "57.78347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "4/2/2013 17:12", "-6.4668055", "57.800137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "4/2/2013 17:24", "-6.4501386", "57.816803", "Recherche (général)", null);
+        assertResultRow(result, row++, "4/2/2013 17:36", "-6.433472", "57.850136", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "4/2/2013 17:40", "-6.433472", "57.883472", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "4/2/2013 18:3", "-6.433472", "57.916805", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "4/2/2013 19:43", "-6.433472", "57.916805", "Fin de pêche (remontée du skiff)", "Coup Nul.");
+        assertResultRow(result, row++, "4/2/2013 19:44", "-6.433472", "57.916805", "Fin de veille", null);
+        assertResultRow(result, row++, "5/2/2013 5:43", "-6.4501386", "58.18347", "Thonier arrivant sur le système détecté", "Route de nuit vers le DCP mis la veille.");
+        assertResultRow(result, row++, "5/2/2013 5:48", "-6.4501386", "58.18347", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "5/2/2013 8:0", "-6.4668055", "58.200138", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "5/2/2013 8:16", "-6.4668055", "58.23347", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 9:22", "-6.5834723", "58.08347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "5/2/2013 9:29", "-6.6001387", "58.016804", "Thonier arrivant sur le système détecté", "Présence de marsouins");
+        assertResultRow(result, row++, "5/2/2013 9:30", "-6.6001387", "58.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 10:13", "-6.6668053", "57.883472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "5/2/2013 10:26", "-6.6668053", "57.83347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "5/2/2013 10:30", "-6.683472", "57.83347", "Thonier arrivant sur le système détecté", "Présence de Marsouins!");
+        assertResultRow(result, row++, "5/2/2013 10:33", "-6.683472", "57.816803", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 10:53", "-6.7501388", "57.78347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "5/2/2013 11:13", "-6.800139", "57.750137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "5/2/2013 11:25", "-6.800139", "57.750137", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 12:25", "-6.8168054", "57.666805", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 13:25", "-7.183472", "57.666805", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 14:25", "-7.4501386", "57.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 14:35", "-7.5001388", "57.633472", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "5/2/2013 14:38", "-7.5001388", "57.633472", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 15:38", "-7.766805", "57.600136", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 16:17", "-7.9501386", "57.516804", "Route vers des systèmes observés", "Listao");
+        assertResultRow(result, row++, "5/2/2013 16:28", "-8.0", "57.516804", "Thonier arrivant sur le système détecté", "Listao");
+        assertResultRow(result, row++, "5/2/2013 16:35", "-8.016806", "57.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "5/2/2013 17:42", "-8.316806", "57.43347", "Recherche (général)", "Marsouins observé mais nous les avons laissé au loin sur tribord sans prendre leur direction");
+        assertResultRow(result, row++, "5/2/2013 18:57", "-8.650139", "57.43347", "Fin de veille", null);
+        assertResultRow(result, row++, "6/2/2013 5:55", "-11.616806", "56.550137", "Recherche (général)", null);
+        assertResultRow(result, row++, "6/2/2013 6:31", "-11.766806", "56.53347", "Route vers des systèmes observés", "Banc de listao");
+        assertResultRow(result, row++, "6/2/2013 6:37", "-11.800139", "56.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 6:41", "-11.800139", "56.550137", "Recherche (général)", null);
+        assertResultRow(result, row++, "6/2/2013 7:28", "-12.0", "56.550137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "6/2/2013 7:34", "-12.016806", "56.550137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 7:47", "-12.016806", "56.550137", "Recherche (général)", "Shiftage de la calée du 05.02.13 réalisée à 8H");
+        assertResultRow(result, row++, "6/2/2013 8:43", "-12.200139", "56.40014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "6/2/2013 8:51", "-12.233473", "56.200138", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 9:41", "-12.366806", "56.200138", "Route vers des systèmes observés", "Zone avec pleins de petits balbaya. 3 thoniers français sur zone.");
+        assertResultRow(result, row++, "6/2/2013 9:43", "-12.366806", "56.18347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 10:5", "-12.433473", "56.100136", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "6/2/2013 10:16", "-12.466805", "56.066803", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "6/2/2013 10:19", "-12.466805", "56.050137", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "6/2/2013 12:28", "-12.466805", "56.03347", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "6/2/2013 12:32", "-12.466805", "56.050137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "6/2/2013 12:49", "-12.416806", "56.050137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 13:0", "-12.433473", "56.066803", "Recherche (général)", null);
+        assertResultRow(result, row++, "6/2/2013 13:10", "-12.450139", "56.100136", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "6/2/2013 13:26", "-12.416806", "56.133472", "Route vers des systèmes observés", "Pleins de petits banc d'YFT et de SKJ");
+        assertResultRow(result, row++, "6/2/2013 14:20", "-12.450139", "56.0", "Thonier arrivant sur le système détecté", "listao + baleine");
+        assertResultRow(result, row++, "6/2/2013 14:20", "-12.450139", "56.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "6/2/2013 14:30", "-12.450139", "56.050137", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "6/2/2013 15:14", "-12.450139", "56.100136", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "6/2/2013 15:51", "-12.366806", "56.03347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "6/2/2013 15:54", "-12.366806", "56.03347", "Recherche (général)", null);
+        assertResultRow(result, row++, "6/2/2013 16:22", "-12.400139", "56.03347", "Route vers des systèmes observés", "une dizaine de poisson (petit banc).");
+        assertResultRow(result, row++, "6/2/2013 16:25", "-12.400139", "56.016804", "Thonier arrivant sur le système détecté", "Plusieurs bancs, dont un plus interessant.");
+        assertResultRow(result, row++, "6/2/2013 16:53", "-12.400139", "56.016804", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "6/2/2013 19:1", "-12.383472", "56.0", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "6/2/2013 19:3", "-12.383472", "56.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "6/2/2013 19:22", "-12.333472", "56.03347", "Fin de veille", null);
+        assertResultRow(result, row++, "7/2/2013 5:47", "-12.216805", "56.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 6:6", "-12.183473", "56.116802", "Route vers des systèmes observés", "Présence de marsouins, nous continuons notre route.");
+        assertResultRow(result, row++, "7/2/2013 6:8", "-12.183473", "56.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 6:32", "-12.200139", "56.116802", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "7/2/2013 6:34", "-12.200139", "56.133472", "Thonier arrivant sur le système détecté", "Banc de listao");
+        assertResultRow(result, row++, "7/2/2013 6:36", "-12.216805", "56.133472", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 6:38", "-12.216805", "56.133472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "7/2/2013 7:9", "-12.266806", "56.133472", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 7:10", "-12.266806", "56.166805", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 7:13", "-12.266806", "56.18347", "Route vers des systèmes observés", "Listao + baleines");
+        assertResultRow(result, row++, "7/2/2013 7:25", "-12.300139", "56.216805", "Thonier arrivant sur le système détecté", "Listao + 3 baleines");
+        assertResultRow(result, row++, "7/2/2013 7:32", "-12.333472", "56.200138", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "7/2/2013 8:11", "-12.383472", "56.050137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 8:15", "-12.383472", "56.03347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "7/2/2013 8:21", "-12.383472", "56.03347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "7/2/2013 8:57", "-12.400139", "55.950138", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "7/2/2013 11:12", "-12.400139", "55.93347", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "7/2/2013 11:16", "-12.400139", "55.93347", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 11:46", "-12.383472", "55.98347", "Route vers des systèmes observés", "Nombre impressionnant de thons! gros balbaya!");
+        assertResultRow(result, row++, "7/2/2013 11:47", "-12.383472", "55.98347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "7/2/2013 12:47", "-12.416806", "56.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 12:51", "-12.416806", "56.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 13:3", "-12.383472", "56.03347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "7/2/2013 13:8", "-12.35014", "56.03347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 13:42", "-12.35014", "56.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 13:46", "-12.366806", "56.016804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "7/2/2013 13:52", "-12.400139", "56.016804", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "7/2/2013 13:56", "-12.400139", "56.016804", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "7/2/2013 15:54", "-12.416806", "56.016804", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "7/2/2013 16:10", "-12.366806", "55.98347", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 16:43", "-12.266806", "55.966805", "Route vers des systèmes observés", "Banc de Listao");
+        assertResultRow(result, row++, "7/2/2013 16:45", "-12.283473", "55.950138", "Thonier arrivant sur le système détecté", "Banc de listao trop rapide, banc de gros albacore visé!");
+        assertResultRow(result, row++, "7/2/2013 16:46", "-12.283473", "55.950138", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 16:52", "-12.283473", "55.98347", "Route vers des systèmes observés", "Banc de listao vu directement aux jumelles nous continuons donc notre route!");
+        assertResultRow(result, row++, "7/2/2013 17:39", "-12.250139", "55.98347", "Route vers des systèmes observés", "Listao + baleine");
+        assertResultRow(result, row++, "7/2/2013 18:1", "-12.283473", "55.916805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "7/2/2013 18:9", "-12.300139", "55.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "7/2/2013 19:0", "-12.433473", "55.883472", "Fin de veille", null);
+        assertResultRow(result, row++, "8/2/2013 5:54", "-12.433473", "55.816803", "Recherche (général)", null);
+        assertResultRow(result, row++, "8/2/2013 6:54", "-12.383472", "55.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "8/2/2013 6:58", "-12.333472", "55.93347", "Route vers des systèmes observés", "Pleins de \"petits bouillons\" partout tout autour de nous, petits bancs rapides!");
+        assertResultRow(result, row++, "8/2/2013 7:17", "-12.316806", "55.950138", "Thonier arrivant sur le système détecté", "Banc de listao + marsouins+ oiseaux");
+        assertResultRow(result, row++, "8/2/2013 7:23", "-12.300139", "55.98347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 7:29", "-12.283473", "56.0", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 7:34", "-12.266806", "56.0", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 7:50", "-12.216805", "56.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 7:52", "-12.233473", "56.016804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 8:2", "-12.250139", "56.03347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 8:4", "-12.250139", "56.03347", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "8/2/2013 8:21", "-12.200139", "56.100136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 8:25", "-12.200139", "56.116802", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 8:27", "-12.200139", "56.116802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 8:52", "-12.183473", "56.08347", "Recherche (général)", null);
+        assertResultRow(result, row++, "8/2/2013 9:1", "-12.216805", "56.066803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 9:15", "-12.250139", "56.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 9:29", "-12.250139", "56.016804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 9:39", "-12.250139", "55.98347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "8/2/2013 9:52", "-12.250139", "55.98347", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "8/2/2013 11:51", "-12.250139", "55.98347", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "8/2/2013 12:0", "-12.233473", "55.98347", "Recherche (général)", null);
+        assertResultRow(result, row++, "8/2/2013 12:26", "-12.200139", "56.066803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 12:30", "-12.183473", "56.066803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "8/2/2013 12:42", "-12.183473", "56.100136", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 12:59", "-12.183473", "56.116802", "Thonier arrivant sur le système détecté", "listao + albacore trop petits");
+        assertResultRow(result, row++, "8/2/2013 13:0", "-12.183473", "56.133472", "Recherche (général)", null);
+        assertResultRow(result, row++, "8/2/2013 13:6", "-12.183473", "56.116802", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 13:11", "-12.200139", "56.116802", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "8/2/2013 13:27", "-12.200139", "56.133472", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "8/2/2013 15:34", "-12.216805", "56.116802", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "8/2/2013 15:47", "-12.250139", "56.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "8/2/2013 15:51", "-12.266806", "56.100136", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "8/2/2013 16:1", "-12.283473", "56.100136", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "8/2/2013 16:3", "-12.283473", "56.100136", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "8/2/2013 18:8", "-12.300139", "56.100136", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "8/2/2013 18:16", "-12.300139", "56.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "8/2/2013 18:56", "-12.233473", "56.116802", "Fin de veille", null);
+        assertResultRow(result, row++, "9/2/2013 5:50", "-12.233473", "56.050137", "Recherche (général)", null);
+        assertResultRow(result, row++, "9/2/2013 6:35", "-12.166806", "56.100136", "Route vers des systèmes observés", "Banc de listao, pas interessant, nous continuons notre route sans s'arrêter!");
+        assertResultRow(result, row++, "9/2/2013 6:41", "-12.133472", "56.100136", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 6:53", "-12.133472", "56.15014", "Thonier arrivant sur le système détecté", "Présence de \"marsouins\" et banc trop petit");
+        assertResultRow(result, row++, "9/2/2013 6:57", "-12.133472", "56.15014", "Recherche (général)", null);
+        assertResultRow(result, row++, "9/2/2013 7:3", "-12.150139", "56.15014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 7:12", "-12.150139", "56.116802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "9/2/2013 7:30", "-12.166806", "56.066803", "Recherche (général)", null);
+        assertResultRow(result, row++, "9/2/2013 7:42", "-12.216805", "56.066803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 7:59", "-12.266806", "56.03347", "Thonier arrivant sur le système détecté", "Banc de listao");
+        assertResultRow(result, row++, "9/2/2013 8:0", "-12.266806", "56.03347", "Recherche (général)", null);
+        assertResultRow(result, row++, "9/2/2013 8:3", "-12.283473", "56.03347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 8:24", "-12.366806", "56.050137", "Thonier arrivant sur le système détecté", "Pleins de petits bancs partout");
+        assertResultRow(result, row++, "9/2/2013 8:50", "-12.333472", "56.066803", "Recherche (général)", null);
+        assertResultRow(result, row++, "9/2/2013 8:51", "-12.35014", "56.066803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 8:53", "-12.35014", "56.066803", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "9/2/2013 8:55", "-12.366806", "56.050137", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "9/2/2013 11:4", "-12.366806", "56.03347", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "9/2/2013 11:11", "-12.35014", "56.016804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 11:12", "-12.35014", "56.03347", "Thonier arrivant sur le système détecté", "Listao trop rapide et pas interessant pour le capitaine.");
+        assertResultRow(result, row++, "9/2/2013 11:27", "-12.333472", "56.03347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 11:31", "-12.316806", "56.03347", "Thonier arrivant sur le système détecté", "Listao + baleine");
+        assertResultRow(result, row++, "9/2/2013 11:32", "-12.316806", "56.050137", "Route vers des systèmes observés", "pleins de petits \"bouts\" partout");
+        assertResultRow(result, row++, "9/2/2013 11:35", "-12.316806", "56.050137", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "9/2/2013 11:40", "-12.316806", "56.066803", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "9/2/2013 14:1", "-12.300139", "56.03347", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "9/2/2013 14:3", "-12.300139", "56.03347", "Recherche (général)", null);
+        assertResultRow(result, row++, "9/2/2013 15:15", "-12.283473", "55.966805", "Thonier arrivant sur le système détecté", "Shiftage de 14h à 15h.");
+        assertResultRow(result, row++, "9/2/2013 15:18", "-12.283473", "55.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "9/2/2013 15:37", "-12.316806", "56.0", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 15:48", "-12.316806", "56.050137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "9/2/2013 15:51", "-12.300139", "56.050137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "9/2/2013 15:56", "-12.300139", "56.066803", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "9/2/2013 16:17", "-12.316806", "56.03347", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "9/2/2013 18:39", "-12.333472", "56.016804", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "9/2/2013 18:40", "-12.333472", "56.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "9/2/2013 19:3", "-12.316806", "55.98347", "Fin de veille", null);
+        assertResultRow(result, row++, "10/2/2013 5:55", "-12.316806", "55.916805", "Thonier arrivant sur le système détecté", "épave balisée la veille.");
+        assertResultRow(result, row++, "10/2/2013 6:2", "-12.316806", "55.916805", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 7:2", "-12.366806", "56.03347", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 7:57", "-12.316806", "55.916805", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "10/2/2013 7:58", "-12.316806", "55.916805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "10/2/2013 8:5", "-12.316806", "55.916805", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 8:11", "-12.333472", "55.916805", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "10/2/2013 8:21", "-12.366806", "55.916805", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "10/2/2013 8:26", "-12.366806", "55.916805", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "10/2/2013 10:38", "-12.383472", "55.916805", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "10/2/2013 10:39", "-12.383472", "55.93347", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 11:6", "-12.433473", "55.90014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "10/2/2013 11:21", "-12.450139", "55.850136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "10/2/2013 11:33", "-12.450139", "55.850136", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 12:6", "-12.400139", "55.816803", "Route vers des systèmes observés", "Banc de Listao.");
+        assertResultRow(result, row++, "10/2/2013 12:16", "-12.383472", "55.850136", "Thonier arrivant sur le système détecté", "Banc de Listao");
+        assertResultRow(result, row++, "10/2/2013 12:17", "-12.383472", "55.850136", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 13:17", "-12.200139", "55.73347", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 14:17", "-12.033473", "55.600136", "Recherche (général)", "Shiftage de 14h à 16h06!");
+        assertResultRow(result, row++, "10/2/2013 15:17", "-11.866806", "55.466805", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 16:17", "-11.700139", "55.350136", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 17:46", "-11.983473", "55.366802", "Recherche (général)", null);
+        assertResultRow(result, row++, "10/2/2013 19:4", "-12.216805", "55.48347", "Fin de veille", "");
+        assertResultRow(result, row++, "11/2/2013 5:54", "-12.283473", "55.48347", "Recherche (général)", null);
+        assertResultRow(result, row++, "11/2/2013 6:54", "-12.433473", "55.48347", "Recherche (général)", null);
+        assertResultRow(result, row++, "11/2/2013 6:56", "-12.433473", "55.48347", "Route vers des systèmes observés", "Poissons \"étalés\"");
+        assertResultRow(result, row++, "11/2/2013 7:17", "-12.466805", "55.53347", "Thonier arrivant sur le système détecté", "Nous sommes 5 sur la zone avec notamment le Glénan (CFTO), le Dolomieu (SAPMER) et Franche-Terre (SAPMER)");
+        assertResultRow(result, row++, "11/2/2013 8:21", "-12.450139", "55.516804", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "11/2/2013 11:6", "-12.433473", "55.516804", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "11/2/2013 11:10", "-12.433473", "55.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "11/2/2013 11:23", "-12.433473", "55.516804", "Début de pêche (larguage du skiff)", "Shiftage du 10.02.2013 de 11h10 à 11h30");
+        assertResultRow(result, row++, "11/2/2013 14:2", "-12.416806", "55.516804", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "11/2/2013 14:6", "-12.416806", "55.516804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "11/2/2013 14:8", "-12.416806", "55.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "11/2/2013 14:13", "-12.416806", "55.53347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "11/2/2013 14:33", "-12.366806", "55.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "11/2/2013 15:7", "-12.366806", "55.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "11/2/2013 15:15", "-12.366806", "55.550137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "11/2/2013 15:17", "-12.383472", "55.550137", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "11/2/2013 15:28", "-12.366806", "55.566803", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "11/2/2013 17:35", "-12.35014", "55.550137", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "11/2/2013 17:39", "-12.35014", "55.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "11/2/2013 18:57", "-12.500139", "55.600136", "Fin de veille", null);
+        assertResultRow(result, row++, "12/2/2013 5:50", "-12.516806", "55.450138", "Recherche (général)", "Nous sommes à côté d'un épave.");
+        assertResultRow(result, row++, "12/2/2013 6:28", "-12.416806", "55.500137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "12/2/2013 6:47", "-12.366806", "55.53347", "Thonier arrivant sur le système détecté", "Poissons étalés, Mélange Listao et Albacore");
+        assertResultRow(result, row++, "12/2/2013 6:58", "-12.35014", "55.550137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "12/2/2013 6:59", "-12.35014", "55.550137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "12/2/2013 7:13", "-12.35014", "55.550137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "12/2/2013 7:20", "-12.333472", "55.566803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "12/2/2013 7:38", "-12.316806", "55.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 8:38", "-12.316806", "55.366802", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 9:20", "-12.316806", "55.53347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "12/2/2013 9:36", "-12.300139", "55.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "12/2/2013 9:40", "-12.300139", "55.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 10:40", "-12.116806", "55.600136", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 11:30", "-12.016806", "55.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 12:30", "-11.800139", "55.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 13:24", "-11.60014", "55.68347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "12/2/2013 13:30", "-11.60014", "55.68347", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 14:30", "-11.35014", "55.666805", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 14:53", "-11.316806", "55.616802", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "12/2/2013 15:0", "-11.300139", "55.600136", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "12/2/2013 15:5", "-11.300139", "55.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 16:5", "-11.083472", "55.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 17:5", "-10.866806", "55.58347", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 18:0", "-10.683473", "55.53347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "12/2/2013 18:5", "-10.666806", "55.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "12/2/2013 18:58", "-10.500139", "55.53347", "Fin de veille", null);
+        assertResultRow(result, row++, "13/2/2013 5:52", "-9.016806", "55.250137", "Thonier arrivant sur le système détecté", "Route de nuit vers ce radeau.");
+        assertResultRow(result, row++, "13/2/2013 6:0", "-9.0", "55.250137", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 7:0", "-8.983473", "55.450138", "Recherche (général)", "Présence du Glénan (CFTO)");
+        assertResultRow(result, row++, "13/2/2013 7:24", "-8.983473", "55.516804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "13/2/2013 7:32", "-8.950139", "55.516804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 7:41", "-8.966805", "55.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 8:35", "-8.950139", "55.68347", "Route vers des systèmes observés", "Nous n'avons pas trouvé le radeau à cause de la pluie, nous ne l'avons pas retrouvé!");
+        assertResultRow(result, row++, "13/2/2013 9:0", "-8.966805", "55.750137", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 10:0", "-9.0", "55.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 10:16", "-9.0", "56.016804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "13/2/2013 10:20", "-9.016806", "56.016804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 10:36", "-9.016806", "56.050137", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 11:17", "-9.016806", "56.166805", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "13/2/2013 11:29", "-9.0", "56.23347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 11:33", "-9.0", "56.250137", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 12:38", "-9.0", "56.48347", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 13:38", "-8.966805", "56.68347", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 13:43", "-8.966805", "56.700138", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "13/2/2013 13:55", "-8.983473", "56.73347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "");
+        assertResultRow(result, row++, "13/2/2013 14:0", "-8.983473", "56.73347", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 14:12", "-8.983473", "56.766804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "13/2/2013 14:20", "-9.0", "56.766804", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 14:27", "-9.016806", "56.816803", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 15:27", "-9.116806", "56.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 16:20", "-9.250139", "57.133472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "13/2/2013 16:24", "-9.250139", "57.133472", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "13/2/2013 16:26", "-9.250139", "57.133472", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 17:27", "-9.066806", "57.23347", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 18:27", "-8.883472", "57.33347", "Recherche (général)", null);
+        assertResultRow(result, row++, "13/2/2013 18:57", "-8.783473", "57.350136", "Fin de veille", "Route jusqu'à 23h.");
+        assertResultRow(result, row++, "14/2/2013 6:5", "-7.9501386", "57.68347", "Recherche (général)", "Pluie.");
+        assertResultRow(result, row++, "14/2/2013 7:2", "-7.7501388", "57.73347", "Route vers des systèmes observés", "Présence de marsouins, nous n'allons pas vers le système observé, nous reprnons notre cap sans se rendre sur zone. Pluie");
+        assertResultRow(result, row++, "14/2/2013 7:5", "-7.7334723", "57.73347", "Recherche (général)", "Pluie");
+        assertResultRow(result, row++, "14/2/2013 8:5", "-7.533472", "57.800137", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 9:5", "-7.383472", "57.916805", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 10:5", "-7.2001386", "58.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 10:10", "-7.183472", "58.0", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "14/2/2013 10:19", "-7.150139", "58.0", "Thonier arrivant sur le système détecté", "\"Balbaya de Marsouins\" pas d'YFT.");
+        assertResultRow(result, row++, "14/2/2013 10:20", "-7.150139", "58.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 11:20", "-6.9501386", "58.050137", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 12:20", "-6.7334723", "58.050137", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 13:20", "-6.5668054", "58.166805", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 14:20", "-6.483472", "58.050137", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 15:20", "-6.4668055", "57.850136", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 16:20", "-6.483472", "57.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 17:20", "-6.633472", "57.68347", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 18:20", "-6.633472", "57.48347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "14/2/2013 18:23", "-6.633472", "57.48347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "14/2/2013 18:25", "-6.633472", "57.466805", "Recherche (général)", null);
+        assertResultRow(result, row++, "14/2/2013 18:52", "-6.633472", "57.383472", "Fin de veille", "Route toute la nuit.");
+        assertResultRow(result, row++, "15/2/2013 6:5", "-6.383472", "55.300137", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 7:5", "-6.2668056", "55.15014", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 8:5", "-6.150139", "55.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 9:5", "-6.0668054", "55.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 10:5", "-5.9834723", "54.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 11:5", "-5.9501386", "54.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 11:6", "-5.9501386", "54.700138", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "15/2/2013 11:14", "-5.9501386", "54.666805", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "15/2/2013 12:8", "-6.0", "54.666805", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "15/2/2013 14:4", "-6.0", "54.700138", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "15/2/2013 14:15", "-6.0", "54.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 15:15", "-5.9501386", "54.550137", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 16:15", "-5.8168054", "54.40014", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 16:51", "-5.7334723", "54.33347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "15/2/2013 16:54", "-5.7334723", "54.33347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "15/2/2013 16:56", "-5.7334723", "54.33347", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 17:37", "-5.6001387", "54.316803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "15/2/2013 17:46", "-5.5834723", "54.33347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "15/2/2013 17:50", "-5.5668054", "54.33347", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 18:54", "-5.4501386", "54.166805", "Recherche (général)", null);
+        assertResultRow(result, row++, "15/2/2013 19:0", "-5.433472", "54.166805", "Fin de veille", null);
+        assertResultRow(result, row++, "15/2/2013 19:1", "-5.433472", "54.166805", "Route de nuit vers objet", "Route vers un radeau balisé du bateau au nord apperçu sur un logiciel du bateau.");
+        assertResultRow(result, row++, "16/2/2013 6:0", "-4.2168055", "53.850136", "Recherche (général)", "Nous n'avons pas retrouvé le radeau balisé appartenant au navire, nous reprenons notre route vers l'ouest");
+        assertResultRow(result, row++, "16/2/2013 7:0", "-4.2168055", "53.766804", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 7:54", "-4.3668056", "53.716805", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "16/2/2013 8:5", "-4.383472", "53.716805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "16/2/2013 8:6", "-4.383472", "53.716805", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 8:39", "-4.4668055", "53.666805", "Route vers des systèmes observés", "\"Chicanneurs");
+        assertResultRow(result, row++, "16/2/2013 8:48", "-4.5001388", "53.666805", "Thonier arrivant sur le système détecté", "\"Chicaneurs\" vus \"sur l'eau\" en surface puis ils ont plongés.");
+        assertResultRow(result, row++, "16/2/2013 9:0", "-4.5001388", "53.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 9:28", "-4.5834723", "53.73347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "16/2/2013 9:43", "-4.633472", "53.766804", "Thonier arrivant sur le système détecté", "\"chicaneurs\"");
+        assertResultRow(result, row++, "16/2/2013 9:47", "-4.633472", "53.78347", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 10:47", "-4.633472", "53.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 11:3", "-4.633472", "53.550137", "Route vers des systèmes observés", "Frégates observées.");
+        assertResultRow(result, row++, "16/2/2013 11:21", "-4.5834723", "53.53347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "16/2/2013 11:25", "-4.5668054", "53.516804", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 12:28", "-4.533472", "53.316803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "16/2/2013 12:37", "-4.550139", "53.33347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "16/2/2013 12:55", "-4.5668054", "53.316803", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "16/2/2013 15:15", "-4.5668054", "53.316803", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "16/2/2013 15:21", "-4.5668054", "53.316803", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 16:21", "-4.5668054", "53.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 16:40", "-4.6168056", "53.08347", "Recherche (général)", "Erreur de ma part sur l'horraire, j'ai cru que le nid de pie avait vu quelque chose hors il n'y avait rien.");
+        assertResultRow(result, row++, "16/2/2013 17:40", "-4.7001386", "52.950138", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 18:20", "-4.783472", "52.83347", "Recherche (général)", null);
+        assertResultRow(result, row++, "16/2/2013 19:8", "-4.783472", "52.68347", "Fin de veille", "Route jusqu'à 20h");
+        assertResultRow(result, row++, "17/2/2013 6:12", "-4.8168054", "52.550137", "Recherche (général)", "");
+        assertResultRow(result, row++, "17/2/2013 7:12", "-4.7501388", "52.366802", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 7:22", "-4.7168055", "52.350136", "Route vers des systèmes observés", "Listao, la distance est trop importante, nous allons voir \"point de volaille\" moins loin.");
+        assertResultRow(result, row++, "17/2/2013 7:28", "-4.7168055", "52.316803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "17/2/2013 7:41", "-4.7168055", "52.28347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "17/2/2013 7:43", "-4.7168055", "52.28347", "Route vers des systèmes observés", "\"Chicaneurs\", même système observé que celui de 07h22");
+        assertResultRow(result, row++, "17/2/2013 7:50", "-4.7334723", "52.266804", "Thonier arrivant sur le système détecté", "Pas de thons mais des \"Marsouins\"");
+        assertResultRow(result, row++, "17/2/2013 7:51", "-4.7334723", "52.266804", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 8:0", "-4.7168055", "52.23347", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 8:32", "-4.650139", "52.133472", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 9:9", "-4.5834723", "52.03347", "Route vers des systèmes observés", "Tâche au sonar, nous prenons le cap puis confirmation des jumelles comme quoi c'est un balbaya de \"marsouins\" et non de \"gros\" nous reprenons notre cap directement sans aller jusqu'au système observé.");
+        assertResultRow(result, row++, "17/2/2013 9:12", "-4.5668054", "52.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 9:54", "-4.5001388", "51.90014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "17/2/2013 10:0", "-4.5001388", "51.883472", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "17/2/2013 10:35", "-4.5001388", "51.90014", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "17/2/2013 12:50", "-4.483472", "51.90014", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "17/2/2013 13:0", "-4.4668055", "51.883472", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 13:45", "-4.4668055", "51.73347", "Recherche (général)", "Shiftage de la calée duy 16.02.2013 de 14h à 14h57");
+        assertResultRow(result, row++, "17/2/2013 14:22", "-4.483472", "51.700138", "Début de pêche (larguage du skiff)", "Environ 10 globicéphales autour du bateau");
+        assertResultRow(result, row++, "17/2/2013 16:50", "-4.483472", "51.700138", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "17/2/2013 16:52", "-4.483472", "51.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 17:52", "-4.5668054", "51.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 18:55", "-4.7001386", "51.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "17/2/2013 19:15", "-4.7001386", "51.466805", "Fin de veille", "Pas de route cette nuit. Nous sommes stoppés.");
+        assertResultRow(result, row++, "18/2/2013 6:18", "-4.800139", "51.383472", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 7:18", "-4.766805", "51.200138", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 7:42", "-4.7168055", "51.133472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "18/2/2013 7:59", "-4.7001386", "51.066803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "18/2/2013 8:0", "-4.7001386", "51.066803", "Recherche (général)", "Shiftage de 8h30 à 10h36J'ai loupé la rencontre avec un objet flottant, voilà le détail: Aux positions 4'42 et 50'53 il y a eut récupération d'une balise 98 et  pose d'une balise 04 sur un radeau (bambou filet) appartenant à un autre armement");
+        assertResultRow(result, row++, "18/2/2013 9:50", "-4.650139", "50.800137", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 10:50", "-4.6001387", "50.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 11:50", "-4.183472", "50.466805", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 12:25", "-4.7168055", "50.383472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "18/2/2013 12:35", "-4.7168055", "50.40014", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "18/2/2013 12:45", "-4.7168055", "50.40014", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 13:50", "-4.5668054", "50.250137", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 14:50", "-4.4668055", "50.08347", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 15:50", "-4.383472", "49.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 16:50", "-4.4168053", "49.73347", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 17:50", "-4.300139", "49.58347", "Recherche (général)", null);
+        assertResultRow(result, row++, "18/2/2013 17:50", "-4.2168055", "49.40014", "Recherche (général)", "Changement d'heure (-1 heure!)");
+        assertResultRow(result, row++, "18/2/2013 18:23", "-4.183472", "49.300137", "Fin de veille", "Nous faisons route toute la nuit seuf si rencontre avec d'autres navires, nous stoppons.");
+        assertResultRow(result, row++, "19/2/2013 5:45", "-3.700139", "48.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 6:31", "-3.6334722", "48.116802", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "19/2/2013 6:35", "-3.6168058", "48.116802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "19/2/2013 6:40", "-3.600139", "48.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 7:40", "-3.5334723", "47.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 7:47", "-3.550139", "47.93347", "Route vers des systèmes observés", "Présence de \"Marsousins\" et de Listao vu aux jumelle avant d'être arrivé sur le système observé, nous reprenons directement notre cap!");
+        assertResultRow(result, row++, "19/2/2013 7:50", "-3.550139", "47.916805", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 8:50", "-3.550139", "47.766804", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 9:17", "-3.4668057", "47.766804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "19/2/2013 9:19", "-3.4668057", "47.766804", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "19/2/2013 9:28", "-3.4668057", "47.766804", "Début de pêche (larguage du skiff)", "Présence du bteau TREVIGNON");
+        assertResultRow(result, row++, "19/2/2013 12:7", "-3.4834723", "47.78347", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "19/2/2013 12:16", "-3.500139", "47.83347", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 12:54", "-3.5668056", "47.73347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "19/2/2013 13:0", "-3.5668056", "47.73347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "19/2/2013 13:20", "-3.5668056", "47.73347", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "19/2/2013 16:0", "-3.5834723", "47.78347", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "19/2/2013 16:1", "-3.5834723", "47.78347", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 16:27", "-3.500139", "47.766804", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "19/2/2013 16:40", "-3.4668057", "47.78347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "19/2/2013 16:41", "-3.4834723", "47.78347", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 16:53", "-3.4834723", "47.83347", "Route vers des systèmes observés", "Vu mattes aux jumelles, direction du système observé puis avant d'y arriver sur le système observé nous avons repris notre cap car c'était des listao!");
+        assertResultRow(result, row++, "19/2/2013 16:54", "-3.4834723", "47.83347", "Recherche (général)", null);
+        assertResultRow(result, row++, "19/2/2013 17:18", "-3.550139", "47.766804", "Route vers des systèmes observés", "Gleurre");
+        assertResultRow(result, row++, "19/2/2013 17:36", "-3.6168058", "47.716805", "Thonier arrivant sur le système détecté", "Gleurre en plus");
+        assertResultRow(result, row++, "19/2/2013 17:40", "-3.6168058", "47.700138", "Début de pêche (larguage du skiff)", "Gleurre en plus");
+        assertResultRow(result, row++, "19/2/2013 21:6", "-3.6168058", "47.766804", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "19/2/2013 21:7", "-3.6168058", "47.766804", "Fin de veille", null);
+        assertResultRow(result, row++, "20/2/2013 5:25", "-3.550139", "47.850136", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 6:25", "-3.5168056", "47.800137", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 6:40", "-3.4668057", "47.78347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "20/2/2013 7:3", "-3.450139", "47.716805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "20/2/2013 7:5", "-3.450139", "47.716805", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 7:45", "-3.3668058", "47.750137", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 8:45", "-3.2168057", "47.700138", "Recherche (général)", "Shiftage de la première calée du 19.02.2013 de 8h à 10h05");
+        assertResultRow(result, row++, "20/2/2013 9:45", "-3.0168056", "47.68347", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 10:45", "-2.8834722", "47.566803", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 11:30", "-2.900139", "47.416805", "Route vers des systèmes observés", "Matte observée, route vers système observé, puis changement de cap avant d'arriver sur le système observé car listao aperçu. Reprenons notre cap sans se rendre sur le système observé.");
+        assertResultRow(result, row++, "20/2/2013 11:32", "-2.900139", "47.416805", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 12:30", "-2.7668056", "47.550137", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 13:30", "-2.750139", "47.750137", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 14:37", "-2.6334722", "47.93347", "Recherche (général)", "Shiftage de la deuxième calée du 19.02.2013 de 14h à 15h30");
+        assertResultRow(result, row++, "20/2/2013 15:37", "-2.650139", "48.133472", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 16:37", "-2.4668057", "48.08347", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 17:37", "-2.3168056", "48.216805", "Recherche (général)", null);
+        assertResultRow(result, row++, "20/2/2013 18:20", "-2.2168057", "48.300137", "Fin de veille", "Stopper pour la nuit à partir de 20h.");
+        assertResultRow(result, row++, "21/2/2013 5:40", "-2.3168056", "48.33347", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 6:40", "-2.2334723", "48.48347", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 7:52", "-2.150139", "48.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 7:58", "-2.150139", "48.700138", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "21/2/2013 8:0", "-2.150139", "48.700138", "Recherche (général)", "shiftage de la 3 ème calée du 19.02.2013");
+        assertResultRow(result, row++, "21/2/2013 9:0", "-2.0334723", "48.866802", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 10:0", "-1.9168056", "49.016804", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 11:0", "-1.7834722", "49.166805", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 12:0", "-1.6501389", "49.266804", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 12:13", "-1.6168056", "49.250137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "21/2/2013 12:41", "-1.6168056", "49.316803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "21/2/2013 12:45", "-1.6168056", "49.316803", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 13:45", "-1.5668055", "49.500137", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 13:58", "-1.5501388", "49.53347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "21/2/2013 14:2", "-1.5501388", "49.53347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "");
+        assertResultRow(result, row++, "21/2/2013 14:5", "-1.5334722", "49.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 15:5", "-1.5834721", "49.65014", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 16:0", "-1.5334722", "49.800137", "Route vers des systèmes observés", "L'épave n'était pas à 1 milles mais plus près, nous l'avons dépassé sans la voir donc nous ne sommes pas aller sur le système observé, de plus aucun oiseaux n'avaient été vu a proximité de l'épave. Nous avons repris directement notre cap.");
+        assertResultRow(result, row++, "21/2/2013 16:2", "-1.5334722", "49.816803", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 17:2", "-1.4334723", "49.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 17:45", "-1.3334723", "50.0", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "21/2/2013 17:50", "-1.3334723", "50.0", "Recherche (général)", null);
+        assertResultRow(result, row++, "21/2/2013 18:11", "-1.3001388", "50.066803", "Fin de veille", "Route toute la nuit.");
+        assertResultRow(result, row++, "22/2/2013 5:22", "-0.3834722", "51.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 5:43", "-0.35013887", "51.950138", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "22/2/2013 5:45", "-0.35013887", "51.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 6:45", "-0.31680554", "52.133472", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 6:47", "-0.31680554", "52.15014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "22/2/2013 7:20", "-0.25013888", "52.23347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "22/2/2013 7:21", "-0.25013888", "52.23347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "YFT de 70 kg environ mélangé avec beaucoup de \"marsouins\" impossible de pêcher.");
+        assertResultRow(result, row++, "22/2/2013 7:32", "-0.23347223", "52.23347", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 7:51", "-0.2001389", "52.300137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "22/2/2013 7:59", "-0.18347223", "52.316803", "Thonier arrivant sur le système détecté", "Albacore de 70 kg environ mélangés avec \"marsouins\" impossible de pêcher!");
+        assertResultRow(result, row++, "22/2/2013 8:0", "-0.18347223", "52.316803", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 8:19", "-0.1501389", "52.366802", "Route vers des systèmes observés", "Vu matte au loin, prenons direction du système observé mais en cours de route les matelots aux jumelles s'apperçoivent qu'il y a des \"marsouins\" avec les YFT, nous ^reprnons notre cap sans nous être rendu sur le système observé");
+        assertResultRow(result, row++, "22/2/2013 8:23", "-0.1501389", "52.366802", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 8:35", "-0.10013889", "52.350136", "Route vers des systèmes observés", "YFT + \"marsouins\", reprise du cap sans nous rendre sur le système observé.");
+        assertResultRow(result, row++, "22/2/2013 8:38", "-0.10013889", "52.350136", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 9:38", "-0.16680557", "52.48347", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 9:50", "-0.18347223", "52.516804", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "22/2/2013 9:53", "-0.18347223", "52.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 10:13", "-0.16680557", "52.58347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "22/2/2013 10:22", "-0.16680557", "52.616802", "Thonier arrivant sur le système détecté", "YFT mélangés avec\"Marsouins\"");
+        assertResultRow(result, row++, "22/2/2013 10:36", "-0.18347223", "52.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 11:21", "-0.1501389", "52.750137", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "22/2/2013 11:25", "-0.1501389", "52.750137", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 12:25", "-0.1501389", "52.93347", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 13:25", "-0.21680556", "53.116802", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 15:4", "-0.26680556", "53.23347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", "Changement d'heur: +1h (heure de l'île maurice, de la réunion et des seychelles!)");
+        assertResultRow(result, row++, "22/2/2013 15:10", "-0.26680556", "53.250137", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 15:13", "-0.26680556", "53.250137", "Route vers des systèmes observés", "YFT + \"Marsouins\" mais vu lors du transit en allant sur le système observé, reprise du cap!");
+        assertResultRow(result, row++, "22/2/2013 15:45", "-0.3001389", "53.350136", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 16:45", "-0.3834722", "53.53347", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 16:57", "-0.3834722", "53.566803", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "22/2/2013 17:0", "-0.40013888", "53.58347", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 17:41", "-0.5501389", "53.566803", "Recherche (général)", "Marsouins observé à 2 mioles mais nous n'allons pas sur le système observé");
+        assertResultRow(result, row++, "22/2/2013 18:24", "-0.6834722", "53.500137", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "22/2/2013 18:25", "-0.6834722", "53.500137", "Recherche (général)", null);
+        assertResultRow(result, row++, "22/2/2013 18:58", "-0.7501389", "53.40014", "Fin de veille", "Route de nuit.");
+        assertResultRow(result, row++, "23/2/2013 6:16", "-2.2668056", "51.18347", "Recherche (général)", null);
+        assertResultRow(result, row++, "23/2/2013 6:53", "-2.3334723", "51.066803", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "23/2/2013 7:4", "-2.350139", "51.03347", "Thonier arrivant sur le système détecté", "Listao + présence d'un cordage pose d'un radeau activité suivante.");
+        assertResultRow(result, row++, "23/2/2013 7:11", "-2.350139", "51.03347", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "23/2/2013 7:25", "-2.350139", "51.03347", "Recherche (général)", null);
+        assertResultRow(result, row++, "23/2/2013 7:35", "-2.3334723", "50.98347", "Route vers des systèmes observés", "volaille apperçu aux jumelles, nous prenons la direction pour en cours de route on observe que ce sont des listao, on reprend notre cap initial sans se rendre sur le système observé.");
+        assertResultRow(result, row++, "23/2/2013 7:43", "-2.3168056", "50.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "23/2/2013 8:41", "-2.2834723", "50.750137", "Route vers des systèmes observés", "vu au sonar!");
+        assertResultRow(result, row++, "23/2/2013 8:50", "-2.2668056", "50.716805", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "23/2/2013 9:18", "-2.2834723", "50.750137", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "23/2/2013 12:10", "-2.2834723", "50.73347", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "23/2/2013 12:17", "-2.300139", "50.716805", "Recherche (général)", null);
+        assertResultRow(result, row++, "23/2/2013 12:36", "-2.2668056", "50.65014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "23/2/2013 12:40", "-2.250139", "50.65014", "Thonier arrivant sur le système détecté", "Plusieurs bancs plus ou moins gros!");
+        assertResultRow(result, row++, "23/2/2013 13:1", "-2.250139", "50.633472", "Route vers des systèmes observés", "Poissons allant trop vite re tour sur système observé précédément");
+        assertResultRow(result, row++, "23/2/2013 13:8", "-2.250139", "50.616802", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "23/2/2013 13:28", "-2.2334723", "50.65014", "Thonier arrivant sur le système détecté", "Petit banc et dispérsé");
+        assertResultRow(result, row++, "23/2/2013 13:30", "-2.2334723", "50.65014", "Recherche (général)", "");
+        assertResultRow(result, row++, "23/2/2013 13:45", "-2.2334723", "50.68347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "23/2/2013 13:47", "-2.2334723", "50.68347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "23/2/2013 13:56", "-2.2334723", "50.68347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "23/2/2013 14:6", "-2.2334723", "50.633472", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "23/2/2013 14:9", "-2.250139", "50.633472", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "23/2/2013 16:5", "-2.2668056", "50.616802", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "23/2/2013 16:6", "-2.2668056", "50.616802", "Recherche (général)", "");
+        assertResultRow(result, row++, "23/2/2013 16:34", "-2.2668056", "50.716805", "Route vers des systèmes observés", "En train de mesurer lorsque le système a été apperçu aux jumelles!");
+        assertResultRow(result, row++, "23/2/2013 16:36", "-2.2668056", "50.716805", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "23/2/2013 16:44", "-2.2668056", "50.716805", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "23/2/2013 19:1", "-2.300139", "50.68347", "Fin de pêche (remontée du skiff)", "Changement d'heure - 1h");
+        assertResultRow(result, row++, "23/2/2013 19:3", "-2.300139", "50.68347", "Fin de veille", null);
+        assertResultRow(result, row++, "24/2/2013 5:27", "-2.350139", "50.616802", "Recherche (général)", "shiftage du 23.02.2013 de 5h35 à 12h33 puis après calée!");
+        assertResultRow(result, row++, "24/2/2013 6:27", "-2.4168057", "50.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 7:27", "-2.5168056", "50.716805", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 8:26", "-2.3168056", "50.716805", "Route vers des systèmes observés", "");
+        assertResultRow(result, row++, "24/2/2013 8:42", "-2.2668056", "50.73347", "Thonier arrivant sur le système détecté", "Mélangé avec \"Marsouins\" (je pense des dauphins longirostre).");
+        assertResultRow(result, row++, "24/2/2013 8:48", "-2.2668056", "50.716805", "Route vers des systèmes observés", "Le poisson se déplace trop vite, nous n'allons pas sur le système observé");
+        assertResultRow(result, row++, "24/2/2013 9:0", "-2.250139", "50.750137", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 9:45", "-2.250139", "50.716805", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "24/2/2013 9:59", "-2.2834723", "50.68347", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "24/2/2013 10:0", "-2.2834723", "50.68347", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 11:0", "-2.4834723", "50.68347", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 11:27", "-2.5834723", "50.716805", "Route vers des systèmes observés", "Dauphins longirostre. On fait se séparer les thons et les dauphins en suivant ces derniers.\n");
+        assertResultRow(result, row++, "24/2/2013 11:30", "-2.5834723", "50.716805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "24/2/2013 11:57", "-2.600139", "50.716805", "Route vers des systèmes observés", "Arrivés sur le système à 12h03 (oublies de le noter sur le formulaire route!)");
+        assertResultRow(result, row++, "24/2/2013 12:33", "-2.6334722", "50.766804", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "24/2/2013 15:5", "-2.6334722", "50.750137", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "24/2/2013 15:8", "-2.650139", "50.750137", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 15:19", "-2.6168058", "50.766804", "Route vers des systèmes observés", "2 mattes");
+        assertResultRow(result, row++, "24/2/2013 15:32", "-2.5834723", "50.800137", "Thonier arrivant sur le système détecté", "Mélange SKJ + YFT.");
+        assertResultRow(result, row++, "24/2/2013 15:34", "-2.5834723", "50.800137", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 15:51", "-2.5334723", "50.83347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "24/2/2013 15:58", "-2.5168056", "50.816803", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "24/2/2013 16:2", "-2.5168056", "50.83347", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 16:58", "-2.3334723", "50.73347", "Route vers des systèmes observés", "\"Marsouins\" apperçu après avoir pris la direction du système observé, reprise du cap sans se rendre sur le système.");
+        assertResultRow(result, row++, "24/2/2013 17:0", "-2.3334723", "50.73347", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 18:0", "-2.4834723", "50.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "24/2/2013 18:12", "-2.5168056", "50.616802", "Fin de veille", "Stopper pour la nuit.");
+        assertResultRow(result, row++, "25/2/2013 5:26", "-2.7334723", "50.500137", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 5:52", "-2.7168057", "50.53347", "Route vers des systèmes observés", "Balbya de \"Marsouins\", reprise du cap sans s'être rendu sur le système observé.");
+        assertResultRow(result, row++, "25/2/2013 6:12", "-2.7668056", "50.58347", "Recherche (général)", "Shiftage du 23 et 24.02.2013 jusqu'à 14h20");
+        assertResultRow(result, row++, "25/2/2013 6:24", "-2.8168056", "50.58347", "Route vers des systèmes observés", "Banc trop petit et inintéressant, recherche général sans se rendre sur le système observé.");
+        assertResultRow(result, row++, "25/2/2013 6:30", "-2.8168056", "50.600136", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 6:42", "-2.800139", "50.633472", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "25/2/2013 6:46", "-2.800139", "50.65014", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "25/2/2013 6:55", "-2.800139", "50.633472", "Début de pêche (larguage du skiff)", null);
+        assertResultRow(result, row++, "25/2/2013 9:35", "-2.8334723", "50.633472", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "25/2/2013 9:36", "-2.8334723", "50.633472", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 10:36", "-2.9668057", "50.700138", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 11:30", "-3.1668057", "50.65014", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 12:30", "-3.400139", "50.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 12:35", "-3.4168057", "50.600136", "Route vers des systèmes observés", "\"Marsouins\" vu en coursz de route, reprise directement du cap, sans se rendre sur le système observé");
+        assertResultRow(result, row++, "25/2/2013 12:43", "-3.4334724", "50.616802", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 13:43", "-3.5334723", "50.816803", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 14:31", "-3.5834723", "50.90014", "Route vers des systèmes observés", "Fin du shiftage du 23 et 24.02.2013 à 14h 20");
+        assertResultRow(result, row++, "25/2/2013 14:40", "-3.5668056", "50.916805", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "25/2/2013 14:46", "-3.550139", "50.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 15:50", "-3.6668057", "51.08347", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 16:17", "-3.5668056", "51.050137", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "25/2/2013 16:22", "-3.5668056", "51.050137", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "25/2/2013 16:23", "-3.550139", "51.050137", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 17:26", "-3.5334723", "51.266804", "Opération sur objet flottant (visite, pose, modification, récupération ou pêche)", null);
+        assertResultRow(result, row++, "25/2/2013 17:31", "-3.5334723", "51.28347", "Recherche (général)", null);
+        assertResultRow(result, row++, "25/2/2013 17:57", "-3.5668056", "51.33347", "Fin de veille", null);
+        assertResultRow(result, row++, "26/2/2013 5:50", "-4.3168054", "53.0", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "26/2/2013 6:3", "-4.300139", "52.98347", "Début de pêche (larguage du skiff)", "Sachant que nous débarquons le lendemain aux Seychelles, il n'y aura pas de shiftage, les poissons restent en saumure!");
+        assertResultRow(result, row++, "26/2/2013 8:45", "-4.300139", "52.966805", "Fin de pêche (remontée du skiff)", null);
+        assertResultRow(result, row++, "26/2/2013 8:48", "-4.300139", "52.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "26/2/2013 9:42", "-4.383472", "53.15014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "26/2/2013 9:53", "-4.3501387", "53.166805", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "26/2/2013 10:0", "-4.3501387", "53.18347", "Recherche (général)", null);
+        assertResultRow(result, row++, "26/2/2013 10:29", "-4.383472", "53.23347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "26/2/2013 10:35", "-4.433472", "53.23347", "Thonier arrivant sur le système détecté", "Trombe d'eau apparçu à 5 milles");
+        assertResultRow(result, row++, "26/2/2013 10:37", "-4.4501386", "53.23347", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "26/2/2013 11:30", "-4.533472", "53.40014", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "26/2/2013 12:4", "-4.6001387", "53.366802", "Thonier arrivant sur le système détecté", "");
+        assertResultRow(result, row++, "26/2/2013 12:7", "-4.6001387", "53.383472", "Recherche (général)", null);
+        assertResultRow(result, row++, "26/2/2013 13:7", "-4.6668053", "53.58347", "Recherche (général)", "Shiftage du 25.02.2013 de 13h à 16h35");
+        assertResultRow(result, row++, "26/2/2013 14:7", "-4.783472", "53.766804", "Recherche (général)", null);
+        assertResultRow(result, row++, "26/2/2013 15:20", "-4.9668055", "53.966805", "Recherche (général)", null);
+        assertResultRow(result, row++, "26/2/2013 16:35", "-5.133472", "54.200138", "Recherche (général)", null);
+        assertResultRow(result, row++, "26/2/2013 17:35", "-5.2501388", "54.40014", "Recherche (général)", null);
+        assertResultRow(result, row++, "26/2/2013 18:22", "-5.3168054", "54.566803", "Fin de veille", "Stopper pour la nuit.");
+        assertResultRow(result, row++, "27/2/2013 6:36", "-5.400139", "54.90014", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/2/2013 7:36", "-5.4168053", "55.133472", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/2/2013 7:44", "-5.400139", "55.166805", "Route vers des systèmes observés", null);
+        assertResultRow(result, row++, "27/2/2013 7:49", "-5.400139", "55.18347", "Thonier arrivant sur le système détecté", null);
+        assertResultRow(result, row++, "27/2/2013 7:52", "-5.400139", "55.18347", "Recherche (général)", null);
+        assertResultRow(result, row++, "27/2/2013 8:40", "-5.283472", "55.133472", "Fin de veille", null);
+        assertResultRow(result, row++, "27/2/2013 8:42", "-5.283472", "55.133472", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "27/2/2013 9:42", "-5.150139", "55.18347", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "27/2/2013 10:42", "-5.150139", "55.316803", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "27/2/2013 11:25", "-4.9501386", "55.43347", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "27/2/2013 12:25", "-4.8501387", "55.566803", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "27/2/2013 13:25", "-4.7001386", "55.600136", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "27/2/2013 14:25", "-4.5834723", "55.58347", "Transit (route sans recherche)", null);
+        assertResultRow(result, row++, "27/2/2013 15:36", "-4.5834723", "55.48347", "Autres (à préciser dans les notes)", "En attente pour rentrer au port avec le pilote");
+        assertResultRow(result, row++, "27/2/2013 16:22", "-4.6168056", "55.450138", "Au port", "Fin de la première partie de calée.Loch totale marée: 5953.03");
+
+    }
+}
\ No newline at end of file
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDailySetAndCatchTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDailySetAndCatchTest.java
new file mode 100644
index 0000000..0b07b83
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDailySetAndCatchTest.java
@@ -0,0 +1,103 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+/**
+ * Pour tester le report {@code dailySetAndCapture}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportDailySetAndCatchTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected String getReportId() {
+        return "dailySetAndCatch";
+    }
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Nombre de calées et captures journalières d'une marée",
+                "Afficher le nombre de calées et les captures journalières d’une calée"
+        );
+
+        assertReportDimension(
+                report,
+                -1,
+                3,
+                new String[]{"Jour observation",
+                             "Nombre de calées",
+                             "Captures thon"
+                },
+                null
+        );
+
+        assertReportNbRequests(report, 1);
+
+        ReportRequest[] requests = report.getRequests();
+        ReportRequest request = requests[0];
+
+        assertReportRequestDimension(
+                request,
+                ReportRequest.RequestLayout.row,
+                0,
+                0
+        );
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 3, 20, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "30/1/2013", "1", "20.0");
+        assertResultRow(result, row++, "1/2/2013", "2", null);
+        assertResultRow(result, row++, "2/2/2013", "1", null);
+        assertResultRow(result, row++, "3/2/2013", "2", null);
+        assertResultRow(result, row++, "4/2/2013", "1", null);
+        assertResultRow(result, row++, "5/2/2013", "1", "7.8");
+        assertResultRow(result, row++, "6/2/2013", "2", "36.0");
+        assertResultRow(result, row++, "7/2/2013", "2", "27.0");
+        assertResultRow(result, row++, "8/2/2013", "3", "14.0");
+        assertResultRow(result, row++, "9/2/2013", "3", "46.0");
+        assertResultRow(result, row++, "10/2/2013", "1", "7.0");
+        assertResultRow(result, row++, "11/2/2013", "3", "30.41");
+        assertResultRow(result, row++, "15/2/2013", "1", "0.07");
+        assertResultRow(result, row++, "16/2/2013", "1", "11.005");
+        assertResultRow(result, row++, "17/2/2013", "2", "40.7");
+        assertResultRow(result, row++, "19/2/2013", "3", "134.701");
+        assertResultRow(result, row++, "23/2/2013", "3", "197.44");
+        assertResultRow(result, row++, "24/2/2013", "1", "12.0");
+        assertResultRow(result, row++, "25/2/2013", "1", "48.075");
+        assertResultRow(result, row++, "26/2/2013", "1", "13.7");
+
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDcpUsageTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDcpUsageTest.java
new file mode 100644
index 0000000..530d467
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportDcpUsageTest.java
@@ -0,0 +1,142 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+/**
+ * Pour tester le report {@code dcpUsage}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportDcpUsageTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected String getReportId() {
+        return "dcpUsage";
+    }
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Utilisation des DCP",
+                "Tableau récapitulatif du nombre de DCP visités selon l’action effectuée (visites avec et sans pêche, mis à l’eau, récuperation), et tortues observées"
+        );
+
+        assertReportDimension(
+                report,
+                -1,
+                7,
+                new String[]{"Type de DCP (Tableau 8)",
+                        "Nombre visités",
+                        "Nombre pêchés",
+                        "Nombre mis à l’eau seuls",
+                        "Nombre renforcés par radeau balisé",
+                        "Récupéré sans pêche",
+                        "Nombre de tortues associées"
+                },
+                null
+        );
+
+        assertReportNbRequests(report, 7);
+
+        ReportRequest[] requests = report.getRequests();
+        ReportRequest request;
+
+        request = requests[0];
+        assertReportRequestDimension(
+                request,
+                ReportRequest.RequestLayout.row,
+                0,
+                0
+        );
+
+        request = requests[1];
+        assertReportRequestDimension(
+                request,
+                ReportRequest.RequestLayout.row,
+                1,
+                0
+        );
+
+        request = requests[2];
+        assertReportRequestDimension(
+                request,
+                ReportRequest.RequestLayout.row,
+                2,
+                0
+        );
+        request = requests[3];
+        assertReportRequestDimension(
+                request,
+                ReportRequest.RequestLayout.row,
+                3,
+                0
+        );
+
+        request = requests[4];
+        assertReportRequestDimension(
+                request,
+                ReportRequest.RequestLayout.row,
+                4,
+                0
+        );
+        request = requests[5];
+        assertReportRequestDimension(
+                request,
+                ReportRequest.RequestLayout.row,
+                5,
+                0
+        );
+        request = requests[6];
+        assertReportRequestDimension(
+                request,
+                ReportRequest.RequestLayout.row,
+                6,
+                0
+        );
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+
+        // 4 DCP dans une maree
+        assertResultDimension(result, 7, 8, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "10 - Caisse ou grosse planche", "1", "0", "0", "0", "0", null);
+        assertResultRow(result, row++, "11 - Cordage, câble", "2", "0", "0", "0", "0", null);
+        assertResultRow(result, row++, "13 - Objet de plastique (à préciser dans les notes)", "2", "0", "0", "0", "0", null);
+        assertResultRow(result, row++, "14 - Un des antérieurs (du 10 à 13) balisé", "1", "0", "0", "0", "0", null);
+        assertResultRow(result, row++, "16 - Radeau ou bouée en dérive", "2", "0", "0", "0", "0", null);
+        assertResultRow(result, row++, "3 - Arbre (ou branche)", "3", "0", "0", "0", "0", null);
+        assertResultRow(result, row++, "6 - Radeau balisé en dérive (bambou et filet)", "19", "6", "13", "0", "0", null);
+        assertResultRow(result, row++, "99 - Autre (à préciser dans les notes)", "2", "0", "0", "0", "0", null);
+
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociation2Test.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociation2Test.java
new file mode 100644
index 0000000..18c1b48
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociation2Test.java
@@ -0,0 +1,50 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import org.junit.Ignore;
+
+/**
+ * Pour tester le report {@code dailySetAndCapture}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+@Ignore
+public class ReportSetByAssociation2Test extends ReportSetByAssociationTest {
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 5, 3, 0, 0);
+
+        // les 8 sets qu test 1
+        // 10 calées representant chaque cas (set +, -) sur les 4 types
+        // d'association (le cas du BL sans 11 est traité 2 fois : une fois
+        // sans SO et une fois avec un BL spécifié)
+        assertResultRow(result, 0, "3", "2", "2", "2", "9");
+        assertResultRow(result, 1, "3", "2", "2", "2", "9");
+        assertResultRow(result, 2, "6", "4", "4", "4", "18");
+
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociationTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociationTest.java
new file mode 100644
index 0000000..d29f976
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportSetByAssociationTest.java
@@ -0,0 +1,128 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+/**
+ * Pour tester le report {@code setByAssociation}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportSetByAssociationTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected String getReportId() {
+        return "setByAssociation";
+    }
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Nombre de calées selon le type d’association",
+                "Afficher la répartitions des calées selon le type d’association l’issue du coup. Les coups sur BL baleine et BO requin-baleine sont spécifiés."
+        );
+
+        assertReportDimension(
+                report,
+                3,
+                5,
+                new String[]{"BL sans baleine",
+                             "BL avec baleine",
+                             "BO avec requin-baleine",
+                             "BO sans requin-baleine",
+                             "Total"
+                },
+                new String[]{"Coups positifs", "Coups nuls", "Total"}
+        );
+
+        assertReportNbRequests(report, 8);
+
+        ReportRequest[] requests = report.getRequests();
+
+        assertReportRequestDimension(
+                requests[0],
+                ReportRequest.RequestLayout.column,
+                0,
+                0
+        );
+        assertReportRequestDimension(
+                requests[1],
+                ReportRequest.RequestLayout.column,
+                0,
+                1
+        );
+        assertReportRequestDimension(
+                requests[2],
+                ReportRequest.RequestLayout.column,
+                1,
+                0
+        );
+        assertReportRequestDimension(
+                requests[3],
+                ReportRequest.RequestLayout.column,
+                1,
+                1
+        );
+        assertReportRequestDimension(
+                requests[4],
+                ReportRequest.RequestLayout.column,
+                2,
+                0
+        );
+        assertReportRequestDimension(
+                requests[5],
+                ReportRequest.RequestLayout.column,
+                2,
+                1
+        );
+        assertReportRequestDimension(
+                requests[6],
+                ReportRequest.RequestLayout.column,
+                3,
+                0
+        );
+        assertReportRequestDimension(
+                requests[7],
+                ReportRequest.RequestLayout.column,
+                3,
+                1
+        );
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 5, 3, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "19" ,"1" ,"0" ,"6" ,"26");
+        assertResultRow(result, row++, "9", "0", "0", "0", "9");
+        assertResultRow(result, row++, "28" ,"1" ,"0" ,"6" ,"35");
+
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetCatchByAssociationTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetCatchByAssociationTest.java
new file mode 100644
index 0000000..e75dd69
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetCatchByAssociationTest.java
@@ -0,0 +1,116 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+/**
+ * Test le report {@code targetCatchByAssociation}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportTargetCatchByAssociationTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected String getReportId() {
+        return "targetCatchByAssociation";
+    }
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Capture de thon selon le type d'association (en t)",
+                "Afficher la répartitions des captures de thons selon le type d'association"
+        );
+
+        assertReportDimension(
+                report,
+                5,
+                7,
+                new String[]{"YFT",
+                             "SKJ",
+                             "BET",
+                             "LTA",
+                             "FRI",
+                             "Autres",
+                             "Total"
+                },
+                new String[]{"BL sans baleine",
+                             "BL avec baleine",
+                             "BO avec requin-baleine",
+                             "BO sans requin-baleine",
+                             "Total"
+                }
+        );
+
+        assertReportNbRequests(report, 4);
+
+        ReportRequest[] requests = report.getRequests();
+
+        assertReportRequestDimension(
+                requests[0],
+                ReportRequest.RequestLayout.row,
+                0,
+                0
+        );
+
+        assertReportRequestDimension(
+                requests[1],
+                ReportRequest.RequestLayout.row,
+                0,
+                1
+        );
+
+        assertReportRequestDimension(
+                requests[2],
+                ReportRequest.RequestLayout.row,
+                0,
+                2
+        );
+
+        assertReportRequestDimension(
+                requests[3],
+                ReportRequest.RequestLayout.row,
+                0,
+                3
+        );
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 7, 5, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "455.2", "0.0", "40.0", "0.0", "0.0", "2.2", "497.4");
+        assertResultRow(result, row++, "26.0", "0.0", "0.0", "0.0", "0.0", "0.0", "26.0");
+        assertResultRow(result, row++, null, null, null, null, null, null, "0.0");
+        assertResultRow(result, row++, "32.0", "71.0", "10.0", "0.0", "0.0", "0.0", "113.0");
+        assertResultRow(result, row++, "513.2", "71.0", "50.0", "0.0", "0.0", "2.2", "636.4");
+
+    }
+}
diff --git a/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetDiscardedByAssociationTest.java b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetDiscardedByAssociationTest.java
new file mode 100644
index 0000000..7d1ca56
--- /dev/null
+++ b/observe-services-topia/src/test/java/fr/ird/observe/services/service/actions/report/ReportTargetDiscardedByAssociationTest.java
@@ -0,0 +1,116 @@
+/*
+ * #%L
+ * ObServe :: Business
+ * %%
+ * Copyright (C) 2008 - 2010 IRD, Codelutin, Tony Chemit
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+package fr.ird.observe.services.service.actions.report;
+
+import fr.ird.observe.services.service.actions.report.model.DataMatrix;
+import fr.ird.observe.services.service.actions.report.model.Report;
+import fr.ird.observe.services.service.actions.report.model.ReportRequest;
+import org.junit.Assert;
+
+/**
+ * Test le report {@code targetDiscardedByAssociation}.
+ *
+ * @author Tony Chemit - chemit@codelutin.com
+ * @since 1.9
+ */
+public class ReportTargetDiscardedByAssociationTest extends AbstractReportServiceTopiaTest {
+
+    @Override
+    protected String getReportId() {
+        return "targetDiscardedByAssociation";
+    }
+
+    @Override
+    protected void testReportSyntax(Report report) {
+        Assert.assertNotNull(report);
+        assertReportName(
+                report,
+                "Rejets de thons selon le type d’association (en t)",
+                "Afficher la répartitions des rejets de thons selon le type d'association"
+        );
+
+        assertReportDimension(
+                report,
+                5,
+                7,
+                new String[]{"YFT",
+                             "SKJ",
+                             "BET",
+                             "LTA",
+                             "FRI",
+                             "Autres",
+                             "Total"
+                },
+                new String[]{"BL sans baleine",
+                             "BL avec baleine",
+                             "BO avec requin-baleine",
+                             "BO sans requin-baleine",
+                             "Total"
+                }
+        );
+
+        assertReportNbRequests(report, 4);
+
+        ReportRequest[] requests = report.getRequests();
+
+        assertReportRequestDimension(
+                requests[0],
+                ReportRequest.RequestLayout.row,
+                0,
+                0
+        );
+
+        assertReportRequestDimension(
+                requests[1],
+                ReportRequest.RequestLayout.row,
+                0,
+                1
+        );
+
+        assertReportRequestDimension(
+                requests[2],
+                ReportRequest.RequestLayout.row,
+                0,
+                2
+        );
+
+        assertReportRequestDimension(
+                requests[3],
+                ReportRequest.RequestLayout.row,
+                0,
+                3
+        );
+    }
+
+    @Override
+    protected void testReportResult(DataMatrix result) {
+        assertResultDimension(result, 7, 5, 0, 0);
+
+        int row = 0;
+        assertResultRow(result, row++, "0.841", "0.0", "0.29", "0.0", "0.08", "0.01", "1.221");
+        assertResultRow(result, row++, null, null, null, null, null, null, "0.0");
+        assertResultRow(result, row++, null, null, null, null, null, null, "0.0");
+        assertResultRow(result, row++, "2.775", "5.405", "0.0", "0.0", "0.0", "0.1", "8.28");
+        assertResultRow(result, row++, "3.6159999999999997", "5.405", "0.29", "0.0", "0.08", "0.11", "9.501");
+
+    }
+}

-- 
To stop receiving notification emails like this one, please contact
codelutin.com SCM administrator <admin+scm@list.forge.codelutin.com>.

    

[Observe-commits] 02/03: implantation du service de generation des rapport + test (refs #7498)

codelutin.com scm