synchronized (state) {
        if (state.seenExceptionsField == expect) {
          state.seenExceptionsField = update;
        }
      }
    }

    @Override
    int decrementAndGetRemainingCount(AggregateFutureState<?> state) {
      synchronized (state) {
        return --state.remainingField;
      }
    }

    @Override
    String atomicHelperTypeForTest() {

        return asJson(new ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                .total(pager.getAllRecordCount())
                .status(Status.OK)
                .result());
    }

    // GET /api/admin/accesstoken/setting/{id}
    /**
     * Retrieves a specific access token setting by ID.
     *
     * @param id the access token ID to retrieve

    }

    /**
     * Get the negotiation status
     *
     * @return status code
     */
    public int getStatus() {
        return status;
    }

    /**
     * Set the negotiation status
     *
     * @param status status code
     */
    public void setStatus(int status) {
        this.status = status;
    }

    /**

		expStatus: replication.Pending,
	},
	{ // 3. replication status for one target - incorrect format
		name:      "replication status for one target",
		rs:        ReplicationState{ReplicationStatusInternal: "arn1=PENDING"},
		expStatus: replication.StatusType(""),
	},
	{ // 4. replication status for 3 targets, one of them failed
		name: "replication status for 3 targets - one failed",
		rs: ReplicationState{

import static com.google.common.math.StatsTesting.MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS;
import static com.google.common.math.StatsTesting.MEGA_STREAM_COUNT;
import static com.google.common.math.StatsTesting.MEGA_STREAM_MAX;
import static com.google.common.math.StatsTesting.MEGA_STREAM_MEAN;
import static com.google.common.math.StatsTesting.MEGA_STREAM_MIN;
import static com.google.common.math.StatsTesting.MEGA_STREAM_POPULATION_VARIANCE;

                    return null;
                })).status(ApiResult.Status.OK).result());
    }

    /**
     * Creates a new stemmer override dictionary item.
     *
     * @param dictId the dictionary ID
     * @param body the request body containing stemmer override item information
     * @return JSON response with result status
     */
    // POST /api/admin/dict/stemmerOverride/setting/{dictId}

* etc.

Nesses casos, você normalmente retornaria um **HTTP status code** próximo ao status code na faixa do status code **400** (do 400 ao 499).

Isso é bastante similar ao caso do HTTP status code 200 (do 200 ao 299). Esses "200" status codes significam que, de algum modo, houve sucesso na requisição.

Os status codes na faixa dos 400 significam que houve um erro por parte do cliente.

    void testFailoverStateCreation() {
        ChannelFailover.FailoverState state = new ChannelFailover.FailoverState("test-channel");

        assertEquals("test-channel", state.getChannelId());
        assertEquals(0, state.getRetryCount());
        assertTrue(state.shouldRetry());
        assertTrue(state.getFailureTime() > 0);
        assertTrue(state.getNextRetryTime() > state.getFailureTime());
    }

    @Test

  if (shape.num_dims != -1) {
    DCHECK(shape.dim_sizes != nullptr);
    Status status = tensorflow::PartialTensorShape::MakePartialShape(
        reinterpret_cast<int64_t*>(shape.dim_sizes), shape.num_dims,
        &partial_shape);
    if (!status.ok()) {
      tsl::Set_TF_Status_from_Status(s, status);
      return nullptr;
    }
  }
  tsl::Set_TF_Status_from_Status(

  CHECK_EQ(actual, 1);
}

TFE_MonitoringCounter0* CreateCounter0(const char* counter_name) {
  TF_Status* status = TF_NewStatus();
  auto* counter =
      TFE_MonitoringNewCounter0(counter_name, status, "description");
  TF_DeleteStatus(status);
  return counter;
}

void IncrementCounter0(TFE_MonitoringCounter0* counter, int64_t delta) {
  auto* cell = TFE_MonitoringGetCellCounter0(counter);