got := &BugReportConfig{}
	if err := yaml.Unmarshal([]byte(config), got); err != nil {
		t.Fatal(err)
	}

	if !reflect.DeepEqual(got, want) {
		t.Errorf("got:\n%s\nwant:\n%s\n\ndiff (-got, +want):\n%s\n", pretty.Sprint(got), pretty.Sprint(want), cmp.Diff(got, want))
	}
}

func TestUnmarshalSelectionSpec(t *testing.T) {
	include := "ns1,ns2/d1,d2/p1,p2/l1=lv1,l2=lv2/a1=av1,a2=av2/c1,c2"
	want := &SelectionSpec{

	SpewKeys:                true,
	DisablePointerAddresses: true,
	DisableCapacities:       true,
}

// Pretty wrap the spew.Sdump with Indent, and disabled methods like error() and String()
// The output may change over time, so for guaranteed output please take more direct control
func Pretty(a interface{}) string {
	return prettyPrintConfig.Sdump(a)
}

    }

    @Test
    @DisplayName("pretty pretty_test")
    public void ugly_test() {
    }

    @ParameterizedTest
    @CsvSource({"10, 'first'", "20, 'second'"})
    public void parametrized_test(int value, String name) {
        System.out.println(name + " " + value);
    }

    @ParameterizedTest
    @DisplayName("pretty parametrized test")
    @CsvSource({"30, 'third'", "40, 'fourth'"})

		t.Errorf("%s", dump.Pretty(original))
		t.Errorf("%s", dump.Pretty(object))
		return
	}

	// encode (serialize) the deep copy using the provided codec
	data, err := runtime.Encode(codec, object)
	if err != nil {
		if runtime.IsNotRegisteredError(err) {
			t.Logf("%v: not registered: %v (%s)", name, err, dump.Pretty(object))
		} else {

    return *this;
  }

  // Enable printing of debug information. If 'pretty_form' is set to true,
  // debug information is printed in a more readable 'pretty' form but this
  // pretty form is not parsable (so only for human readability).
  MlirDumpConfig& emit_location_information(bool pretty_form = false) {
    this->op_printing_flags.enableDebugInfo(/*enable=*/true, pretty_form);
    return *this;

		t.Fatal(dump.Pretty(actualNodes))
	}
	for i := range expectedNodes {
		currExpected := expectedNodes[i]
		currActual := actualNodes[i]
		if currExpected.uid != currActual.uid {
			t.Errorf("expected %v, got %v", dump.Pretty(currExpected), dump.Pretty(currActual))
		}
	}
	if len(expectedEdges) != len(actualEdges) {
		t.Fatal(dump.Pretty(actualEdges))
	}
	for i := range expectedEdges {

// Deprecated: use NewSerializerWithOptions instead.
func NewSerializer(meta MetaFactory, creater runtime.ObjectCreater, typer runtime.ObjectTyper, pretty bool) *Serializer {
	return NewSerializerWithOptions(meta, creater, typer, SerializerOptions{false, pretty, false})
}

// NewYAMLSerializer creates a YAML serializer that handles encoding versioned objects into the proper YAML form. If typer

	s.AddUnversionedTypes(externalGV, &metav1.Status{})

	utilruntime.Must(runtimetesting.RegisterConversions(s))

	cf := newCodecFactory(s, newSerializersForScheme(s, testMetaFactory{}, CodecFactoryOptions{Pretty: true, Strict: true}))
	codec := cf.LegacyCodec(schema.GroupVersion{Version: "v1"})
	return s, codec
}

var semantic = conversion.EqualitiesOrDie(
	func(a, b runtimetesting.MyWeirdCustomEmbeddedVersionKindField) bool {

				t.Errorf("Test %q: got unexpected error: %v", test.name, err)
			}
			if !reflect.DeepEqual(test.expectedObject, obj) {
				t.Errorf("Test %q: Expected object:\n%s\ngot:\n%s", test.name, dump.Pretty(test.expectedObject), dump.Pretty(obj))
			}
		})
	}

set -o errexit
set -o nounset
set -o pipefail
set -o xtrace

retry() {
  for i in {1..5}; do
    if "$@"
    then
      return 0
    else
      sleep "${i}"
    fi
  done
  "$@"
}

# The root of the build/dist directory
KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/../..
export KUBE_ROOT

# Runs benchmark integration tests, producing pretty-printed results