These test cases might help you to understand the homework better and you might become aware of some cases that you might have forgotten in your implementation!

testKnapsack.java

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import java.util.LinkedList;
import java.util.Random;

public class testKnapsack {

    private Knapsack knapsackGlo;
    private KnapsackSolver knapsackSolverGlo;
    private LinkedList<Item> itemLinkedListGlo;

    @Before
    public void set(){

        knapsackGlo = new Knapsack(28);
        knapsackSolverGlo = new KnapsackSolver();
        itemLinkedListGlo= new LinkedList<>();

        Item item1 = new Item(1, 4, 10);
        Item item2 = new Item(2, 5, 15);
        Item item3 = new Item(3, 2, 5);
        Item item4 = new Item(3, 4, 10);
        Item item5 = new Item(3, 7, 15);
        Item item6 = new Item(3, 3, 20);
        Item item7 = new Item(3, 1, 5);

        itemLinkedListGlo.add(item1);
        itemLinkedListGlo.add(item2);
        itemLinkedListGlo.add(item3);
        itemLinkedListGlo.add(item4);
        itemLinkedListGlo.add(item5);
        itemLinkedListGlo.add(item6);
        itemLinkedListGlo.add(item7);
    }

@Test
public void testWith3El(){

    Knapsack k = new Knapsack(10);
    KnapsackSolver knapsackSolver = new KnapsackSolver();
    LinkedList<Item> itemLinkedList = new LinkedList<>();

    Item item1 = new Item(1, 4, 10);
    Item item2 = new Item(2, 7, 15);
    Item item3 = new Item(3, 2, 6);

    itemLinkedList.add(item1);
    itemLinkedList.add(item2);
    itemLinkedList.add(item3);

    k = knapsackSolver.solveKnapsackOptimal(k, itemLinkedList);

}

@Test
public void testTakeAll(){

    Knapsack k = new Knapsack(28);
    KnapsackSolver knapsackSolver = new KnapsackSolver();
    LinkedList<Item> itemLinkedList = new LinkedList<>();

    Item item1 = new Item(1, 4, 10);
    Item item2 = new Item(2, 7, 15);
    Item item3 = new Item(3, 2, 5);
    Item item4 = new Item(3, 4, 10);
    Item item5 = new Item(3, 7, 15);
    Item item6 = new Item(3, 3, 20);
    Item item7 = new Item(3, 1, 5);

    itemLinkedList.add(item1);
    itemLinkedList.add(item2);
    itemLinkedList.add(item3);
    itemLinkedList.add(item4);
    itemLinkedList.add(item5);
    itemLinkedList.add(item6);
    itemLinkedList.add(item7);

    k = knapsackSolver.solveKnapsackOptimal(k, itemLinkedList);

    System.out.println(k.toString());
    Assert.assertEquals("The value is not the maximal", k.currentValue, 80);
    Assert.assertEquals("All the elements are not in the list, even though there is enough place", k.getCurrentWeight(), 28);

}

@Test
public void testEmptyKnapsack(){

    Knapsack k = new Knapsack(10);
    KnapsackSolver knapsackSolver = new KnapsackSolver();
    LinkedList<Item> itemLinkedList = new LinkedList<>();

    Item item1 = new Item(1, 40, 10);
    Item item2 = new Item(2, 70, 15);
    Item item3 = new Item(3, 20, 5);
    Item item4 = new Item(3, 40, 10);
    Item item5 = new Item(3, 70, 15);

    itemLinkedList.add(item1);
    itemLinkedList.add(item2);
    itemLinkedList.add(item3);
    itemLinkedList.add(item4);
    itemLinkedList.add(item5);

    k = knapsackSolver.solveKnapsackOptimal(k, itemLinkedList);


    Assert.assertTrue("Knapscak includes something, eventhough it isn't that big", k.currentValue == 0);
    Assert.assertTrue(k.getCurrentWeight() == 0);

}


@Test
public void testReachToTheSky(){

    //Knapsack k = new Knapsack(10);
    KnapsackSolver knapsackSolver = new KnapsackSolver();
    LinkedList<Item> itemLinkedList = new LinkedList<>();
    Item temp;
    Random random = new Random();


    int currentWeight = 0, numOfItems = 10, maxValueOfItem = 100;

    // To weight +1, because the randGenerator can give zero values and that's nonsense! To prevent this, the range is upgraded 1-11
    for (int i = 0; i < numOfItems; i++) {
        temp = new Item(i, random.nextInt(10)+1, random.nextInt(maxValueOfItem));
        itemLinkedList.add(temp);
        currentWeight += temp.getWeight();
    }

    Knapsack k = new Knapsack(currentWeight);

    knapsackSolver.solveKnapsackOptimal(k, itemLinkedList);



    Assert.assertTrue("Knap doesn't have everything that it can have", k.getCurrentWeight() == currentWeight);
    Assert.assertTrue("That much of value is too much", k.currentValue < numOfItems*maxValueOfItem);
}


@Test
public void testBasic(){

    Knapsack k = new Knapsack(10);
    LinkedList<Item> itemLinkedList = new LinkedList<>();
    Random random = new Random();

    for (int i = 0; i < 10; i++) {
        itemLinkedList.add(new Item(i, random.nextInt()%5 + 5, random.nextInt()%100 + 100));
    }

    KnapsackSolver knapsackSolver = new KnapsackSolver();

    knapsackSolver.solveKnapsackOptimal(k, itemLinkedList).toString();

}

@Test
public void testEasyGreedy(){

    Knapsack k = new Knapsack(10);
    KnapsackSolver knapsackSolver = new KnapsackSolver();

    knapsackSolver.solveKnapsackGreedyStupid(k, (LinkedList<Item>) itemLinkedListGlo.clone());

    Assert.assertTrue(k.currentValue >= 35);
    Assert.assertTrue(k.getItemsInKnapsack().contains(itemLinkedListGlo.get(5)));
}


    @Test
    public void testLessEasyGreedy(){

        Knapsack k = new Knapsack(10);

        k = knapsackSolverGlo.solveKnapsackGreedySmart(k, (LinkedList<Item>) itemLinkedListGlo.clone());


        Assert.assertTrue(k.getItemsInKnapsack().contains(itemLinkedListGlo.get(5)));
    }


}