TensorShape d1_shape({2});
  TensorShape d2_shape({2, 2});
  std::vector<Output> indices = {Const(scope_, 2), Const(scope_, {1, 0})};
  std::vector<Output> data = {
      Placeholder(scope_, DT_FLOAT, Placeholder::Shape(d1_shape)),
      Placeholder(scope_, DT_FLOAT, Placeholder::Shape(d2_shape))};
  auto y = DynamicStitch(scope_, indices, data);
  TensorShape y_shape({3, 2});
  RunTest(data, {d1_shape, d2_shape}, {y}, {y_shape});
}

import com.google.errorprone.refaster.annotation.Placeholder;

/**
 * Refaster rules to rewrite usages of {@code com.google.common.collect.TreeTraverser} in terms of
 * {@code com.google.common.graph.Traverser}.
 */
@SuppressWarnings("DefaultPackage")
public class TraverserRewrite {
  abstract class TreeTraverserPreOrder<N> {
    @Placeholder
    abstract Iterable<N> getChildren(N node);

    @BeforeTemplate

spec:
  destination:
    name: in-cluster
    namespace: argocd
    server: ''
  sources:
  - path: istio
    repoURL: '{repo-placeholder}'
    targetRevision: HEAD
  - path: application
    repoURL: '{repo-placeholder}'
    targetRevision: HEAD
    directory:
      include: application.yaml
  project: default
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

    EXPECT_LT(max_error, 1e-4);
  }

  Scope scope_;
};

TEST_F(ManipGradTest, RollGrad) {
  TensorShape shape({5, 4, 3});
  auto x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(shape));
  auto y = Roll(scope_, x, {2, 1}, {0, 1});
  RunTest(x, shape, y, shape);
}

}  // namespace

node {
  name: "input0"
  op: "Placeholder"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
}
versions {
  producer: 29
  min_consumer: 12
}

# Verify that functions from the library are properly imported.

# CHECK-LABEL:  func @main() {
# CHECK:    "tf.Placeholder"

    example:

    ```
    TEST_F(ArrayGradTest, IdentityGrad) {
      TensorShape shape({5, 2});
      auto x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(shape));
      auto y = Identity(scope_, x);
      RunTest(x, shape, y, shape);
    }
    ```

NOTE: There are some ops that require features from the C++ API that are not yet
implemented.

TEST(ClientSessionTest, CallableWithCustomThreadPool) {
  Scope root = Scope::NewRootScope();
  int num_threads = 3;

  TensorShape data_shape({1, 1});
  auto a = Placeholder(root, DT_INT32, Placeholder::Shape(data_shape));
  auto b = Placeholder(root, DT_INT32, Placeholder::Shape(data_shape));
  auto c = BatchMatMul(root, a, b);
  ClientSession session(root);
  std::vector<Tensor> outputs;

  auto inter_op_threadpool =

  TF_ASSERT_OK(root.graph()->AddFunctionLibrary(flib));
  auto predicate = ops::Placeholder(root.WithOpName("pred"), DT_BOOL);
  auto placeholder = ops::Placeholder(root.WithOpName("A"), DT_INT32);
  std::vector<NodeBuilder::NodeOut> if_inputs(
      {NodeBuilder::NodeOut(placeholder.node())});
  Node* if_node;
  TF_ASSERT_OK(
      NodeBuilder(kFunctionalIfNodeName, "If", &root.graph()->flib_def())

# CHECK: build_graph(out_dir)
node: {
  name: "x"
  op: "Placeholder"
  attr: {
    key: "shape"
    value: {
      shape: {
        dim: {
          size: -1
        }
      }
    }
  }
  attr: {
    key: "dtype"
    value: {
      type: DT_INT32
    }
  }
}
node: {
  name: "y"
  op: "Placeholder"
  attr: {
    key: "shape"
    value: {
      shape: {

// CHECK: "extra_type_attr"
// CHECK-NEXT:    value
// CHECK-NEXT:      list
// CHECK-NEXT:        type: DT_INT32
// CHECK-NEXT:        type: DT_FLOAT

// CHECK-LABEL: function
// CHECK: name: "plain"
// CHECK: Placeholder
// CHECK: key: "type"
// CHECK: type: DT_INT8

func.func @main(%arg0 : tensor<16xf32>) {
  tf_executor.graph {