public String available;

    /** Search/filter parameter for data configuration sort order. */
    public String sortOrder;

    /** Search/filter parameter for data configuration creator. */
    public String createdBy;

    /** Search/filter parameter for data configuration creation time. */
    public String createdTime;

    }

    /**
     * Adds a tag to filter by.
     * @param tag The tag.
     */
    public void addTag(final String tag) {
        tags.add(tag);
    }

    /**
     * Adds a role to filter by.
     * @param role The role.
     */
    public void addRole(final String role) {
        roles.add(role);
    }

    /**
     * Adds a field to filter by.
     * @param field The field name.

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

/**
 * Servlet filter for handling character encoding conversion and URL redirection.
 * This filter processes requests with specific encoding requirements and converts
 * character encodings according to configured mapping rules.
 *
 * <p>The filter intercepts requests matching configured path patterns and

For example, imagine that you want to return an HTTP status code of "OK" `200` by default.

But if the data didn't exist, you want to create it, and return an HTTP status code of "CREATED" `201`.

But you still want to be able to filter and convert the data you return with a `response_model`.

For those cases, you can use a `Response` parameter.

## Use a `Response` parameter { #use-a-response-parameter }

    public ArtifactResolutionRequest setCollectionFilter(ArtifactFilter filter) {
        this.collectionFilter = filter;

        return this;
    }

    /**
     * Gets the artifact filter that controls downloading of artifact files. This filter operates on those artifacts
     * that have been included by the {@link #getCollectionFilter()}.
     *

        regA(builder);
        return builder;
    }

    protected FilterAggregationBuilder regFilterA(String name, QueryBuilder filter) {
        FilterAggregationBuilder builder = AggregationBuilders.filter(name, filter);
        regA(builder);
        return builder;
    }

    protected GlobalAggregationBuilder regGlobalA(String name) {

    private DosFileFilter filter;

    @BeforeEach
    public void setup() {
        filter = new DosFileFilter("*", SmbFile.ATTR_NORMAL);
    }

    @Test
    public void testAcceptReturnsTrueWhenAttributesMatch() throws Exception {
        SmbFile file = mock(SmbFile.class);
        when(file.getAttributes()).thenReturn(SmbFile.ATTR_NORMAL);
        assertTrue(filter.accept(file), "Attributes match should be accepted");

        return stream(ex_q).get(stream -> stream.filter(StringUtil::isNotBlank).distinct().toArray(n -> new String[n]));
    }

    @Override
    public Map<String, String[]> getFields() {
        return fields;
    }

    @Override
    public String[] getLanguages() {
        return stream(lang).get(stream -> stream.filter(StringUtil::isNotBlank).distinct().toArray(n -> new String[n]));
    }

     *     <li>"s" - contextual snapshot filter</li>
     *     <li>"ns" - unconditional snapshot filter (no snapshots selected from ranges)</li>
     *     <li>"e(G:A:V)" - predicate filter (leaves out G:A:V from range, if hit, V can be range)</li>
     * </ul>
     * Example filter expression: <code>"h(5);s;e(org.foo:bar:1)</code> will cause: ranges are filtered for "top 5" (instead

//go:build !(windows || js || wasip1)

package main

import (
	"regexp"
	"strings"
	"testing"
)

func TestExitCodeFilter(t *testing.T) {
	// Write text to the filter one character at a time.
	var out strings.Builder
	f, exitStr := newExitCodeFilter(&out)
	// Embed a "fake" exit code in the middle to check that we don't get caught on it.
	pre := "abc" + exitStr + "123def"