Inital commit - Fin du tp

src/main/java/AsciiStringFilter.java

+import java.util.ArrayList;
+import java.util.List;
+
+public class AsciiStringFilter implements StringFilter{
+
+    @Override
+    public String filter(String string) {
+        StringBuilder return_string = new StringBuilder();
+        for (char word : string.toCharArray()) {
+            if ((int) word < 128) {
+                return_string.append(word);
+            }
+        }
+        return return_string.toString();
+    }
+
+    @Override
+    public String[] filter(String[] strings, StringFilter filters) {
+        if (strings == null || filters == null) {
+            throw new IllegalArgumentException("Strings array and filter must not be null");
+        }
+
+        List<String> filteredStrings = new ArrayList<>();
+
+        for (String str : strings) {
+            filteredStrings.add(filters.filter(str));
+        }
+
+        return filteredStrings.toArray(new String[0]);
+    }
+}

src/main/java/CompositeStringFilter.java

+import java.util.ArrayList;
+import java.util.List;
+
+public class CompositeStringFilter implements StringFilter{
+
+    private final StringFilter[] filters;
+
+    public CompositeStringFilter(StringFilter[] filters) {
+        this.filters = filters;
+    }
+
+    @Override
+    public String filter(String string) {
+        String filteredString = string;
+
+        // Apply each filter successively
+        for (StringFilter filter : filters) {
+            filteredString = filter.filter(filteredString);
+        }
+
+        return filteredString;
+    }
+
+    @Override
+    public String[] filter(String[] strings, StringFilter filters) {
+        if (strings == null || filters == null) {
+            throw new IllegalArgumentException("Strings array and filter must not be null");
+        }
+
+        List<String> filteredStrings = new ArrayList<>();
+
+        for (String str : strings) {
+            filteredStrings.add(filters.filter(str));
+        }
+
+        return filteredStrings.toArray(new String[0]);
+    }
+}

src/main/java/LowerCaseStringFilter.java

+import java.util.ArrayList;
+import java.util.List;
+
+public class LowerCaseStringFilter implements StringFilter{
+    @Override
+    public String filter(String string) {
+        return string.toLowerCase();
+    }
+
+    @Override
+    public String[] filter(String[] strings, StringFilter filters) {
+        if (strings == null || filters == null) {
+            throw new IllegalArgumentException("Strings array and filter must not be null");
+        }
+
+        List<String> filteredStrings = new ArrayList<>();
+
+        for (String str : strings) {
+            filteredStrings.add(filters.filter(str));
+        }
+
+        return filteredStrings.toArray(new String[0]);
+    }
+}

src/main/java/PostfixStringFilter.java

+import java.util.ArrayList;
+import java.util.List;
+
+public class PostfixStringFilter implements StringFilter{
+
+    private final int n;
+
+    public PostfixStringFilter(int n) {
+        this.n = n;
+    }
+
+    @Override
+    public String filter(String string) {
+        return string.substring(this.n);
+    }
+
+    @Override
+    public String[] filter(String[] strings, StringFilter filters) {
+        if (strings == null || filters == null) {
+            throw new IllegalArgumentException("Strings array and filter must not be null");
+        }
+
+        List<String> filteredStrings = new ArrayList<>();
+
+        for (String str : strings) {
+            filteredStrings.add(filters.filter(str));
+        }
+
+        return filteredStrings.toArray(new String[0]);
+    }
+}

src/main/java/PrefixStringFilter.java

+import java.util.ArrayList;
+import java.util.List;
+
+public class PrefixStringFilter implements StringFilter{
+
+    private final int n;
+
+    public PrefixStringFilter(int n) {
+        this.n = n;
+    }
+
+    @Override
+    public String filter(String string) {
+        return string.substring(0, this.n);
+    }
+
+    @Override
+    public String[] filter(String[] strings, StringFilter filters) {
+        if (strings == null || filters == null) {
+            throw new IllegalArgumentException("Strings array and filter must not be null");
+        }
+
+        List<String> filteredStrings = new ArrayList<>();
+
+        for (String str : strings) {
+            filteredStrings.add(filters.filter(str));
+        }
+
+        return filteredStrings.toArray(new String[0]);
+    }
+}

src/main/java/Stack.java

+public class Stack {
+
+    public Vector vector;
+
+    public Stack(Vector vector) {
+        this.vector = vector;
+    }
+
+    public void push(int value) {
+        vector.add(value);
+    }
+
+    public int peek() {
+        return vector.get(vector.size() - 1);
+    }
+
+    public int pop() {
+        int head = vector.get(vector.size());
+        vector.resize(vector.size() - 1);
+        return head;
+    }
+
+    public int size() {
+        return vector.size();
+    }
+
+    public boolean isEmpty() {
+        return vector.isEmpty();
+    }
+}

src/main/java/StringFilter.java

+public interface StringFilter {
+
+    String filter(String string);
+
+    String[] filter(String[] strings, StringFilter filters);
+}

src/main/java/UpperCaseStringFilter.java

+import java.util.ArrayList;
+import java.util.List;
+
+public class UpperCaseStringFilter implements StringFilter{
+    @Override
+    public String filter(String string) {
+        return string.toUpperCase();
+    }
+
+    @Override
+    public String[] filter(String[] strings, StringFilter filters) {
+        if (strings == null || filters == null) {
+            throw new IllegalArgumentException("Strings array and filter must not be null");
+        }
+
+        List<String> filteredStrings = new ArrayList<>();
+
+        for (String str : strings) {
+            filteredStrings.add(filters.filter(str));
+        }
+
+        return filteredStrings.toArray(new String[0]);
+    }
+}

