diff --git a/.idea/gradle.xml b/.idea/gradle.xml
new file mode 100644
index 0000000000000000000000000000000000000000..267d99c598ebbe3300ab6f14a8d02cdceb5cfe67
--- /dev/null
+++ b/.idea/gradle.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+ <component name="GradleSettings">
+ <option name="linkedExternalProjectsSettings">
+ <GradleProjectSettings>
+ <option name="distributionType" value="DEFAULT_WRAPPED" />
+ <option name="externalProjectPath" value="$PROJECT_DIR$" />
+ <option name="modules">
+ <set>
+ <option value="$PROJECT_DIR$" />
+ </set>
+ </option>
+ <option name="useAutoImport" value="true" />
+ </GradleProjectSettings>
+ </option>
+ </component>
+</project>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
new file mode 100644
index 0000000000000000000000000000000000000000..29af3ee87f1f2dd7037f23b0db8ceccda899dde7
--- /dev/null
+++ b/.idea/misc.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+ <component name="ExternalStorageConfigurationManager" enabled="true" />
+ <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" project-jdk-type="JavaSDK">
+ <output url="file://$PROJECT_DIR$/out" />
+ </component>
+</project>
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 0000000000000000000000000000000000000000..94a25f7f4cb416c083d265558da75d457237d671
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+ <component name="VcsDirectoryMappings">
+ <mapping directory="$PROJECT_DIR$" vcs="Git" />
+ </component>
+</project>
\ No newline at end of file
diff --git a/README.md b/README.md
index 02b432c2604e3e16ff074a8190816b56cf4931fa..460054e123f82447445ef6df81202f60238c7000 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,112 @@
-# Vector2021
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" lang="fr" xml:lang="fr">
+<h2>Version courte <h2>
+<p> Pour chacune des classes vue en TD vous devez écrire des tests pour chacune des méthodes et ensuite vous implémenterez ces méthodes. Vous avez un exemple de squelette pour la classe <code>Vector</code>.</p>
+
+<h2>Objectif</h2>
+
+<p>L'objectif de ce TP est de mettre en place des pratiques de programmation permettant
+ de produire un code correct et lisible. Ce premier TP est assez long à réaliser. Il est impératif de vous concentrer
+ sur votre TP et de travailler entre les TP pour le terminer.</p>
+
+<p>La démarche que vous allez suivre pour implémenter les exercices du TD est la suivante. Vous allez faire dans l'ordre
+ les trois points suivants :
+<ul>
+ <li>Écriture de commentaires pour spécifier <b>précisément</b> le comportement des classes et méthodes.</li>
+ <li>Écriture de tests permettant de vérifier la <b>totalité</b> de la spécification.</li>
+ <li>Écriture du code des méthodes de façon <b>la plus lisible possible</b>.</li>
+</ul>
+</p>
+
+<h2>Vecteur d'entiers</h2>
+
+<h3>Écriture des tests</h3>
+
+<p>Les tests permettent de vérifier à chaque étape du développement que le code écrit est correct, c'est-à-dire,
+ qu'il vérifie les spécifications. Les tests vont être écrits sous la forme de petites méthodes qui vérifient
+ un des comportements attendus. </p>
+
+<p>Faites un clic droit sur la classe <code>Vector</code> et créez un nouveau <code>JUnit Test Case</code>.
+ Sélectionnez <code>New JUnit 4 test</code>, le répertoire <code>src/test/java</code> et nommez
+ la classe <code>VectorTest</code>. Normalement, la nouvelle classe contient un code qui ressemble à celui-ci : <p>
+
+ <code>
+ public class VectorTest {
+ @Test
+ public void test() {
+ fail("Not yet implemented");
+ }
+ }
+ </code>
+
+<p>Placez vous sur la classe et <code>VectorTest</code> et exécutez son contenu à l'aide de la flèche
+ verte d'<code>Eclipse</code>. Normalement, vous devriez voir apparaître le résultat de l'exécution
+ avec un échec rencontré sur la méthode <code>void test()</code>. En effet, la méthode
+ <code>test()</code> est annotée par <code>@Test</code>. Par conséquent, elle est exécutée comme
+ un test par <code>JUnit</code>. La ligne <code>fail("Not yet implemented");</code> génère l'échec
+ obtenu par l'exécution des tests.</p>
+
+<p>Vous allez écrire des méthodes dans la classe <code>VectorTest</code> afin de tester les différentes
+ fonctionnalités de la classe <code>Vector</code>. Pour cela, vous allez la compléter en vous inspirant des tests déjà écrits.
+
+<h3>Implémentation de la classe Vector</h3>
+
+<p>Vous pouvez maintenant implémenter la classe <code>Vector</code> en vérifiant
+ à chaque étape de son implémentation que de nouveaux tests passent au vert.
+ N'hésitez pas à utiliser le débogueur d'Eclipse si vous avez des problèmes
+ pour trouver vos erreurs. Évidemment, les erreurs peuvent se trouver dans
+ les tests ou dans le code de la classe Vector. Dans tous les cas, vous ne
+ devez modifier les tests uniquement s'ils sont en désaccords avec les
+ spécifications de la classe.</p>
+
+<h2>Pile d'entiers</h2>
+
+<p>Effectuez les mêmes étapes que pour l'exercice précédent afin d'ajouter
+ à votre projet la nouvelle classe <code>Stack</code> qui utilise
+ la classe <code>Vector</code> afin d'implémenter une pile. Vous devez
+ donc écrire les spécifications de la classe, écrire une classe
+ de tests, puis implémenter la classe <code>Stack</code>. Cette classe
+ peut être placée dans un package <code>fr.licinfo.structure</code>. </p>
+
+<h2>Filtres de chaînes de caractères</h2>
+
+<p>Nous allons programmer les classes de l'exercice 3 du TD en utilisant la même démarche de "qualité".
+ Créez un nouveau projet Maven de nom <code>stringfilter</code>, configurez-le afin de pouvoir utiliser
+ <code>JUnit 4</code> et <code>Hamcrest</code>.</p>
+
+<p>Définissez ensuite l'interface <code>StringFilter</code> et commentez-là. Créez ensuite les différentes classes
+ qui implémentent l'interface <code>StringFilter</code>. Écrivez les commentaires précisant leurs spécifications
+ <b>sans les implémenter</b>.</p>
+
+<p>Ajoutez une classe de tests <code>StringFilterTest</code>. Dans cette classe, ajoutez une méthode testant
+ chacune des implémentations de <code>StringFilter</code>. Par exemple, vous pouvez ajouter la méthode suivante
+ pour tester la classe <code>UpperCaseStringFilter</code> : </p>
+
+<code>
+
+ @Test
+ public void upperCaseStringFilter() {
+ String input = "toto";
+ StringFilter filter = new UpperCaseStringFilter();
+ String output = filter.filter(input);
+ assertThat(output, equalTo("TOTO"));
+ }
+</code>
+
+<p>Implémentez ensuite les différents filtres en vérifiant que votre code est correct à l'aide des tests.</p>
+</div>
+<ul id="slide-out" class="right side-nav"></ul>
+</div>
+
+<footer class="page-footer teal lighten-2">
+ <div class="footer-copyright">
+ <div class="center-align">
+ © 2018 Bertrand Estellon
+ </div>
+ </div>
+</footer>
+
+</body>
+
+</html>
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000000000000000000000000000000000000..efe68dfc81a33490322e4ce2ac30dbdcef639c54
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,16 @@
+plugins {
+ id 'java'
+}
+
+version '1.0-SNAPSHOT'
+
+sourceCompatibility = 1.8
+
+repositories {
+ mavenCentral()
+}
+
+dependencies {
+ testCompile group: 'junit', name: 'junit', version: '4.12'
+ testCompile 'org.hamcrest:hamcrest-library:1.3'
+}
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000000000000000000000000000000000..1948b9074f1016d15d505d185bc3f73deb82d8c8
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000000000000000000000000000000000000..115e675dba4554a6c078a2c57b70002f5503c215
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Wed Sep 18 23:20:29 CEST 2019
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.8-all.zip
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000000000000000000000000000000000000..cccdd3d517fc5249beaefa600691cf150f2fa3e6
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000000000000000000000000000000000000..f9553162f122c71b34635112e717c3e733b5b212
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000000000000000000000000000000000000..a06b32ce2e7679f39dcf351933ad471959191017
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1,2 @@
+rootProject.name = 'vector'
+
diff --git a/src/main/java/Vector.java b/src/main/java/Vector.java
new file mode 100644
index 0000000000000000000000000000000000000000..739cec510ccba4ef5278084a1356bcd1958fd213
--- /dev/null
+++ b/src/main/java/Vector.java
@@ -0,0 +1,68 @@
+import java.util.Arrays;
+
+/** * La classe Vector implémente un tableau d'entiers * de taille dynamique. Les éléments du vecteur sont stockés dans un tableau. * La taille de ce tableau est au minimum doublée à chaque fois qu'il est * nécessaire de le faire grossir. */
+public class Vector {
+
+ /**
+ * Tableau permettant de stocker les éléments du vecteur.
+ * Seuls les size premiers éléments font partie du vecteur.
+ * La taille de ce tableau est égale à la capacité du vecteur, c'est-à-dire,
+ * au nombre d'éléments maximum que le vecteur peut contenir sans
+ * avoir besoin d'allouer un nouveau tableau.
+ */
+ private int[] elements;
+
+ /**
+ * Nombre d'éléments présents dans le vecteur.
+ */
+ private int size;
+
+ /**
+ * Construit un vecteur de capacité initiale initialCapacity.
+ *
+ * @param initialCapacity Capacité initiale du vecteur
+ */
+ public Vector(int initialCapacity) {
+ elements = new int[initialCapacity];
+ size = 0;
+ }
+
+ public Vector() {
+ this(10);
+ }
+
+ /**
+ * Augmente la capacité du vecteur si nécessaire de façon
+ * à permettre le stockage d'au moins <code>minCapacity</code>
+ * éléments. S'il est nécessaire d'augmenter la capacité du vecteur,
+ * elle est au minimum doublée.
+ *
+ * @param minCapacity Capacité minimale à assurer
+ */
+ public void ensureCapacity(int minCapacity) {
+ int oldCapacity = elements.length;
+ if (oldCapacity >= minCapacity) return;
+ int newCapacity = Math.max(oldCapacity * 2, minCapacity);
+ elements = Arrays.copyOf(elements, newCapacity);
+ }
+
+ public void resize(int newSize) {
+ ensureCapacity(newSize);
+ this.size = newSize;
+ }
+
+ /**
+ * Retourne la capacité du vecteur.
+ *
+ * @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; }
+}
\ No newline at end of file
diff --git a/src/test/java/VectorTest.java b/src/test/java/VectorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ccad28cbc5f9060f68e415f11612dfae524c34b
--- /dev/null
+++ b/src/test/java/VectorTest.java
@@ -0,0 +1,121 @@
+import static junit.framework.TestCase.fail;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+import org.junit.Test;
+
+public class VectorTest {
+
+ @Test
+ public void testVectorInt() {
+ Vector vector = new Vector(123);
+ assertThat(vector.capacity(), equalTo(123));
+ assertThat(vector.size(), equalTo(0));
+ }
+
+ @Test
+ public void testVector() {
+ Vector vector = new Vector();
+ assertThat(vector.capacity(), equalTo(10));
+ assertThat(vector.size(), equalTo(0));
+ }
+
+ @Test
+ public void testEnsureCapacity_CapacityDoubled() {
+ Vector vector = new Vector(23);
+ vector.ensureCapacity(24);
+ assertThat(vector.capacity(), greaterThanOrEqualTo(23*2));
+ }
+
+ @Test
+ public void testEnsureCapacity_CapacitySatified() {
+ Vector vector = new Vector(23);
+ vector.ensureCapacity(120);
+ /* TODO */
+ fail("not yet implemented");
+ }
+
+ @Test
+ public void testEnsureCapacity_CapacityAlwaysIncreased() {
+ Vector vector = new Vector(120);
+ vector.ensureCapacity(10);
+ assertThat(vector.capacity(), equalTo(120));
+ }
+
+ @Test
+ public void testResize() {
+ Vector vector = new Vector();
+ vector.resize(120);
+ /* TODO */
+ fail("not yet implemented");
+ }
+
+ @Test
+ public void testResize_Zeros() {
+ Vector vector = new Vector(1);
+ vector.add(2);
+ vector.resize(0);
+ vector.resize(1);
+ assertThat(vector.get(0), equalTo(0));
+ }
+
+ @Test
+ public void testResize_CapacityIncreased() {
+ /* TODO */
+ fail("not yet implemented");
+ }
+
+ @Test
+ public void testResize_CapacityAlwaysIncreased() {
+ /* TODO */
+ fail("not yet implemented");
+ }
+
+ @Test
+ public void testIsEmpty() {
+ Vector vector = new Vector();
+ assertThat(vector.isEmpty(), equalTo(true));
+ vector.resize(12);
+ /* TODO */
+ fail("not yet implemented");
+ }
+
+ @Test
+ public void testAdd() {
+ Vector vector = new Vector();
+ vector.add(12);
+ vector.add(13);
+ vector.add(10);
+ assertThat(vector.size(), equalTo(3));
+ assertThat(vector.get(0), equalTo(12));
+ assertThat(vector.get(1), equalTo(13));
+ assertThat(vector.get(2), equalTo(10));
+ vector.resize(1);
+ vector.add(2);
+ /* TODO */
+ fail("not yet implemented");
+ }
+
+ @Test
+ public void testSet() {
+ Vector vector = new Vector();
+ vector.add(12);
+ vector.add(13);
+ vector.add(10);
+ vector.set(0, 2);
+ vector.set(2, 4);
+ vector.set(3, 123);
+ /* TODO */
+ fail("not yet implemented");
+ }
+
+ @Test
+ public void testGet() {
+ Vector vector = new Vector();
+ vector.add(12);
+ vector.add(13);
+ /* TODO : tester également le fait d'être en dehors des bornes. */
+ fail("not yet implemented");
+ }
+
+}
\ No newline at end of file