"address_prefix": "10.111.182.109",
                              "prefix_len": 32
                            }
                          ],
                          "on_match": {
                            "matcher": {
                              "matcher_tree": {
                                "input": {
                                  "name": "port",

                              "address_prefix": "10.111.182.109",
                              "prefix_len": 32
                            }
                          ],
                          "on_match": {
                            "matcher": {
                              "matcher_tree": {
                                "input": {
                                  "name": "port",

                              "address_prefix": "10.104.171.68",
                              "prefix_len": 32
                            }
                          ],
                          "on_match": {
                            "matcher": {
                              "matcher_tree": {
                                "input": {
                                  "name": "port",

		return []string{getMatches(fc.GetFilterChainMatch())}
	}
	switch v := l.GetFilterChainMatcher().GetOnNoMatch().GetOnMatch().(type) {
	case *matcher.Matcher_OnMatch_Action:
		if v.Action.GetName() == fc.GetName() {
			return []string{"UNMATCHED"}
		}
	case *matcher.Matcher_OnMatch_Matcher:
		ms, f := recurse(fc.GetName(), v.Matcher)
		if !f {
			return []string{"NONE"}
		}
		return ms
	}

    public boolean hasRole(final String role) {
        return stream(user.getRoleNames()).get(stream -> stream.anyMatch(s -> s.equals(role)));
    }

    public boolean hasRoles(final String[] acceptedRoles) {
        return stream(user.getRoleNames())
                .get(stream -> stream.anyMatch(s1 -> stream(acceptedRoles).get(s3 -> s3.anyMatch(s2 -> s2.equals(s1)))));
    }

    public boolean hasGroup(final String group) {

                        return false;
                    }
                    if (Arrays.stream(webProtocols).anyMatch(p -> s.startsWith(p))) {
                        return web;
                    }
                    if (Arrays.stream(fileProtocols).anyMatch(p -> s.startsWith(p))) {
                        return file;
                    }
                    return true;

            String[] keywords = query.split(" ");
            assertTrue(doc.entrySet().stream()
                    .anyMatch(entry -> entry.getValue().toString().toLowerCase().contains(keywords[0].toLowerCase())), doc.toString());
            assertFalse(doc.entrySet().stream()
                    .anyMatch(entry -> entry.getValue().toString().toLowerCase().contains(keywords[2].toLowerCase())), doc.toString());
        }
    }

            if (StringUtil.isEmpty(key) || userBean
                    .map(user -> stream(user.getRoles()).get(stream -> stream.anyMatch(s -> (ROLE_VALUE_PREFIX + s).equals(key)))
                            || stream(user.getGroups()).get(stream -> stream.anyMatch(s -> (GROUP_VALUE_PREFIX + s).equals(key))))
                    .orElse(false)) {
                return p.getSecond();
            }

                        .body().jsonPath().get("response.plugins");
                boolean exists = installed.stream().map(this::getArtifactFromMap)
                        .anyMatch(a -> a.getName().equals(target.getName()) && a.getVersion().equals(target.getVersion()));
                if (!exists) {
                    ThreadUtil.sleep(500);
                    continue;
                }

     */
    private boolean isRequestedProjectCollected(MavenExecutionRequest request, List<MavenProject> projects) {
        return projects.stream().map(MavenProject::getFile).anyMatch(request.getPom()::equals);
    }

    /**
     * This method finds out whether collecting projects failed because of the following scenario: