super.setUp(testInfo);
        messages = new FessMessages();
    }

    // Test constant fields
    @Test
    public void test_constantFields() {
        // Test error message constants
        assertEquals("{errors.front_header}", FessMessages.ERRORS_front_header);
        assertEquals("{errors.front_footer}", FessMessages.ERRORS_front_footer);

     */
    public boolean isSuccess() {
        return returnCode == ERROR_SUCCESS;
    }

    /**
     * Gets the error message for the current return code.
     *
     * @return a human-readable error message
     */
    public String getErrorMessage() {
        switch (returnCode) {
        case ERROR_SUCCESS:
            return "Success";

				if db.AddError(tx.Clauses(clause.Where{Exprs: queryConds}).Delete(modelValue).Error) != nil {
					return
				}
			}
		}

	}
}

func Delete(config *Config) func(db *gorm.DB) {
	supportReturning := utils.Contains(config.DeleteClauses, "RETURNING")

	return func(db *gorm.DB) {
		if db.Error != nil {
			return
		}

		if db.Statement.Schema != nil {

                                "content": {"application/json": {"schema": {}}},
                            },
                            "422": {
                                "description": "Validation Error",
                                "content": {
                                    "application/json": {
                                        "schema": {

	// ErrIncorrectSequence is returned when an out-of-sequence item is received.
	ErrIncorrectSequence = errors.New("out-of-sequence item received")
)

// ErrResponse is a remote error response.
type ErrResponse struct {
	msg string
}

func (e ErrResponse) Error() string {
	return fmt.Sprintf("remote: %s", e.msg)

    runExpectedExceptionCatchingAsyncTest(expectedException, false);
  }

  public void testCatchingAsync_fallbackGeneratesError() throws Exception {
    Error error = new Error("deliberate");
    AsyncFunction<Throwable, Integer> fallback =
        unused -> {
          throw error;
        };
    ListenableFuture<Integer> failingFuture = immediateFailedFuture(new RuntimeException());
    ExecutionException expected =

    runExpectedExceptionCatchingAsyncTest(expectedException, false);
  }

  public void testCatchingAsync_fallbackGeneratesError() throws Exception {
    Error error = new Error("deliberate");
    AsyncFunction<Throwable, Integer> fallback =
        unused -> {
          throw error;
        };
    ListenableFuture<Integer> failingFuture = immediateFailedFuture(new RuntimeException());
    ExecutionException expected =

      raising an error and quitting.

  Returns:
    [String] The value of var_name after querying for input.

  Raises:
    UserInputError: if a query has been attempted n_ask_attempts times without
      success, assume that the user has made a scripting error, and will
      continue to provide invalid input. Raise the error to avoid infinitely
      looping.
  """

//go:generate msgp -file $GOFILE

// RStat has replication error stats
type RStat struct {
	Count int64 `json:"count"`
	Bytes int64 `json:"bytes"`
}

// RTimedMetrics has replication error stats for various time windows
type RTimedMetrics struct {
	LastHour    ReplicationLastHour `json:"lastHour"`
	SinceUptime RStat               `json:"sinceUptime"`
	LastMinute  ReplicationLastMinute
	// Error counts

			if err != nil {
				t.Error(err)
			}
			tmpfile.WriteString(testCase.content)
			tmpfile.Sync()
			tmpfile.Close()

			value, err := readFromSecret(tmpfile.Name())
			if err != nil && !testCase.expectedErr {
				t.Error(err)
			}
			if err == nil && testCase.expectedErr {
				t.Error(errors.New("expected error, found success"))
			}
			if value != testCase.expectedValue {