html_url: https://github.com/fastapi/full-stack-fastapi-template
  stars: 37341
  owner_login: fastapi
  owner_html_url: https://github.com/fastapi
- name: Hello-Python
  html_url: https://github.com/mouredev/Hello-Python
  stars: 31799
  owner_login: mouredev
  owner_html_url: https://github.com/mouredev
- name: serve
  html_url: https://github.com/jina-ai/serve
  stars: 21721
  owner_login: jina-ai

    assertThat(manager.servicesByState().keySet()).containsExactly(Service.State.FAILED);
  }

  private static void assertState(
      ServiceManager manager, Service.State state, Service... services) {
    Collection<Service> managerServices = manager.servicesByState().get(state);
    for (Service service : services) {
      assertEquals(service.toString(), state, service.state());

@GwtIncompatible
final class DirectExecutorService extends AbstractListeningExecutorService {

  /** Lock used whenever accessing the state variables (runningTasks, shutdown) of the executor */
  private final Object lock = new Object();

  /*
   * Conceptually, these two variables describe the executor being in
   * one of three states:
   *   - Active: shutdown == false
   *   - Shutdown: runningTasks > 0 and shutdown == true

            // from being reused. Otherwise we're still obligated to transmit the request body to
            // leave the connection in a consistent state.
            exchange.noNewExchangesOnConnection()
          }
        }
      } else if (!isUpgradeRequest) {
        exchange.noRequestBody()
      }

      if (requestBody == null || !requestBody.isDuplex()) {

        }
    }

    @Nested
    @DisplayName("Response State Tests")
    class ResponseStateTests {

        @BeforeEach
        void setup() {
            testBlock = new TestServerMessageBlock(mockConfig);
        }

        @Test
        @DisplayName("Test received state")
        void testReceivedState() {
            assertFalse(testBlock.isReceived());

import java.io.Serializable;
import java.util.List;

import org.codelibs.fess.util.ComponentUtil;

/**
 * GroupPager provides pagination functionality for group management operations in Fess.
 * This class manages the state and metadata required for paginated display of group lists,
 * including page navigation, record counts, and search criteria.
 *
 */
public class GroupPager implements Serializable {

        queryContext.setQueryBuilder(initialQuery);

        queryContext.addFunctionScore(list -> {
            list.add(new FilterFunctionBuilder(QueryBuilders.termQuery("status", "active"),
                    ScoreFunctionBuilders.weightFactorFunction(2.0f)));
        });

        QueryBuilder result = queryContext.getQueryBuilder();
        assertNotNull(result);

/**
 * FessIntervalController extends DefaultIntervalController to provide
 * Fess-specific interval control functionality for web crawling operations.
 * This controller manages delays and timing for various crawling states
 * including processing delays, queue waiting times, and new URL discovery.
 */
public class FessIntervalController extends DefaultIntervalController {

    /**
     * Default constructor.
     */

    }

    /**
     * Reflectively set the 'status' on a SMB2 response to drive control flow.
     */
    private static void setStatus(jcifs.internal.smb2.ServerMessageBlock2Response resp, int status) throws Exception {
        Field f = jcifs.internal.smb2.ServerMessageBlock2.class.getDeclaredField("status");
        f.setAccessible(true);
        f.setInt(resp, status);
    }

# Response - Change Status Code { #response-change-status-code }

You probably read before that you can set a default [Response Status Code](../tutorial/response-status-code.md){.internal-link target=_blank}.

But in some cases you need to return a different status code than the default.

## Use case { #use-case }

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