} catch (InterruptedException e) {
        /* ignore */
      }
      try {
        // Fill up heap so soft references get cleared.
        filler = new byte[Math.max(filler.length, filler.length * 2)];
      } catch (OutOfMemoryError e) {
      }
    }

    CacheTesting.processPendingNotifications(cache);
    assertEquals(1, cache.size());
    assertEquals(1, removalListener.getCount());
  }

    </init-param>
  </filter>

  <filter>
    <filter-name>corsFilter</filter-name>
    <filter-class>org.codelibs.fess.filter.CorsFilter</filter-class>
  </filter>

  <filter>
    <filter-name>webApiFilter</filter-name>
    <filter-class>org.codelibs.fess.filter.WebApiFilter</filter-class>
  </filter>

  <filter>
    <filter-name>lastaPrepareFilter</filter-name>

        ScopeArtifactFilter filter = new ScopeArtifactFilter(Artifact.SCOPE_TEST);

        assertTrue(filter.include(newArtifact(Artifact.SCOPE_COMPILE)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_SYSTEM)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_PROVIDED)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_RUNTIME)));
        assertTrue(filter.include(newArtifact(Artifact.SCOPE_TEST)));

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

}

func (r Rule) validateFilter() error {
	return r.Filter.Validate()
}

// Prefix - a rule can either have prefix under <filter></filter> or under
// <filter><and></and></filter>. This method returns the prefix from the
// location where it is available
func (r Rule) Prefix() string {
	if r.Filter.Prefix != "" {
		return r.Filter.Prefix
	}
	return r.Filter.And.Prefix
}

  <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>

			outputFormat: "json",
			filter:       EndpointFilter{},
		},
		{
			name:         "emptyfilter",
			outputFormat: "yaml",
			filter:       EndpointFilter{},
		},
		{
			name:         "portfilter",
			outputFormat: "json",
			filter: EndpointFilter{
				Port: 8080,
			},
		},
		{
			name:         "portfilter",
			outputFormat: "yaml",
			filter: EndpointFilter{
				Port: 8080,
			},
		},
	}

}

// PrintServiceSummary prints a summary of the relevant services in the config dump to the ConfigWriter stdout
func (c *ConfigWriter) PrintPolicySummary(filter PolicyFilter) error {
	w := c.tabwriter()
	zDump := c.ztunnelDump

	pols := slices.Filter(maps.Values(zDump.Policies), filter.Verify)
	slices.SortFunc(pols, func(a, b *ZtunnelPolicy) int {
		if r := cmp.Compare(a.Namespace, b.Namespace); r != 0 {
			return r
		}

		call           string
		fn             func() error
		filter, expect string
	}{
		{call: "Setegid(1)", fn: func() error { return syscall.Setegid(1) }, filter: "Gid:", expect: "\t0\t1\t0\t1"},
		{call: "Setegid(0)", fn: func() error { return syscall.Setegid(0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"},

		{call: "Seteuid(1)", fn: func() error { return syscall.Seteuid(1) }, filter: "Uid:", expect: "\t0\t1\t0\t1"},

type FilterRule struct {
	Name  string `xml:"Name"`
	Value string `xml:"Value"`
}

func (filter FilterRule) isEmpty() bool {
	return filter.Name == "" && filter.Value == ""
}

// MarshalXML implements a custom marshaller to support `omitempty` feature.
func (filter FilterRule) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	if filter.isEmpty() {
		return nil
	}
	type filterRuleWrapper FilterRule