if len(p) == 0 {
		return 0, r.setErr(nil, false)
	}
	r.mu.Lock()
	defer r.mu.Unlock()
	if err := r.err; err != nil {
		if err == io.EOF {
			err = ErrWriteOnClosed
		}
		return 0, err
	}
	wrote := 0
	for len(p) > 0 {
		n, err = r.write(p)
		wrote += n
		if !r.block || err == nil {
			break
		}
		err = r.setErr(err, true)

        String title = Character.toTitleCase(propertyName.charAt(0)) + propertyName.substring(1);

        // Try setter first
        MethodInfo setter = classMethodCache.get("set" + title);
        if (setter != null && isMethodCompatible(setter.method, valueType)) {
            return setter;
        }

        // Try adder
        MethodInfo adder = classMethodCache.get("add" + title);

                        queryMap = new HashMap<>();
                        keyMatchQueryMap.put(virtualHost, queryMap);
                    }
                    final String termKey = toLowerCase(keyMatch.getTerm());
                    List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>> boostList = queryMap.get(termKey);
                    if (boostList == null) {
                        boostList = new ArrayList<>();

     */
    boolean hasReadMethod();

    /**
     * Returns the setter method.
     *
     * @return the setter method
     */
    Method getWriteMethod();

    /**
     * Returns whether the property has a setter method.
     *
     * @return whether the property has a setter method
     */
    boolean hasWriteMethod();

    /**

        final String field = getSearchField(context.getDefaultField(), wildcardQuery.getField());
        if (Constants.DEFAULT_FIELD.equals(field)) {
            final String text = wildcardQuery.getTerm().text();
            context.addFieldLog(field, text);
            final String highlightText = StringUtils.strip(text, "*");
            if (StringUtil.isNotBlank(highlightText)) {

     */
    @Test
    public void test_constructor() {
        FessIntervalController controller = new FessIntervalController();
        assertNotNull(controller);
    }

    /**
     * Test getter and setter for delayMillisAfterProcessing
     */
    @Test
    public void test_delayMillisAfterProcessing() {
        FessIntervalController controller = new FessIntervalController();

     */
    private List<String> skipAnnotations = Collections.singletonList("Generated");

    /**
     * Setter to specify the visibility scope where Javadoc comments are checked.
     *
     * @param scope a scope.
     */
    public void setScope(Scope scope) {
        this.scope = scope;
    }

    /**
     * Setter to specify the visibility scope where Javadoc comments are not checked.
     *
     * @param excludeScope a scope.

                relatedContentMap.put(key, pair);
            }
            if (entity.getTerm().startsWith(regexPrefix)) {
                final String regex = entity.getTerm().substring(regexPrefix.length());
                if (StringUtil.isBlank(regex)) {
                    logger.warn("Unknown regex pattern: {}", entity.getTerm());
                } else {

    }

    @Test
    @DisplayName("Test subCommand getter and setter")
    void testSubCommandGetterSetter() {
        byte subcommand = (byte) 0x05;
        response.setSubCommand(subcommand);
        assertEquals(subcommand, response.getSubCommand());
    }

    @Test
    @DisplayName("Test status getter and setter")
    void testStatusGetterSetter() {
        assertEquals(0, response.getStatus());

        return readMethod != null;
    }

    @Override
    public final Method getWriteMethod() {
        return writeMethod;
    }

    /**
     * Sets the setter method.
     *
     * @param writeMethod
     *            The setter method.
     */
    protected final void setWriteMethod(final Method writeMethod) {
        this.writeMethod = writeMethod;
        if (writeMethod != null) {