slice_begin, slice_end, slice_stride);
  return true;
}

OpFoldResult StridedSliceOp::fold(FoldAdaptor) {
  // Fold StridedSlice operation if it extracts statically known dimensions.
  //
  // For example,
  //
  //   %shape  = tf.Shape(%arg)                   // %arg: tensor<?x2x3x1xf32>
  //   %height = tf.StridedSlice(%shape, 1, 2, 1)
  //

                                PatternRewriter& rewriter) const override;
};

LogicalResult FoldConstantCaseOp::matchAndRewrite(
    TF::CaseOp op, PatternRewriter& rewriter) const {
  // Extract the constant cond value.
  DenseIntElementsAttr branch;
  if (!matchPattern(op.getBranchIndex(), m_Constant(&branch))) return failure();

  int index = *branch.getValues<int>().begin();

	response, err = s.client.Do(request)
	c.Assert(err, nil)
	// assert the http response status code.
	c.Assert(response.StatusCode, http.StatusOK)

	var buffer bytes.Buffer
	// extract the body of the response.
	responseBody, err := io.ReadAll(response.Body)
	c.Assert(err, nil)
	// assert the http response body content.
	c.Assert(true, bytes.Equal(responseBody, buffer.Bytes()))
}

Supporting class for matching a feature of an object. FeatureMatcher(Matcher<? super U>, String, String) - Constructor for class org.hamcrest.FeatureMatcher Constructor featureValueOf(T) - Method in class org.hamcrest.FeatureMatcher Implement this to extract the interesting feature. findExpectedType(Class<?>) - Method in class org.hamcrest.internal.ReflectiveTypeFinder H hasItem(Matcher<? super T>) - Static method in class org.hamcrest.core.IsCollectionContaini Creates a matcher for Iterables that only...

  }
  if (padding_attr == tflite::Padding_VALID) {
    return kTfLitePaddingValid;
  }

  return inst->emitOpError() << "Invalid padding attribute: " << padding,
         std::nullopt;
}

// Extracts TfLitePoolParams from a TFL custom op.
// Template parameter, TFLOp, should be a TFL custom op containing attributes
// generated from TfLitePoolParams.
// Returns std::nullopt if conversion fails.
template <typename TFLOp>

  if (failed(InferShapeForFunctionReturnType(func))) return false;

  return false;
}

bool ShapeInference::InferShapeForXlaHostComputeMlir(
    _XlaHostComputeMlirOp host_compute_op) {
  // Extract the module and function.
  // The '_XlaHostComputeMlir` verifier verifies that `host_mlir_module`
  // attribute is well formed, so we just return in case of an error in

    cat "${cert_create_debug_output}" >&2
    echo "=== Failed to generate cloud-pvl-admission certificates: Aborting ===" >&2
    exit 2
  fi
}

# Using provided master env, extracts value from provided key.
#
# Args:
# $1 master env (kube-env of master; result of calling get-master-env)
# $2 env key to use
function get-env-val() {
  local match

    TFL::QConstOp bias_tfl_op;
    bool fuse_bias_constant =
        FindUserOfType<stablehlo::AddOp>(op) && has_i32_output;
    // Get the desired output type and extract any existing fusible bias
    // as `TFL::QConstOp` so that it can be fused with TFL::FullyConnectedOp`.
    const Type output_type = GetOutputTypeAndOptionallyUpdateBias(

		kubeClient:      kubeClient,
		volumePluginMgr: volumePluginMgr,
		recorder:        recorder,
		blkUtil:         blkUtil,
		translator:      csitrans.New(),
	}
}

// OperationGenerator interface that extracts out the functions from operation_executor to make it dependency injectable
type OperationGenerator interface {
	// Generates the MountVolume function needed to perform the mount of a volume plugin

  // depends on an op with static output shape like tf.Const.
  absl::StatusOr<mlir::FunctionType> InferLibFunctionType(
      const FunctionBody& fbody);

  // Extracts arg and ret nodes from FunctionBody.
  void GetArgsAndRetsFromFunctionBody(
      const FunctionBody& fbody,
      absl::InlinedVector<OutputTensor, 4>* arg_nodes,
      absl::InlinedVector<OutputTensor, 4>* ret_nodes,