}

    def checkTestCases(int total, int succeeded, int failed) {
        def tests = resultsNode.@tests as int
        def disabled = resultsNode.@disabled as int
        def testFailed = resultsNode.@failures as int
        def run = tests - disabled
        def testSucceeded = tests - failed
        assert run == total
        assert testSucceeded == succeeded
        assert testFailed == failed
        return true

    }

    def "runs tasks"() {
        when:
        controller.scheduleAndRunTasks()

        then:
        1 * workController.scheduleAndRunRequestedTasks(null) >> ExecutionResult.succeeded()

        and:
        1 * finishExecutor.finishBuildTree([]) >> null
    }

    def "runs tasks and collects failure to schedule and execute tasks"() {
        def failure = new RuntimeException()

                  FloatType::getF32(context.get()), 3.0, 2, -128, 127));

  auto dense_attr =
      GetDenseAttrFromTensorProtoAttr(GetQint8Tensor(), result_tensor_type);

  ASSERT_TRUE(succeeded(dense_attr));
  EXPECT_THAT(dense_attr->getValues<int8_t>(), testing::SizeIs(4));
  EXPECT_EQ(dense_attr->getValues<int8_t>()[0], 1);
  EXPECT_EQ(dense_attr->getValues<int8_t>()[1], 2);

        return
      }
    }
  )mlir");

  FailureOr<SmallVector<AssetFileDef>> asset_file_defs =
      ConvertAssetArgs(*module_op);

  EXPECT_TRUE(succeeded(asset_file_defs));
  EXPECT_THAT(*asset_file_defs, SizeIs(1));

  const AssetFileDef& asset_file_def = *asset_file_defs->begin();
  EXPECT_THAT(asset_file_def.filename(), Eq("file_0.txt"));

			// The current succeeded interval is behind, so we can move to the next.
			succeededPointer++
		} else if succeededIndexes[succeededPointer].Last > ruleIndexes[rulePointer].Last {
			// The current rule interval is behind, so we can move to the next.
			rulePointer++
		} else {
			// Both intervals end at the same position, we can move to the next succeeded, and next rule.
			succeededPointer++
			rulePointer++

      func.return %2 : tensor<*xi32>
    }
  })";

  CellReader<int64_t> error(kHasTpuPartitionedCallStreamzName);
  CreateModule(kMlirModuleStr);

  auto result = Run();

  EXPECT_TRUE(result.succeeded());

  EXPECT_EQ(error.Delta("true"), 1);
  EXPECT_EQ(error.Delta("false"), 0);
}

TEST_F(InferenceMetricsPassTest, RecordsFalseForNonTPUPartitionedCallOp) {
  static constexpr char kMlirModuleStr[] = R"(

	resizeStatus v1.ClaimResourceStatus

	// pvcAlreadyUpdated if true indicates that although we are calling NodeExpandVolume on the kubelet
	// PVC has already been updated - possibly because expansion already succeeded on different node.
	// This can happen when a RWX PVC is expanded.
	pvcAlreadyUpdated bool
}

func newNodeExpander(resizeOp nodeResizeOperationOpts, client clientset.Interface, recorder record.EventRecorder) *NodeExpander {

import (
	"os/exec"
	"strings"
)

func main() {
	out, err := exec.Command("go", "run", "fixedbugs/issue9862.go").CombinedOutput()
	outstr := string(out)
	if err == nil {
		println("go run issue9862.go succeeded, should have failed\n", outstr)
		return
	}
	if !strings.Contains(outstr, "symbol too large") {
		println("go run issue9862.go gave unexpected error; want symbol too large:\n", outstr)
	}

      %0 = "tf.Const"() {value = dense<1000> : tensor<1xi32>} : () -> tensor<1xi32>
      func.return %0 : tensor<1xi32>
    }
  })";

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

  EXPECT_TRUE(result.succeeded());
}

TEST_F(VerifyNoOutsideCompilationMarkersPassTest,
       FailsXlaOutsideCompilationMarkers) {
  static constexpr char kMlirModuleStr[] = R"(

      func.return %1 : tensor<6x3x!tf_type.qint8>
    }
  })";
  CreateModule(kMlirModuleStr);
  CellReader<int64_t> reader(kMetricsName);

  auto result = Run();

  EXPECT_TRUE(result.succeeded());
  EXPECT_EQ(reader.Delta("tf.ConcatV2"), 1);
  EXPECT_EQ(reader.Delta("func.return"), 1);
  EXPECT_EQ(reader.Delta("func.func"), 0);
}

TEST_F(LegalizeTfTypesTest, RecordsStreamzNoQuantOps) {