}

// Tags - a rule can either have tag under <filter></filter> or under
// <filter><and></and></filter>. This method returns all the tags from the
// rule in the format tag1=value1&tag2=value2
func (r Rule) Tags() string {
	if !r.Filter.Tag.IsEmpty() {
		return r.Filter.Tag.String()
	}
	if len(r.Filter.And.Tags) != 0 {
		var buf bytes.Buffer
		for _, t := range r.Filter.And.Tags {
			if buf.Len() > 0 {
				buf.WriteString("&")

Testing basn4a08.png: PASS (32 zero samples)
 Filter 1 was used 1 times
 Filter 4 was used 31 times
Testing basn4a16.png: PASS (64 zero samples)
 Filter 0 was used 1 times
 Filter 1 was used 2 times
 Filter 2 was used 1 times
 Filter 4 was used 28 times
Testing basn6a08.png: PASS (160 zero samples)
 Filter 1 was used 1 times
 Filter 4 was used 31 times
Testing basn6a16.png: PASS (1072 zero samples)
 Filter 1 was used 4 times

        final EncodingFilter filter = new EncodingFilter();
        Map<String, String[]> paramMap;

        paramMap = filter.parseQueryString("a=", "UTF-8");
        assertEquals(1, paramMap.size());
        assertEquals("", paramMap.get("a")[0]);

        paramMap = filter.parseQueryString("a", "UTF-8");
        assertEquals(1, paramMap.size());
        assertEquals("", paramMap.get("a")[0]);

     * <pre>
     *    filter(HeadFilter, lines:25, skip:2)
     *    filter(ReplaceTokens, tokens:[copyright:'2009', version:'2.3.1'])
     * </pre>
     *
     * @param properties map of filter properties
     * @param filterType Class of filter to add
     * @return this
     */
    ContentFilterable filter(Map<String, ?> properties, Class<? extends FilterReader> filterType);

    /**

  <artifactId>b</artifactId>
  <version>1.0</version>

    <build>
        <filters>
            <filter>src/main/filters/a.properties</filter>
            <filter>src/main/filters/c.properties</filter>
            <filter>src/main/filters/b.properties</filter>
            <filter>src/main/filters/d.properties</filter>
        </filters>
    </build>

        val self = this
        return KaRendererKeywordFilter filter@{ modifier, symbol ->
            val analysisSession = this@filter
            self.filter(analysisSession, modifier, symbol) || other.filter(analysisSession, modifier, symbol)
        }
    }

    public object ALL : KaRendererKeywordFilter {
        override fun filter(analysisSession: KaSession, modifier: KtKeywordToken, annotated: KaAnnotated): Boolean {

            - orRules:
                rules:
                - metadata:
                    filter: envoy.filters.a.b
                    path:
                    - key: c
                    value:
                      stringMatch:
                        exact: exact
                - metadata:
                    filter: envoy.filters.a.b
                    path:
                    - key: c

   "api" [shape="box", label=<<B>api</B>>, color="chartreuse3", bgcolor="chartreuse3", style="filled"]

   "compileOnlyApi" [shape="box", label=<<B>compileOnlyApi</B>>, color="chartreuse3", bgcolor="chartreuse3", style="filled"]

   "implementation" [shape="box", label=<<B>implementation</B>>, color="chartreuse3", bgcolor="chartreuse3", style="filled"]
   "implementation" -> "api"

                    - metadata:
                        filter: envoy.filters.http.jwt_authn
                        path:
                        - key: payload
                        - key: iss
                        value:
                          stringMatch:
                            exact: requestPrincipals
                    - metadata:
                        filter: envoy.filters.http.jwt_authn
                        path:

// string matcher.
func MetadataValueMatcher(filter, key string, m *matcher.ValueMatcher) *matcher.MetadataMatcher {
	return &matcher.MetadataMatcher{
		Filter: filter,
		Path: []*matcher.MetadataMatcher_PathSegment{
			{
				Segment: &matcher.MetadataMatcher_PathSegment_Key{
					Key: key,
				},
			},
		},
		Value: m,
	}
}