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)));
    }

    @Test
    public void testJustOnePerfectItem(){

        Item itemSpe = new Item(10, 28, 81);
        itemLinkedListGlo.add(itemSpe);

        Knapsack k = knapsackSolverGlo.solveKnapsackOptimal(knapsackGlo, (LinkedList<Item>) itemLinkedListGlo.clone());

        Assert.assertTrue("There is more than one element in your knapsack",k.getItemsInKnapsack().size() == 1);
        Assert.assertTrue("The item is not the expected one" ,k.getItemsInKnapsack().get(0).equals(itemSpe));

    }

    @Test
    public void testItemsLikeSand(){

        for (int i = 0; i < knapsackGlo.getMaximumWeight(); i++) {
            itemLinkedListGlo.add(new Item(i, 1, 1));
        }

        Knapsack k = knapsackSolverGlo.solveKnapsackOptimal(knapsackGlo, (LinkedList<Item>) itemLinkedListGlo.clone());

        Assert.assertTrue("With sand, the little rest of the knapsnack is not filled!!!\n\n\n\n", k.getItemsInKnapsack().size() == 9);

    }


    @Test
    public void testJustSandAndOneDiffEl(){

        Knapsack k1 = new Knapsack(30);
        LinkedList<Item> sandItemsList = new LinkedList<>();

        for (int i = 0; i <= k1.getMaximumWeight(); i++) {
            if (i == k1.getCurrentWeight()){
                sandItemsList.add(new Item(i, 4, 4));
            }
            sandItemsList.add(new Item(i, 3, 3));
        }

        Knapsack k2 = knapsackSolverGlo.solveKnapsackOptimal(k1, sandItemsList);

        Assert.assertTrue("That does not have the optimum value", k2.currentValue == 30);
        Assert.assertTrue("There is a unnecessary element in the sack", k2.getItemsInKnapsack().size() == 10);


    }

    @Test
    public void testAllIsTooWorthy(){

        Knapsack k1 = new Knapsack(30);

        LinkedList<Item> itemLinkedList = new LinkedList<>();

        for (int i = 0; i < k1.getMaximumWeight(); i++) {
            itemLinkedList.add(new Item(i, k1.getMaximumWeight()+1, i*100));
        }

        itemLinkedList.add(new Item(31, 29, 1));

        k1 = knapsackSolverGlo.solveKnapsackOptimal(k1, itemLinkedList);

        Assert.assertTrue("That cant be so valueable!", k1.currentValue <= 1);
    }



}

Hi Kerem,
I would propose cloning the List of available items before handing them to the KnapsackSolver because otherwise the List could be modified inside of the solving method and your tests could fail unexpectedly (i.e. there are less elements in the list you're checking against than expected).

Take a look at my fork of this gist for an idea how to do it (https://gist.github.com/reknih/e61531732963322692d951741cc6b762).

Great tests, keep up the good work!

Yeah good idea, thanks for the rec!

Hi Kerem,
super Test und Danke für die Arbeit. Eine Anmerkung in public void testReachToTheSky() solltest Du auch den Value bei 1 beginnen lassen. In einem der Foren Beiträge wurde bestätigt, dass weight und value nicht kleiner als eins sein werden. Der iterative Algorithmus stoppt beim Absuchen der Matrix, wenn der Value 0 ist und vergisst dann das letzte "0" Item hinzuzufügen.

Gruß
Stefan