src/main/java/Vector.java

@@ -51,7 +51,11 @@ public class Vector {
     }
 
     public void resize(int newSize) {
+        if (size > newSize) {
+            Arrays.fill(elements,newSize,size,0);
+        } else {
             ensureCapacity(newSize);
+        }
         this.size = newSize;
     }
 
@@ -60,13 +64,41 @@ public class Vector {
      *
      * @return Capacité du vecteur.
      */
+
     public int capacity() {
         return elements.length;
     }
 
-    public int size() { return 0; }
-    public boolean isEmpty() { return false; }
-    public void add(int element) { }
-    public void set(int index, int element) {  }
-    public int get(int index) { return 0; }
+    public int size() { return this.size; }
+
+    public boolean isEmpty() {
+        return this.size == 0;
+    }
+
+    public void add(int element) {
+        this.set(this.size, element);
+        this.resize(this.size + 1);
+    }
+
+    public void set(int index, int element) {
+        if (index > this.size) { return; }
+        this.elements[index] = element;
+    }
+
+    public int get(int index) {
+        if (index > this.size) { return 0; }
+        return this.elements[index];
+    }
+
+    public void toStringVector() {
+        if (this.isEmpty()) { System.out.println("[]"); }
+        else {
+            System.out.print("[");
+            for (int index = 0; index < this.size - 1; index++) {
+                System.out.print(this.get(index) + ",");
+            }
+            System.out.println(this.get(this.size - 1) + "]");
+        }
+    }
+
 }
\ No newline at end of file

src/test/java/VectorTest.java

@@ -36,25 +36,21 @@ public class VectorTest {
     }
 
     @Test
-    @Disabled
     void testEnsureCapacity_CapacitySatisfied() {
         Vector vector = new Vector(23);
         vector.ensureCapacity(120);
-        // TODO : add code
-        fail("not yet implemented");
+        assertThat(vector.capacity()).isEqualTo(120);
+        assertThat(vector.capacity()).isGreaterThanOrEqualTo(23*2);
     }
 
     @Test
-    @Disabled
     void testResize() {
         Vector vector = new Vector();
         vector.resize(120);
-        // TODO : add code
-        fail("not yet implemented");
+        assertThat(vector.size()).isEqualTo(120);
     }
 
     @Test
-    @Disabled
     void testResize_Zeros() {
         Vector vector = new Vector(1);
         vector.add(2);
@@ -64,48 +60,52 @@ public class VectorTest {
     }
 
     @Test
-    @Disabled
+    void testResize_plus() {
+        Vector vector = new Vector(1);
+        vector.resize(10);
+        assertThat(vector.get(5)).isEqualTo(0);
+    }
+
+    @Test
     void testResize_CapacityIncreased() {
-        /* TODO */
-        fail("not yet implemented");
+        Vector vector = new Vector(1);
+        vector.resize(50);
+        assertThat(vector.capacity()).isGreaterThanOrEqualTo(50);
     }
 
     @Test
-    @Disabled
     void testResize_CapacityNeverDecreaseWhenSizeDecrease() {
-        // TODO : add code
-        fail("not yet implemented");
+        Vector vector = new Vector(40);
+        vector.resize(20);
+        vector.resize(1);
+        assertThat(vector.capacity()).isEqualTo(40);
     }
 
     @Test
-    @Disabled
     void testIsEmpty() {
         Vector vector = new Vector();
         assertThat(vector.isEmpty()).isTrue();
         vector.resize(12);
-        // TODO : add code
-        fail("not yet implemented");
+        assertThat(vector.isEmpty()).isFalse();
     }
 
     @Test
-    @Disabled
     void testAdd() {
         Vector vector = new Vector();
         vector.add(12);
         vector.add(13);
         vector.add(10);
+        System.out.println(vector.size());
         assertThat(vector.size()).isEqualTo(3);
         assertThat(vector.get(0)).isEqualTo(12);
         assertThat(vector.get(1)).isEqualTo(13);
         assertThat(vector.get(2)).isEqualTo(10);
         vector.resize(1);
         vector.add(2);
-        // TODO : add code
-        fail("not yet implemented");
+        assertThat(vector.get(1)).isEqualTo(2);
     }
 
     @Test
-    @Disabled
     void testSet() {
         Vector vector = new Vector();
         vector.add(12);
@@ -114,27 +114,27 @@ public class VectorTest {
         vector.set(0, 2);
         vector.set(2, 4);
         vector.set(3, 123);
-        // TODO : add code
-        fail("not yet implemented");
+        assertThat(vector.get(0)).isEqualTo(2);
+        assertThat(vector.get(2)).isEqualTo(4);
+        assertThat(vector.get(3)).isEqualTo(123);
     }
 
     @Test
-    @Disabled
     void testGet_WhenInRange() {
         Vector vector = new Vector();
         vector.add(12);
         vector.add(13);
-        // TODO : add test
-        fail("not yet implemented");
+        assertThat(vector.get(0)).isEqualTo(12);
+        assertThat(vector.get(1)).isEqualTo(13);
     }
 
     @Test
-    @Disabled
     void testGet_WhenOutsideRange() {
         Vector vector = new Vector();
         vector.add(12);
         vector.add(13);
-        // TODO : add test for indices outside of the size of the vector
-        fail("not yet implemented");
+
+        vector.resize(50);
+        assertThat(vector.get(29)).isEqualTo(0);
     }
 }