tests := []struct {
		name    string
		printer func() ([]metav1.TableRow, error)
	}{
		{
			name: "Pod",
			printer: func() ([]metav1.TableRow, error) {
				return printPod(&api.Pod{}, printers.GenerateOptions{})
			},
		},
		{
			name: "PodTemplate",
			printer: func() ([]metav1.TableRow, error) {
				return printPodTemplate(&api.PodTemplate{}, printers.GenerateOptions{})
			},
		},
		{

}

void ConstBytesAttr::print(mlir::AsmPrinter& printer) const {
  StringRef bytes_str = getValue();
  // Elide the attribute if flag is set.
  std::optional<int64_t> limit = OpPrintingFlags().getLargeElementsAttrLimit();
  printer << " : \"";
  if (limit && limit.value() < bytes_str.size()) {
    printer << "__elided__";
  } else {
    printer << "0x" << llvm::toHex(bytes_str);
  }
  printer << "\"";

	"previous_track_button":                "\u23ee\ufe0f",
	"prince":                               "\U0001f934",
	"princess":                             "\U0001f478",
	"printer":                              "\U0001f5a8\ufe0f",
	"probing_cane":                         "\U0001f9af",
	"puerto_rico":                          "\U0001f1f5\U0001f1f7",
	"punch":                                "\U0001f44a",

func printPodList(podList *api.PodList, options printers.GenerateOptions) ([]metav1.TableRow, error) {
	rows := make([]metav1.TableRow, 0, len(podList.Items))
	for i := range podList.Items {
		r, err := printPod(&podList.Items[i], options)
		if err != nil {
			return nil, err
		}
		rows = append(rows, r...)
	}
	return rows, nil
}

func printPod(pod *api.Pod, options printers.GenerateOptions) ([]metav1.TableRow, error) {

// CHECK-LABEL: testValidWhileRegionNoInputs
func.func private @printer(tensor<i32>) -> ()
func.func @testValidWhileRegionNoInputs() -> () {
  "tf.WhileRegion"() (
    {
      %true = arith.constant dense<1> : tensor<i1>
      "tf.Yield"(%true) : (tensor<i1>) -> ()
    },
    {
      %one = arith.constant dense<1> : tensor<i32>
      func.call @printer(%one) : (tensor<i32>) -> ()

    OptionalAttr<TypeAttr>:$input_to_output_intermediate,
    OptionalAttr<TypeAttr>:$effective_hidden_scale_intermediate
  );

  let results = (outs AnyTensor:$output);

  // TODO(fengliuai): customize printer and parser to not display
  // empty region.
  let regions = (region AnyRegion:$internal);

  let hasOptions = 1;

  let hasCanonicalizer = 1;

  let hasVerifier = 1;

	if r0 != 0 {

	return (*abi.Type)(abi.NoEscape(unsafe.Pointer(v.typ_)))
}

// pointer returns the underlying pointer represented by v.
// v.Kind() must be Pointer, Map, Chan, Func, or UnsafePointer
// if v.Kind() == Pointer, the base type must not be not-in-heap.
func (v Value) pointer() unsafe.Pointer {
	if v.typ().Size() != goarch.PtrSize || !v.typ().Pointers() {
		panic("can't call pointer on a non-pointer Value")
	}
	if v.flag&flagIndir != 0 {

					Parallelism:             pointer.Int32(5),
					ActiveDeadlineSeconds:   pointer.Int64(2),
					TTLSecondsAfterFinished: pointer.Int32(1),
				},
			},
			update: func(job *batch.Job) {
				job.Spec.Parallelism = pointer.Int32(2)
				job.Spec.ActiveDeadlineSeconds = pointer.Int64(3)
				job.Spec.TTLSecondsAfterFinished = pointer.Int32(2)
				job.Spec.ManualSelector = pointer.Bool(true)

					},
					ClaimMappings: apiserver.ClaimMappings{
						Username: apiserver.PrefixedClaimOrExpression{
							Claim:  "username",
							Prefix: pointer.String(""),
						},
						Groups: apiserver.PrefixedClaimOrExpression{
							Claim:  "groups",
							Prefix: pointer.String(""),
						},
					},
				},
				now: func() time.Time { return now },
			},