CellReader<int64_t> dynamism_function_counter(
      kDynamismFunctionCounterStreamzName);

  CreateModule(kMlirModuleStr);
  auto result = Run();

  EXPECT_TRUE(result.succeeded());
  EXPECT_EQ(dynamism_function_counter.Delta(kNotDynamicFunctionName), 1);
}

TEST_F(InputLoweringMetricsPassTest, CountsDynamicOps) {
  static constexpr char kMlirModuleStr[] = R"(

  // incompatible_shape_error is `true` (what is also checked by the verifier).
  if (succeeded(RewriteEqOp<TF::EqualOp>(op, rewriter))) return success();
  if (succeeded(RewriteEqOp<TF::NotEqualOp>(op, rewriter))) return success();
  if (succeeded(RewriteBatchMatMulV2Op(op, rewriter))) return success();

  return failure();
}

            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)

 * 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) {

 */

package org.gradle.process.internal;

public enum ExecHandleState {
    INIT(false),
    STARTING(false),
    STARTED(false),
    ABORTED(true),
    FAILED(true),
    DETACHED(true),
    SUCCEEDED(true);

    private final boolean terminal;

    ExecHandleState(boolean terminal) {
        this.terminal = terminal;
    }

    public boolean isTerminal() {
        return terminal;
    }

  mlir::tf_device::ClusterFuncOp cluster_func_op = cluster_func_ops.front();

  tensorflow::tpu::TPUCompileMetadataProto compile_metadata;

  ASSERT_TRUE(mlir::succeeded(SetMetadataProtoFromClusterFuncOp(
      cluster_func_op,
      /*num_replicas=*/1, /*num_cores_per_replica=*/1, {}, &compile_metadata)));

  tensorflow::tpu::TPUCompileMetadataProto expected_compile_metadata;

/**
 * Allows an execution action to provide status information to the execution context.
 *
 * <p>Note: if the action does not call {@link #onFailure(Throwable)}, then the execution is assumed to have
 * succeeded.</p>
 */
public interface ExecutionListener {
    /**
     * Reports a failure of the execution. Note that it is the caller's responsibility to perform any logging of the
     * failure.
     *

		write("b", i, `package p
var
var
var
var
var
`)
	}

	cmd := exec.Command(args[0], args[1:]...)
	output, err := cmd.CombinedOutput()
	if err == nil {
		panic("compile succeeded unexpectedly")
	}
	if !bytes.Contains(output, []byte("syntax error:")) {
		panic(fmt.Sprintf(`missing "syntax error" in compiler output; got: 
%s`, output))
	}