TD2 ex 2 ok

src/TD2/ensembleEntierBorne/EnsembleEntierBorne.java

@@ -2,70 +2,69 @@ package TD2.ensembleEntierBorne;
 
 public class EnsembleEntierBorne {
 
-    private final int MAXIMUM;
+	private final int MAXIMUM;
-    private boolean tab[];
+	private boolean tab[];
 
-    public EnsembleEntierBorne(int max)
+	public EnsembleEntierBorne() {
-    {
+		this(0);
-    	MAXIMUM = max;
+	}
-    	tab = new boolean[max+1];        
-    }
 	
-    public void add(int elt)
+	public EnsembleEntierBorne(int max) {
-    {
+		this.MAXIMUM = max;
-        this.tab[elt] = true;
+		this.tab = new boolean[max + 1];
-    }
+		for(int i = 0; i < this.getMAXIMUM(); i++) {
+			this.setTabI(false, i);
+		}
+	}
 
-    public void remove(int elt)
+	public void add(int elt) {
-    {
+		this.setTabI(true, elt);
-        this.tab[elt] = false;
+	}
-    }
 
-    public boolean doesContains(int elt)
+	public void remove(int elt) {
-    {
+		this.setTabI(false, elt);
-        if (this.tab[elt] == true) {
+	}
-            return true;
-        } else {
-            return false;
-        }
-    }
 
-	/*EnsembleEntierBorne intersect(EnsembleEntierBorne ens)
+	public boolean doesContains(int elt) {
-    {
+		return this.tab[elt];
+	}
 
-    }*/
+	public EnsembleEntierBorne intersect(EnsembleEntierBorne ens) {
+		EnsembleEntierBorne e = new EnsembleEntierBorne(Math.max(this.getMAXIMUM(), ens.getMAXIMUM()));
+		
+		for(int i=0; i < Math.min(this.getMAXIMUM(), ens.getMAXIMUM()); i++) {
+			e.setTabI(this.doesContains(i) && ens.doesContains(i), i);
+		}
+		return e;
+	}
 	 
 	public int getMAXIMUM() {
-		return MAXIMUM;
+		return this.MAXIMUM;
-    }   
+	}
-    
 
 	public boolean[] getTab() {
-		return tab;
+		return this.tab;
-    }
+	}
 	
-	public void setTab(boolean tab[]) {
+	public void setTab(boolean[] b) {
-		this.tab = tab;
+		this.tab = b;
+	}
+
+	public void setTabI(boolean b, int i) {
+		this.tab[i] = b;
 	}
 
 	@Override
 	public String toString() {
 
-        String retour = "{";
+		String s = "{";
 
-        for (int i = 0; i < this.MAXIMUM; i++)
+		for (int i = 0; i < this.getMAXIMUM(); i++) {
-        {
+			if (doesContains(i)) {
-            if (this.tab[i] == true)
+				s += i + ", ";
-            {
+			}
-                retour += i+", ";
+		}
-            }
+		return s.substring(0, s.length()-2) + "}";
-        }
-        retour += "}";
-        return retour;
 	}
 
-	
-
-
-
 }

src/TD2/ensembleEntierBorne/TestEnsembleEntierBorne.java

@@ -5,7 +5,7 @@ public class TestEnsembleEntierBorne {
 	public static void main(String[] args) {
 		EnsembleEntierBorne e1 = new EnsembleEntierBorne(20);
 		EnsembleEntierBorne e2 = new EnsembleEntierBorne(11);
-		EnsembleEntierBorne e3 = new EnsembleEntierBorne(5);
+		EnsembleEntierBorne e3 = new EnsembleEntierBorne(10);
 		
 		e1.add(3);
 		e1.add(5);
@@ -35,12 +35,16 @@ public class TestEnsembleEntierBorne {
 		e2.add(8);
 
 		e3.add(5);
+		e3.add(8);
 		e3.add(0);
 		e3.add(3);
 
 		System.out.println("e1 = " + e1.toString());
 		System.out.println("e2 = " + e2.toString());
 		System.out.println("e3 = " + e3.toString());
+		
+		System.out.println(e3.intersect(e2));
+		
 	}
 
 }

tests/TD2/ensembleEntierBorne/EnsembleEntierBorneTest.java

@@ -0,0 +1,100 @@
+package TD2.ensembleEntierBorne;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.Test;
+
+public class EnsembleEntierBorneTest {
+
+	private EnsembleEntierBorne e1 = new EnsembleEntierBorne(20);
+	private EnsembleEntierBorne e2 = new EnsembleEntierBorne(16);
+	private EnsembleEntierBorne e3 = new EnsembleEntierBorne(18);
+
+
+	@Test
+	public void testAdd() {
+		e1.add(3);
+		e1.add(5);
+		e1.add(9);
+		e1.add(14);
+		e1.add(18);
+		
+		assertTrue(e1.doesContains(3));
+		assertTrue(e1.doesContains(5));
+		assertTrue(e1.doesContains(9));
+		assertTrue(e1.doesContains(14));
+		assertTrue(e1.doesContains(18));
+	}
+	
+	@Test
+	public void testRemove() {
+		
+		e2.add(1);
+		e2.add(2);
+		e2.add(3);
+		e2.add(4);
+		e2.add(5);
+		e2.add(6);
+		e2.add(7);
+		e2.add(8);
+	
+		assertTrue(e2.doesContains(1));
+		assertTrue(e2.doesContains(2));
+		assertTrue(e2.doesContains(3));
+		assertTrue(e2.doesContains(4));
+		assertTrue(e2.doesContains(5));
+		assertTrue(e2.doesContains(6));
+		assertTrue(e2.doesContains(7));
+		assertTrue(e2.doesContains(8));
+
+		e2.remove(2);
+		e2.remove(5);
+		e2.remove(8);
+
+		assertFalse(e2.doesContains(2));
+		assertFalse(e2.doesContains(5));
+		assertFalse(e2.doesContains(8));
+	}
+	
+	@Test
+	public void testToString() {
+		e2.add(1);
+		e2.add(2);
+		e2.add(3);
+		e2.add(4);
+		e2.add(5);
+		e2.add(6);
+		e2.add(7);
+		e2.add(8);
+		
+		assertEquals("{1, 2, 3, 4, 5, 6, 7, 8}", e2.toString());
+	}
+	
+	@Test
+	public void testIntersect() {
+		e1.add(3);
+		e1.add(5);
+		e1.add(9);
+		e1.add(14);
+		e1.add(18);
+		
+		e2.add(1);
+		e2.add(3);
+		e2.add(4);
+		e2.add(5);
+		e2.add(7);
+		e2.add(9);
+		e2.add(15);
+		
+		e3 = e1.intersect(e2);
+		
+		assertTrue(e3.doesContains(3));
+		assertTrue(e3.doesContains(5));
+		assertTrue(e3.doesContains(9));
+		
+		
+		
+	}
+}