[Demonstration 1]

[Buggy Method]
public LinkedHashMap<Food, Integer> topKfoods(int canteenId) {
    CanteenController canteenCtrl = new CanteenController();
    Canteen canteen = canteenCtrl.getCanteen(canteenId);
    ArrayList<OrderPeriod> orderPeriodList = orderPeriodDAO.getAllPeriodsForCanteen(canteen);
    ArrayList<FoodOrder> allFoodOrderList = new ArrayList<FoodOrder>();
    for (OrderPeriod orderPeriod : orderPeriodList) {
        allFoodOrderList.addAll(foodOrderDAO.getAllFoodOrderOfOrderPeriod(orderPeriod));
    }
    List<Food> allFoodFromCanteen = foodDAO.getAllFoodFromCanteen(canteen);
    LinkedHashMap<Food, Integer> foodCountMap = new LinkedHashMap<Food, Integer>();
    Set<FoodOrderItem> foodOrderItemSet = new HashSet<FoodOrderItem>();
    for (FoodOrder foodOrder : allFoodOrderList) {
        foodOrderItemSet.addAll(foodOrder.getFoodOrderList());
    }
    for (Food f : allFoodFromCanteen) {
        int foodIDf = f.getFoodId();
        int count = 0;
        Iterator<FoodOrderItem> iter = foodOrderItemSet.iterator();
        while (iter.hasNext()) {
            FoodOrderItem foodOrderItem = (FoodOrderItem) iter.next();
            Food food = foodOrderItem.getFood();
            int foodID = food.getFoodId();
            if (foodID == foodIDf) {
                count += foodOrderItem.getQuantity();
            }
            // if (foodCountMap.containsKey(food)) {
            // count = foodCountMap.get(food);
            // }
            //
            // int quantity = foodOrderItem.getQuantity();
            // count += quantity;
            // foodCountMap.put(food, count);
        }
        if (foodCountMap.containsKey(f)) {
            count += foodCountMap.get(f);
            foodCountMap.put(f, count);
        } else {
            foodCountMap.put(f, count);
        }
    }
    // sort by integer
    List<Map.Entry<Food, Integer>> entries = new ArrayList<Map.Entry<Food, Integer>>(foodCountMap.entrySet());
    Collections.sort(entries, new Comparator<Map.Entry<Food, Integer>>() {

        public int compare(Map.Entry<Food, Integer> a, Map.Entry<Food, Integer> b) {
            return a.getValue().compareTo(b.getValue());
        }
    });
    LinkedHashMap<Food, Integer> sortedMap = new LinkedHashMap<Food, Integer>();
    for (Map.Entry<Food, Integer> entry : entries) {
        sortedMap.put(entry.getKey(), entry.getValue());
    }
    return sortedMap;
}

[Buggy Hunk]
return a.getValue().compareTo(b.getValue());

[Patch]
return b.getValue().compareTo(a.getValue());

[Demonstration 2]

[Buggy Method]
private static String getQueryURL(String queryRoot, String query, PrideFilter... filters) {
    String queryURLAsString = queryRoot + "?";
    if (!query.isEmpty()) {
        queryURLAsString = queryURLAsString + "query=" + query;
    }
    if (filters != null && filters.length > 0) {
        for (PrideFilter aFilter : filters) {
            queryURLAsString += aFilter.getType().toString() + "=" + aFilter.getValue().replace(" ", "%20");
        }
    }
    System.out.println(queryURLAsString);
    return queryURLAsString;
}

[Buggy Hunk]
queryURLAsString += aFilter.getType().toString() + "=" + aFilter.getValue().replace(" ", "%20");

[Patch]
queryURLAsString += "&" + aFilter.getType().toString() + "=" + aFilter.getValue().replace(" ", "%20");

[Demonstration 3]

[Buggy Method]
@Test
public void givenSessionIsAdded_whenItIsRemoved_thenCallDestroyMethod() {
    Session session = sessionManager.getSession("13");
    assertThat(session.isDestroyed()).isFalse();
    sessionManager.remove(session);
    assertThat(session.isDestroyed()).isTrue();
}

[Buggy Hunk]
Session session = sessionManager.getSession("13");

[Patch]
Session session = sessionManager.getSession(sessionId);