return ExecutionResult.succeeded(model);
        });
    }

    @Override
    public <T> T withEmptyBuild(Function<? super SettingsInternal, T> action) {
        return runBuild(() -> {
            T result = buildLifecycleController.withSettings(action);
            return ExecutionResult.succeeded(result);
        });
    }

  pm.addInstrumentation(std::make_unique<SaveQuantizationReportInstrumentation>(
      report_file_path));

  const LogicalResult run_result = pm.run(*module_op);
  ASSERT_TRUE(succeeded(run_result));

  // Check that the report file contains `QuantizationResults` textproto,
  // reflecting the quantization results, in this case the
  // `composite_dot_general_fn` with quantized with `static_range_ptq` method.

	cmd := exec.Command("go", "build", "-gcflags=-L -e", "-o="+dst, path(file)) // TODO(gri) no need for -gcflags=-L if go tool is adjusted
	out, err := cmd.CombinedOutput()
	if err == nil {
		t.Errorf("expected cgo to fail but it succeeded")
	}

	lines := bytes.Split(out, []byte("\n"))
	for _, re := range errors {
		found := false
		for _, line := range lines {
			if re.Match(line) {
				t.Logf("found match for %#q: %q", re, line)

				// stack
				prog.Stacks[k] += int64(v)
			} else {
				// counter
				prog.Counters[k] += int64(v)
			}
			succeeded = true
			fok = true
		}
		if !fok {
			u.logger.Printf("no counters found in %s", f)
		}
	}
	if !succeeded {
		return "", fmt.Errorf("none of the %d count files for %s contained counters", len(countFiles), expiryDate)
	}
	// 1. generate the local report

			Value:         spcs[0].Value,
			GlobalDefault: spcs[0].GlobalDefault,
		},
	}

	for k, v := range errorCases {
		if errs := ValidatePriorityClass(&v); len(errs) == 0 {
			t.Errorf("Expected error for %s, but it succeeded", k)
		}
	}
}

func TestValidatePriorityClassUpdate(t *testing.T) {
	preemptLowerPriority := core.PreemptLowerPriority
	preemptNever := core.PreemptNever

	old := scheduling.PriorityClass{

public class DefaultTestSuccessResult extends AbstractTestResult implements InternalTestSuccessResult {
    public DefaultTestSuccessResult(long startTime, long endTime) {
        super(startTime, endTime, "succeeded");
    }

		{
			// Test recycler success with some events
			name:      "RecyclerSuccess",
			createPod: newPod("podRecyclerSuccess", v1.PodPending, ""),
			eventSequence: []watch.Event{
				// Pod gets Running and Succeeded
				newPodEvent(watch.Added, "podRecyclerSuccess", v1.PodPending, ""),
				newEvent(v1.EventTypeNormal, "Successfully assigned recycler-for-podRecyclerSuccess to 127.0.0.1"),

public class DefaultSuccessResult extends AbstractOperationResult implements InternalSuccessResult {
    public DefaultSuccessResult(long startTime, long endTime) {
        super(startTime, endTime, "succeeded");
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.testkit.runner;

/**
 * Thrown when executing a build that was expected to fail, but succeeded.
 *
 * @since 2.6
 * @see GradleRunner#buildAndFail()
 */
public class UnexpectedBuildSuccess extends UnexpectedBuildResultException {
    public UnexpectedBuildSuccess(String message, BuildResult buildResult) {

	log.SetOutput(lOut)
	log.SetFlags(0)

	lw := errWriter{err: errors.New("Write Error!")}
	wl := NewWriteLogger("write:", lw)
	if _, err := wl.Write([]byte("Hello, World!")); err == nil {
		t.Fatalf("Unexpectedly succeeded to write: %v", err)
	}

	wantLogWithHex := fmt.Sprintf("lw: write: %x: %v\n", "", "Write Error!")
	if g, w := lOut.String(), wantLogWithHex; g != w {
		t.Errorf("WriteLogger mismatch\n\tgot:  %q\n\twant: %q", g, w)
	}