diff --git a/src/test/java/ch/zhaw/pm2/racetrack/CarTest.java b/src/test/java/ch/zhaw/pm2/racetrack/CarTest.java
new file mode 100644
index 0000000..472b356
--- /dev/null
+++ b/src/test/java/ch/zhaw/pm2/racetrack/CarTest.java
@@ -0,0 +1,187 @@
+
+package ch.zhaw.pm2.racetrack;
+
+import ch.zhaw.pm2.racetrack.strategy.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for Class Car
+ */
+class CarTest {
+
+    Car car;
+
+    // Default coordinates for tests
+    int DEFAULT_X = 10;
+    int DEFAULT_Y = 10;
+    char DEFAULT_ID = 'f';
+
+    /**
+     * Create a new Car Object and set Position to a defined Default Position
+     */
+    @BeforeEach
+    void setUp() {
+        car = new Car(DEFAULT_ID, new PositionVector(DEFAULT_X, DEFAULT_Y));
+    }
+
+    @Test
+    void getID() {
+        assertEquals(DEFAULT_ID, car.getID());
+    }
+
+    /**
+     * Method to check nextPosition with coordinates as int
+     *
+     * @param x the expected value for x coordinate
+     * @param y the expected value for y coordinate
+     */
+    void checkNextPosition(int x, int y) {
+        assertEquals(new PositionVector(x, y), car.nextPosition());
+    }
+
+    /**
+     * - checks if the position of the car can be set and saved correctly with valid positions.
+     * - checks if an exception is throwed and position keeps unchanged if invalid coordinates are entered.
+     */
+    @Test
+    void setPosition() {
+        checkNextPosition(DEFAULT_X, DEFAULT_Y);
+
+        // List of valid Positions
+        List<PositionVector> validPositions = new ArrayList<>();
+        validPositions.add(new PositionVector(20, 20));
+        validPositions.add(new PositionVector(0, 0));
+        validPositions.add(new PositionVector(20, 0));
+        validPositions.add(new PositionVector(0, 20));
+
+        for (PositionVector positionVector : validPositions) {
+            car.setPosition(positionVector);
+            assertEquals(positionVector, car.nextPosition());
+        }
+
+        // List of invalid positions.
+        List<PositionVector> invalidPositions = new ArrayList<>();
+        invalidPositions.add(new PositionVector(0, -20));
+        invalidPositions.add(new PositionVector(-20, 0));
+        invalidPositions.add(new PositionVector(-20, -20));
+
+        for (PositionVector positionVector : invalidPositions) {
+            boolean exception = false;
+            try {
+                car.setPosition(positionVector);
+            } catch (IllegalArgumentException e) {
+                exception = true;
+            }
+            assertTrue(exception);
+
+            // position should keep unchanged
+            checkNextPosition(DEFAULT_X, DEFAULT_Y);
+        }
+    }
+
+    void checkVelocity(int x, int y) {
+        assertEquals(new PositionVector(x, y), car.getVelocity());
+    }
+
+
+    /**
+     * Checks if the methods accelerate, move and getVelocity are working correctly with acceleration in all directions.
+     * Checks also if velocity is calculated correctly if method accelerate is called a second time.
+     */
+    @Test
+    void movement() {
+        // add all possible directions in a List
+        List<PositionVector.Direction> directions = Arrays.asList(PositionVector.Direction.values());
+
+        //position shouldn't be changed because velocity should be 0.
+        car.move();
+        checkNextPosition(DEFAULT_X, DEFAULT_Y);
+
+        for (PositionVector.Direction direction1 : directions) {
+
+            //create a new instance of Car with default coordinates and velocity 0.
+            setUp();
+
+            //variables to save the actual expected result of method nextPosition
+            int expectedNextPosX = DEFAULT_X;
+            int expectedNextPosY = DEFAULT_Y;
+
+            //variables to save the acutal expected result of method getVelocity
+            int expectedVelocityX = 0;
+            int expectedVelocityY = 0;
+
+            car.accelerate(direction1);
+            expectedVelocityX += direction1.vector.getX();
+            expectedVelocityY += direction1.vector.getY();
+            expectedNextPosX += direction1.vector.getX();
+            expectedNextPosY += direction1.vector.getY();
+            checkVelocity(expectedVelocityX, expectedVelocityY);
+            checkNextPosition(expectedNextPosX, expectedNextPosY);
+
+            car.move();
+            expectedNextPosX += direction1.vector.getX();
+            expectedNextPosY += direction1.vector.getY();
+            checkVelocity(expectedVelocityX, expectedVelocityY);
+            checkNextPosition(expectedNextPosX, expectedNextPosY);
+
+            for (PositionVector.Direction direction2 : directions) {
+                car.accelerate(direction2);
+                expectedVelocityX += direction2.vector.getX();
+                expectedVelocityY += direction2.vector.getY();
+                expectedNextPosX += direction2.vector.getX();
+                expectedNextPosY += direction2.vector.getY();
+                checkVelocity(expectedVelocityX, expectedVelocityY);
+                checkNextPosition(expectedNextPosX, expectedNextPosY);
+
+                car.move();
+                checkVelocity(expectedVelocityX, expectedVelocityY);
+                expectedNextPosX += (direction1.vector.getX() + direction2.vector.getX());
+                expectedNextPosY += (direction1.vector.getY() + direction2.vector.getY());
+                checkNextPosition(expectedNextPosX, expectedNextPosY);
+            }
+        }
+    }
+
+
+    /**
+     * test for methods crash and isCrashed. checks if state crashed is set and returned correctly.
+     */
+    @Test
+    void crash() {
+        assertFalse(car.isCrashed());
+        car.crash();
+        assertTrue(car.isCrashed());
+    }
+
+    /**
+     * test for methods setMoveStrategy. Checks if the MoveStrategy Object is saved and returned correctly
+     * with all Types of MoveStrategy.
+     */
+    @Test
+    void MoveStrategy() {
+        MoveStrategy moveStrategy;
+
+        moveStrategy = new DoNotMoveStrategy();
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+
+        moveStrategy = new MoveListStrategy();
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+
+        moveStrategy = new PathFollowerMoveStrategy();
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+
+        moveStrategy = new UserMoveStrategy();
+        car.setMoveStrategy(moveStrategy);
+        assertEquals(moveStrategy, car.getMoveStrategy());
+    }
+}