}
        return new Result<>(result.hasErrors() || hasErrors(problems), result.get(), list);
    }

    public static <T> Result<T> addProblems(Result<T> result, Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);

}

// withError allows a fluent style for internal result code.
func (r *Result) withError(err error) *Result {
	r.err = err
	return r
}

// TargetsSingleItems returns true if any of the builder arguments pointed
// to non-list calls (if the user explicitly asked for any object by name).
// This includes directories, streams, URLs, and resource name tuples.
func (r *Result) TargetsSingleItems() bool {
	return r.targetsSingleItems
}

 * <p>
 * The meaning of the value parameter is specific to each concrete subclass. The validity of {@code null}
 * is also to be defined by each subclass. This implementation does allow null values.
 *
 * <p>The result is the last message sent from the daemon back to the daemon client.
 */
public abstract class Result<T> extends Message {

    private final T value;

        }
        return new Result<>(result.hasErrors() || hasErrors(problems), result.get(), list);
    }

    public static <T> Result<T> addProblems(Result<T> result, Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);
            }

	return buf.String()
}

func (r *Result) add(result echo.CallResult, err error) {
	count := result.Responses.Len()
	if count == 0 {
		count = 1
	}

	r.TotalRequests += count
	if err != nil {
		r.Error = multierror.Append(r.Error, fmt.Errorf("request %d: %v", r.TotalRequests, err))
	} else {
		r.SuccessfulRequests += count
	}
}

func (r Result) PercentSuccess() float64 {

import java.time.Duration;

public class Result {

    private final Duration duration;
    private final Try<Execution> execution;

    protected Result(Duration duration, Try<Execution> execution) {
        this.duration = duration;
        this.execution = execution;
    }

    protected Result(Result parent) {
        this(parent.getDuration(), parent.getExecution());
    }

Tres Popp <******@****.***> 1648061556 -0700

        result.asFailure()

        then:
        thrown(IllegalArgumentException)
    }

    def "can query successful void result"() {
        def result = ExecutionResult.succeeded()

        expect:
        result.value == null
        result.valueOrRethrow == null
        result.failureOrNull == null
        result.failures.empty
        result.rethrow()
    }

    def "can query failed result"() {

        when:
        TestFailure result = serialize(failure, DefaultTestFailure)

        then:
        result.rawFailure.message == 'cause'
        result.details.assertionFailure == true
        result.details.message == 'cause'
        result.details.expected == 'expectedValue'
        result.details.actual == 'actualValue'
        result.details.stacktrace.contains('java.lang.RuntimeException: cause')
    }

		t.Fatalf("invalid create/update unix nano time: %#v", result)
	}

	result.FieldAllowUpdate = "field_allow_update_updated"
	result.FieldReadonly = "field_readonly_updated"
	result.FieldIgnore = "field_ignore_updated"
	DB.Save(&result)

	var result2 CustomizeFieldStruct
	DB.Find(&result2, "name = ?", "create")