*/
  @Deprecated
  public static CharMatcher singleWidth() {
    return SingleWidth.INSTANCE;
  }

  // Static factories

  /** Returns a {@code char} matcher that matches only one specified BMP character. */
  public static CharMatcher is(char match) {
    return new Is(match);
  }

  /**
   * Returns a {@code char} matcher that matches any character except the BMP character specified.
   *

     *
     * @return the operating system architecture (never null)
     */
    @Nonnull
    String arch();

    /**
     * Returns the OS version as reported by the system property "os.version".
     * The value is converted to lowercase for consistency.
     *
     * @return the operating system version (never null)
     */
    @Nonnull
    String version();

    /**

    /**
     * Analyzes the given text and returns a list of tokens.
     *
     * @param text the text to analyze
     * @param field the field associated with the text
     * @param lang the language of the text
     * @return a list of analyzed tokens
     */
    List<AnalyzeToken> analyze(String text, String field, String lang);

    /**
     * Analyzes the given text and returns a list of tokens along with their readings.
     *

        }
    }

    private synchronized boolean isInterrupted() {
        if (thread != null) {
            return thread.isInterrupted();
        }
        return true;
    }

    /**
     * Returns the list of expired {@link TimeoutTask}.
     *
     * @return the list of expired {@link TimeoutTask}
     */
    protected synchronized List<TimeoutTask> getExpiredTask() {

   * well-formed.
   *
   * <p>This method returns {@code true} if and only if {@code Arrays.equals(bytes, new
   * String(bytes, UTF_8).getBytes(UTF_8))} does, but is more efficient in both time and space.
   */
  public static boolean isWellFormed(byte[] bytes) {
    return isWellFormed(bytes, 0, bytes.length);
  }

  /**

public interface Location {

    /**
     * Return the line number where the current event ends,
     * returns -1 if none is available.
     * @return the current line number
     */
    int getLineNumber();

    /**
     * Return the column number where the current event ends,
     * returns -1 if none is available.
     * @return the current column number
     */
    int getColumnNumber();

    /**

            return setupWireFormatReturn;
        }

        @Override
        protected int writeParametersWireFormat(byte[] dst, int dstIndex) {
            return parametersWireFormatReturn;
        }

        @Override
        protected int writeDataWireFormat(byte[] dst, int dstIndex) {
            return dataWireFormatReturn;
        }

        @Override

                return false;
            }
        } else if (!value3.equals(other.value3)) {
            return false;
        }
        if (value4 == null) {
            if (other.value4 != null) {
                return false;
            }
        } else if (!value4.equals(other.value4)) {
            return false;
        }
        return true;
    }

        // Test implementation that returns null for empty params
        queryRescorer = new QueryRescorer() {
            @Override
            public RescorerBuilder<?> evaluate(Map<String, Object> params) {
                if (params == null || params.isEmpty()) {
                    return null;
                }
                return createMockRescorerBuilder();
            }
        };

		t.Errorf("should returns record not found error, but got %v", err)
	}

	for _, user := range []User{users[0], users[2]} {
		result = User{}
		if err := DB.Where("id = ?", user.ID).First(&result).Error; err != nil {
			t.Errorf("no error should returns when query %v, but got %v", user.ID, err)
		}
	}

	for _, user := range []User{users[0], users[2]} {