EXPECT_FALSE(ImportXlaComputationIntoModule(bad_computation).ok());
}

TEST_F(Tf2XlaRewriterTest, ImportsSingleComputation) {
  XlaBuilder builder("test_builder");
  XlaComputation to_apply;
  {
    auto sub_builder = builder.CreateSubBuilder("add");
    auto arg0 = Parameter(sub_builder.get(), 0,
                          ShapeUtil::MakeScalarShape(xla::F32), "x");

        key = "application/x-lharc";
        assertTrue(extractorFactory.getExtractor(key) instanceof LhaExtractor);

    }

    public void test_builder() {
        assertEquals("test", extractorFactory.builder(new ByteArrayInputStream("test".getBytes()), null).extract().getContent());
        assertEquals("test",

  const auto cast_op_name = scope.GetUniqueNameForOp("Cast");

  auto cast_builder = NodeBuilder(cast_op_name, "Cast")
                          .Input(orig_const)
                          .Attr("DstT", DataTypeToEnum<DstT>::v());
  scope.UpdateBuilder(&cast_builder);
  Node* ret;
  scope.UpdateStatus(cast_builder.Finalize(scope.graph(), &ret));
  if (!scope.ok()) return Output();

    }

    @Override
    public void text(String textFragment) {
        textBuilder.append(textFragment);
        if (!textFragment.endsWith(SystemProperties.getInstance().getLineSeparator())) {
            return;
        }
        String text = textBuilder.toString();
        textBuilder = new StringBuilder();
        synchronized (testDescriptors) {

                             Node* arg_node) {
  NodeDefBuilder ret_builder(absl::StrCat("ret_", arg_idx), "_Retval");
  ret_builder.Attr("T", data_type);
  ret_builder.Attr("index", arg_idx);
  ret_builder.Input(arg_node->name(), 0, data_type);
  NodeDef ret_def;
  TF_RETURN_IF_ERROR(ret_builder.Finalize(&ret_def));
  TF_ASSIGN_OR_RETURN(Node * ret_node, function_body.graph->AddNode(ret_def));

        subprojects {
            apply plugin: "java-library"
        }
        project(":buildD-impl") {
            dependencies {
                api(project(":buildD-api"))
                implementation("org.test:buildE-api:1.0")
            }
        }
        """
        includedBuilds << buildD
        def buildE = multiProjectBuild("buildE", ['buildE-api', 'buildE-impl'])
        buildE.buildFile << """

func compareToGolden(t *testing.T, name string, actual string) {
	t.Helper()
	gotBytes := []byte(actual)
	goldenFile := filepath.Join("testdata", name+".golden")
	testutil.CompareContent(t, gotBytes, goldenFile)
}

func TestBuilder(t *testing.T) {
	cases := []struct {
		name         string
		expectV4     bool
		expectV6     bool
		config       func(builder *IptablesRuleBuilder)
		sharedGolden bool
	}{
		{
			"insert-single-v4",

	if n := b.Len(); n != len(got) {
		t.Errorf("Len: got %d; but len(String()) is %d", n, len(got))
	}
	if n := b.Cap(); n < len(got) {
		t.Errorf("Cap: got %d; but len(String()) is %d", n, len(got))
	}
}

func TestBuilder(t *testing.T) {
	var b Builder
	check(t, &b, "")
	n, err := b.WriteString("hello")
	if err != nil || n != 5 {
		t.Errorf("WriteString: got %d,%s; want 5,nil", n, err)
	}
	check(t, &b, "hello")