[Demonstration 1]

[Buggy Method]
@Test
public void createGroup() {
    mockAuthentication("jdubois@ippon.fr");
    User user = userService.getUserByLogin("jdubois@ippon.fr");
    assertEquals(0, groupService.getGroupsForUser(user).size());
    String groupName = "Group name";
    String groupDescription = "Group description";
    boolean publicGroup = true;
    groupService.createGroup(groupName, groupDescription, publicGroup, group.isPostModerated());
    Collection<Group> groups = groupService.getGroupsForUser(user);
    assertEquals(1, groups.size());
    Group group = groups.iterator().next();
    assertEquals(groupName, group.getName());
    assertEquals(groupDescription, group.getDescription());
    assertTrue(group.isPublicGroup());
    assertFalse(group.isArchivedGroup());
}

[Buggy Hunk]
groupService.createGroup(groupName, groupDescription, publicGroup, group.isPostModerated());

[Patch]
groupService.createGroup(groupName, groupDescription, publicGroup, false);

[Demonstration 2]

[Buggy Method]
private void initStopGroup() {
    // get resources from stop section
    StopRes res = container.getStop();
    // create resource mapper to map resources from stop tag
    StopResMapper rm = new StopResMapper(res.getPreMain(), res.getPostMain(), res.getMain());
    // get the environment
    Map<String, String> env = null;
    if (envHandler != null) {
        env = envHandler.getProcsEnv();
    }
    // gather resources
    List<Resource> resources = new ArrayList<>();
    resources.addAll(rm.getPreMainRes());
    resources.add(rm.getMainRes());
    resources.addAll(rm.getPostMainRes());
    // init handlers
    List<ProcessHandler> handlers = initDefaultProcs(rm, resources, env);
    // init proc handler for stop group
    StopGroupHandler stopGroupHandler = new StopGroupHandler(handlers);
    procMngr.setStopGroupHandler(stopGroupHandler);
}

[Buggy Hunk]
StopGroupHandler stopGroupHandler = new StopGroupHandler(handlers);

[Patch]
StopGroupProcessHandler stopGroupHandler = new StopGroupProcessHandler(handlers);

[Demonstration 3]

[Buggy Method]
@GET
@Path("/groups")
@Produces({ MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
@Authorize(name = "getAllGroups")
public Response list(@Context HttpHeaders hh, @Context HttpServletRequest request, @QueryParam("slbId") final Long slbId, @QueryParam("appId") final String appId, @QueryParam("vsId") final Long vsId, @TrimmedQueryParam("ip") final String ip, @TrimmedQueryParam("slbName") final String slbName, @TrimmedQueryParam("domain") final String domain, @TrimmedQueryParam("type") String type, @TrimmedQueryParam("tag") final String tag, @TrimmedQueryParam("pname") final String pname, @TrimmedQueryParam("pvalue") final String pvalue, @TrimmedQueryParam("mode") final String mode) throws Exception {
    final SelectionMode selectionMode = SelectionMode.getMode(mode);
    final Long[] vsIdRange = new QueryExecuter.Builder<IdVersion>().addFilter(new FilterSet<IdVersion>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return slbId != null || slbName != null;
        }

        @Override
        public Set<IdVersion> filter() throws Exception {
            Long sId = slbId;
            if (sId == null && slbName != null) {
                sId = slbCriteriaQuery.queryByName(slbName);
            }
            if (sId != null) {
                return virtualServerCriteriaQuery.queryBySlbId(sId);
            }
            return new HashSet<>();
        }
    }).addFilter(new FilterSet<IdVersion>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return domain != null;
        }

        @Override
        public Set<IdVersion> filter() throws Exception {
            return virtualServerCriteriaQuery.queryByDomain(domain);
        }
    }).addFilter(new FilterSet<IdVersion>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return slbId != null || slbName != null || domain != null;
        }

        @Override
        public Set<IdVersion> filter() throws Exception {
            return virtualServerCriteriaQuery.queryAll(SelectionMode.OFFLINE_FIRST);
        }
    }).build(IdVersion.class).run(new ResultHandler<IdVersion, Long>() {

        @Override
        public Long[] handle(Set<IdVersion> result) throws Exception {
            if (vsId != null) {
                if (result == null)
                    return new Long[] { vsId };
                boolean flag = false;
                for (IdVersion e : result) {
                    if (e.getId().equals(vsId)) {
                        flag = true;
                        break;
                    }
                }
                if (!flag)
                    return new Long[0];
            }
            return VersionUtils.extractUniqIds(result);
        }
    });
    if (vsIdRange != null && vsIdRange.length == 0) {
        return responseHandler.handle(new GroupList(), hh.getMediaType());
    }
    final Set<IdVersion> groupFilter = vsIdRange == null ? null : groupCriteriaQuery.queryByVsIds(vsIdRange);
    final Long[] groupIds = new QueryExecuter.Builder<Long>().addFilter(new FilterSet<Long>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return groupFilter != null;
        }

        @Override
        public Set<Long> filter() throws Exception {
            Set<Long> result = new HashSet<>();
            for (IdVersion e : groupFilter) {
                result.add(e.getId());
            }
            return result;
        }
    }).addFilter(new FilterSet<Long>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return true;
        }

        @Override
        public Set<Long> filter() throws Exception {
            return groupCriteriaQuery.queryAll();
        }
    }).addFilter(new FilterSet<Long>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return appId != null;
        }

        @Override
        public Set<Long> filter() throws Exception {
            return groupCriteriaQuery.queryByAppId(appId);
        }
    }).addFilter(new FilterSet<Long>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return tag != null;
        }

        @Override
        public Set<Long> filter() throws Exception {
            return new HashSet<>(tagService.query(tag, "group"));
        }
    }).addFilter(new FilterSet<Long>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return pname != null;
        }

        @Override
        public Set<Long> filter() throws Exception {
            if (pvalue != null)
                return new HashSet<>(propertyService.query(pname, pvalue, "group"));
            else
                return new HashSet<>(propertyService.query(pname, "group"));
        }
    }).build(Long.class).run();
    IdVersion[] keys = new QueryExecuter.Builder<IdVersion>().addFilter(new FilterSet<IdVersion>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return groupFilter != null;
        }

        @Override
        public Set<IdVersion> filter() throws Exception {
            return groupFilter;
        }
    }).addFilter(new FilterSet<IdVersion>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return ip != null && groupFilter != null;
        }

        @Override
        public Set<IdVersion> filter() throws Exception {
            return groupCriteriaQuery.queryByGroupServer(ip);
        }
    }).addFilter(new FilterSet<IdVersion>() {

        @Override
        public boolean shouldFilter() throws Exception {
            return true;
        }

        @Override
        public Set<IdVersion> filter() throws Exception {
            return groupIds.length == 0 ? new HashSet<IdVersion>() : groupCriteriaQuery.queryByIdsAndMode(groupIds, selectionMode);
        }
    }).build(IdVersion.class).run(new ResultHandler<IdVersion, IdVersion>() {

        @Override
        public IdVersion[] handle(Set<IdVersion> result) throws Exception {
            result.removeAll(groupCriteriaQuery.queryAllVGroups(selectionMode));
            return result.toArray(new IdVersion[result.size()]);
        }
    });
    GroupList groupList = new GroupList();
    for (Group group : groupRepository.list(keys)) {
        groupList.addGroup(getGroupByType(group, type));
    }
    groupList.setTotal(groupList.getGroups().size());
    return responseHandler.handle(groupList, hh.getMediaType());
}

[Buggy Hunk]
return ip != null && groupFilter != null;

[Patch]
return ip != null;