test en cours, pas fini

src/impl/Afficheur.java

@@ -3,11 +3,13 @@ package impl;
 import interfaces.CapteurAsync;
 import interfaces.ObserverdeCapteur;
 
+import java.util.ArrayList;
 import java.util.Random;
 import java.util.concurrent.Future;
 
 public class Afficheur implements ObserverdeCapteur {
     private int id= new Random().nextInt(100);
+    public ArrayList<Integer> vals = new ArrayList();
 
     public Afficheur() {}
 
@@ -22,6 +24,7 @@ public class Afficheur implements ObserverdeCapteur {
             Future<Integer> futureValue= capteurAsync.getValue();
             Integer value=futureValue.get();
             System.out.println("Afficheur " + id+", value: "+ value);
+            vals.add(value);
         }catch(Exception e){
             //TODO
             e.printStackTrace();

src/impl/DiffusionAtomique.java

@@ -36,6 +36,6 @@ public class DiffusionAtomique implements AlgoDiffusion {
                 e.printStackTrace();
             }
         }
-        capteur.unlock(); //TODO
+        capteur.unlock();
     }
 }

src/impl/Scheduler.java

@@ -6,7 +6,7 @@ public class Scheduler {
     private final ScheduledExecutorService scheduler;
 
     public Scheduler(int nbCanaux) {
-        int nThread = 2+2*nbCanaux;
+        int nThread = 20+2*nbCanaux;
         scheduler = Executors.newScheduledThreadPool(nThread);
     }
 

src/test/Test.java

@@ -0,0 +1,104 @@
+package test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import impl.Afficheur;
+import impl.Canal;
+import impl.CapteurImpl;
+import impl.DiffusionAtomique;
+import impl.Scheduler;
+
+public class Test {
+
+    static int NB_CANAUX = 3;
+
+    public static void main(String[] argv){
+        //DiffusionSequencielle algoSeq = new DiffusionSequencielle;
+        //DiffusionEpoque algoEpoque = new DiffusionEpoque();
+
+        //test : génère un résultat
+        try {
+            List<Integer>[] rAtom = testAtom();
+            System.out.println("\noracle:\n");
+            Boolean r = oracleAtom(rAtom);
+            System.out.println("Test : " + r);
+
+        } catch (Exception e) {
+            // TODO: handle exception
+        }
+
+        // oracle vérifit le résultat
+
+    }
+
+    private static List<Integer>[] testAtom() throws InterruptedException{
+
+        ArrayList<Integer>[] r = new ArrayList[NB_CANAUX];
+        for(int i = 0; i<NB_CANAUX; i++){
+            r[i] = new ArrayList<Integer>();
+        }
+
+        Afficheur[] a = new Afficheur[NB_CANAUX];
+
+        Scheduler scheduler = new Scheduler(NB_CANAUX);
+        CapteurImpl c = new CapteurImpl();
+
+        DiffusionAtomique algo = new DiffusionAtomique();
+        algo.capteur = c;
+        c.setAlgoDiffusion(algo);
+
+        for(int i = 0; i<NB_CANAUX; i++){
+            Afficheur afficheur = new Afficheur();
+            afficheur.setId(i);
+            a[i] = afficheur;
+            Canal canal = new Canal(c, scheduler, afficheur);
+            c.attach(canal);
+        }
+         
+        ScheduledExecutorService clock =  scheduler.getScheculer();
+        clock.scheduleAtFixedRate(() -> c.tick(), 0, 500, TimeUnit.MILLISECONDS);
+
+        Thread.sleep(5000);
+
+        clock.close();
+
+        Thread.sleep(1500);
+        
+        for(int i = 0; i<NB_CANAUX; i++){
+            r[i] = a[i].vals;
+            System.out.println("\n"+a[i].vals.size());
+            for(int j = 0; j<r[i].size(); j ++){
+                 System.out.print(r[i].get(j) + "-");
+            }
+        }
+
+
+        return r;
+    }
+
+    private static boolean oracleAtom(List<Integer>[] resultats){
+        boolean r = true;
+        int testSize = -1;
+        for(int i = 0; i< NB_CANAUX && r; i++){
+
+            if(testSize!=-1) {
+                r = r && resultats[i].size() == testSize;
+            }
+            else {
+                testSize = resultats[i].size();
+            }
+            int valTest = 1;
+            for(int j = 0; j< resultats[i].size() && r; j++){
+                System.out.print(resultats[i].get(j) + " - ");
+                r = r && resultats[i].get(j)==valTest;
+                valTest++;
+            }
+            System.out.println(resultats[i].size()+"---- ");
+        }
+        return r;
+    }
+
+}