}
}

// -----

// Tests that outputs are correctly merged and fed from TPU computation for
// tiled output sharding with MAXIMAL sharding for one of the output and OTHER
// for latter output.

// The following OpSharding is used for TPU computation outputs in below test:
// Proto debug string:
//  output 0
//  type: MAXIMAL
//  tile_assignment_dimensions: 1

      return op->emitOpError()
             << "output #" << i << " should be " << expected_output_type
             << " instead got " << output.getType();
  }
  return success();
}

mlir::LogicalResult SplitOp::verify() {
  SplitOp op = *this;
  int64_t num_splits = op.getNumSplits();
  if (op.getNumResults() != num_splits)

		add chain ip kube-proxy filter-output { type filter hook output priority -110 ; }
		add rule ip kube-proxy filter-output ct state new jump service-endpoints-check
		add rule ip kube-proxy filter-output ct state new jump firewall-check
		add chain ip kube-proxy filter-output-post-dnat { type filter hook output priority -90 ; }
		add rule ip kube-proxy filter-output-post-dnat ct state new jump cluster-ips-check

  return rewriter.create<arith::ConstantOp>(output.getLoc(), attr_type, attr);
}

Value ExpandedDynamicShape(PatternRewriter& rewriter, Value input,
                           DenseIntElementsAttr broadcast_dimensions,
                           Value output) {
  assert(mlir::cast<ShapedType>(output.getType()) &&
         "output type must be of ShapedType");

}

void CreateSubgraphTouchingRefVar(const Scope& s) {
  Output variable =
      ops::Variable(s.WithOpName("variable"), PartialTensorShape{}, DT_FLOAT);
  Output read = ops::Identity(s.WithOpName("read_ref_var"), variable);
  Output neg = ops::Negate(s.WithOpName("negate_ref"), read);
  Output add = ops::Add(s.WithOpName("add_ref"), neg, neg);

  Output constant =

  // expected-error @+1 {{rank of input tensor is 2. rank of output tensor is expected to be 1, instead of 2.}}
  %0 = "tf.Bitcast"(%arg0) : (tensor<3x2xi16>) -> tensor<3x2xi32>
  func.return %0 : tensor<3x2xi32>
}

// -----

func.func @testBitcast_v5(%arg0: tensor<3x2xi16>) -> tensor<2xi32> {
  // expected-error @+1 {{the 0th dim of output tensor is 2. It is not equal to the one in input tensor, which is 3}}

    }

    func.return %1 : tensor<2xi32>
  }

  //  Tests that all inputs to a function are passed and all outputs are returned for an outside compilation cluster
  //  with dynamic-shaped inputs/outputs. This test case tests that if another outside compiled returns
  //  only statically-shaped outputs, the value consumed by an outside compiled op with some dynamically shaped inputs is
  //  sent back to the host.

            if (!s.ok()) {
              return;
            }
            node_map[n] = copy;
          }

          // Only handle input edges. Output edges will be added later as
          // its output nodes' input edges.
          for (auto e : n->in_edges()) {
            if (node_map.find(e->src()) == node_map.end()) {
              s = errors::Internal("Cannot find node image for ",

  %cst = "tfl.no_value"() {value = unit} : () -> none
  // expected-error @+1 {{expect output type has rank = 4, got output type tensor<64x84x32xf32>}}

    func.return %0 : tensor<*xi32>
  }

  // CHECK-LABEL: func @call_in_graph_1
  func.func @call_in_graph_1(%arg0: tensor<?x?x?x?xbf16>, %arg1: tensor<5x5x1x32xbf16>) -> tensor<*xbf16> {
    // CHECK: tf_executor.fetch %outputs : tensor<?x?x?x32xbf16>
    %0 = tf_executor.graph {
      %1:2 = tf_executor.island wraps "tf.PartitionedCall"(%arg0, %arg1) {