correction

src/main/java/fr/univamu/sorting/InsertionSort.java

+package fr.univamu.sorting;
+
+public class InsertionSort<T extends Comparable<T>> implements Sorter<T> {
+    private Sortable<T> sortable;
+
+    public InsertionSort(Sortable<T> sortable) {
+        this.sortable = sortable;
+    }
+
+    @Override
+    public void sort() {
+        insertionSort(sortable);
+    }
+    private void insertionSort(Sortable<T> sortable){
+
+        int n = sortable.size();
+
+        for (int i = 1; i < n; ++i) {
+            T key = sortable.get(i);
+            int j = i - 1;
+
+            while (j >= 0 && sortable.compare(j, key) > 0) {
+                sortable.Swap(j + 1, j);
+                j = j - 1;
+            }
+
+            sortable.set(j + 1, key);
+        }
+    }
+}
\ No newline at end of file

src/main/java/fr/univamu/sorting/Sort.java

 package fr.univamu.sorting;
 
-public class Sort {
+public class Sort<T extends Comparable<T>> {
+    private Sortable<T> sortable;
+    public Sort(Sortable<T> sortable){
+        this.sortable = sortable;
+    }
     public void sort(){
-        bubbleSort();
+        bubbleSort(sortable);
     }
-    public void bubbleSort(){
+    public void bubbleSort(Sortable<T> sortable){
 
-        for( int i=0; i< data.size()-1; i++){
-            for(int j=0 ; j< data.size()-1-i; j++){
-                if(compare(j,j+1)>0){
-                    Swap(j,j+1);
+        for( int i=0; i< sortable.size()-1; i++){
+            for(int j=0 ; j< sortable.size()-1-i; j++){
+                if(sortable.compare(j,j+1)>0){
+                    sortable.Swap(j,j+1);
                 }
             }
         }

src/main/java/fr/univamu/sorting/Sortable.java

+package fr.univamu.sorting;
+
+import java.util.List;
+
+public interface Sortable<T extends Comparable<T>> {
+    void Swap(int index1, int index2);
+    int compare(int index1, int index2);
+    int size();
+    T get(int index);
+    void set(int index, T value);
+
+}

src/main/java/fr/univamu/sorting/SortableIntArray.java

 package fr.univamu.sorting;
 
 import java.util.List;
-
-public class SortableIntArray {
-    private int[]data;
-    public SortableIntArray(int [] data){
+public class SortableIntArray<T extends Comparable> implements Sortable<T> {
+    private T[]data;
+    public SortableIntArray(T [] data){
         this.data = data;
     }
 
+
     public void Swap (int index1, int index2){
-        Integer x = data[index1];
+        T x = data[index1];
         data[index1] = data[index2];
         data[index2]= x;
     }
 
     public int compare(int index1, int index2){
-        return data[index1]- data[index2];
+        return data[index1].compareTo(data[index2]);
     }
 
     public int size() {
         return data.length;
     }
+
+    @Override
+    public T get(int index) {
+        return data[index];
+    }
 }

src/main/java/fr/univamu/sorting/SortableIntList.java

@@ -2,27 +2,31 @@ package fr.univamu.sorting;
 
 import java.util.List;
 
-public class SortableIntList {
-    private List<Integer> data;
-    public SortableIntList(List<Integer> data){
+public class SortableIntList<T extends Comparable<T>> implements Sortable<T> {
+    private List<T> data;
+    public SortableIntList(List<T> data){
         this.data = data;
     }
 
     public void Swap (int index1, int index2){
-        Integer x = data.get(index1);
+        T x = data.get(index1);
         data.set(index1, data.get(index2));
         data.set(index2, x);
     }
 
     public int compare(int index1, int index2){
-        return data.get(index1)- data.get(index2);
+        return data.get(index1).compareTo(data.get(index2));
     }
 
     public int size(){
         return data.size();
     }
-    public int get(int index){
-        return data.get(index);
+    public T get(int index){
+        return (T) data.get(index);
+    }
+
+    public void set(int index, T value){
+        data.set(index, value);
     }
 
     public void sort(){

src/main/java/fr/univamu/sorting/Sorter.java

+package fr.univamu.sorting;
+
+public interface Sorter<T extends Comparable<T>> {
+    void sort();
+}

src/test/java/fr/univamu/sorting/ListSortTest.java

@@ -7,12 +7,16 @@ import static fr.univamu.sorting.IntLists.*;
 import static org.assertj.core.api.Assertions.assertThat;
 
 class ListSortTest {
+  List<Integer> values = IntLists.shuffledRange(1,100);
+  Sortable <Integer> sortableValues = new SortableIntList<>(values);
+  Sort <Integer> sorter = new Sort<>(sortableValues);
 
 
 
   @Test
   void testSort() {
-
+    sorter.sort();
+    assertThat(values).isEqualTo(IntLists.range(1,100));
   }
 
 }
\ No newline at end of file