}

  @Test
  @TestMetadata("arrayWithInc.kt")
  public void testArrayWithInc() {
    runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/arrayWithInc.kt");
  }

  @Test
  @TestMetadata("binaryExpressionWithString.kt")
  public void testBinaryExpressionWithString() {
    runTest("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/binaryExpressionWithString.kt");
  }

	if err != nil {
		return err
	}
	if !exists {
		return nil
	}
	out, err := runner.run(opDeleteRule, fullArgs)
	if err != nil {
		return fmt.Errorf("error deleting rule: %v: %s", err, out)
	}
	return nil
}

func (runner *runner) IsIPv6() bool {
	return runner.protocol == ProtocolIPv6
}

func (runner *runner) Protocol() Protocol {
	return runner.protocol

  void RunTest(const Output& x, const TensorShape& x_shape, const Output& y,
               const TensorShape& y_shape) {
    TF_ASSERT_OK(scope_.status());
    float max_error;
    TF_ASSERT_OK((ComputeGradientError<float, float, float>(
        scope_, {x}, {x_shape}, {y}, {y_shape}, &max_error)));
    EXPECT_LT(max_error, 1e-3);
  }

 */

package org.gradle.testkit.runner

import org.gradle.internal.nativeintegration.ProcessEnvironment
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.testfixtures.internal.NativeServicesTestFixture
import org.gradle.testkit.runner.fixtures.InjectsPluginClasspath
import org.gradle.testkit.runner.fixtures.InspectsBuildOutput

After creating and configuring a runner instance, the build can be executed via the link:{javadocPath}/org/gradle/testkit/runner/GradleRunner.html#build--[GradleRunner.build()] or link:{javadocPath}/org/gradle/testkit/runner/GradleRunner.html#buildAndFail--[GradleRunner.buildAndFail()] methods depending on the anticipated outcome.

The following demonstrates the usage of the Gradle runner in a Java JUnit test:

    final AtomicInteger numCalls = new AtomicInteger();

    Runnable runMe =
        new Runnable() {
          @Override
          public void run() {
            numCalls.incrementAndGet();
            throw new RuntimeException("FAKE EXCEPTION!");
          }
        };

    e.execute(runMe);
    e.execute(runMe);
    fakePool.runAll();

    assertEquals(2, numCalls.get());
  }

	var usecases = []struct {
		name                string
		runner              Runner
		expectedCmdAndFlags map[string][]string
		setAdditionalFlags  func(*pflag.FlagSet)
	}{
		{
			name:   "when there are no phases, cmd should be left untouched",
			runner: Runner{},
		},
		{
			name: "phases should not inherits any parent flags by default",
			runner: Runner{
				Phases: []Phase{phaseBuilder4("foo", nil)},
			},

        """

        when:
        def runner = GradleRunner.create()
        runner.withJvmArguments("-javaagent:${agentJar}")
        if (!GradleContextualExecuter.embedded) {
            runner.withGradleInstallation(buildContext.gradleHomeDir)
        }
        runner.withArguments("--configuration-cache")
        runner.forwardOutput()
        runner.withProjectDir(testDirectory)
        runner.withPluginClasspath([new File("some-dir")])

        when:
        def runner = createRunner()
            .withProjectDir(workingDir)
            .withArguments(arguments)

        then:
        runner.projectDir == workingDir
        runner.arguments == arguments
        runner.pluginClasspath == []
        !runner.debug
        !runner.standardOutput
        !runner.standardError
        !runner.standardInput
        0 * testKitDirProvider.getDir()

				func(cmd string, args ...string) exec.Cmd { return fakeexec.InitFakeCmd(&fcmd, cmd, args...) },
			},
		}
		ipt := New(fexec, ProtocolIPv4)
		runner := ipt.(*runner)
		if testCase.Expected != runner.hasCheck {
			t.Errorf("Expected result: %v, Got result: %v", testCase.Expected, runner.hasCheck)
		}
	}
}

func TestIPTablesCommands(t *testing.T) {
	testCases := []struct {
		funcName    string
		protocol    Protocol