tests := []struct {
		desc   string
		in1    string
		in2    string
		expect bool
	}{
		{
			desc:   "yaml-equal",
			in1:    `foo: bar`,
			in2:    `foo: bar`,
			expect: true,
		},
		{
			desc:   "bad-yaml-1",
			in1:    "O#JF*()#",
			in2:    `foo: bar`,
			expect: false,
		},
		{
			desc:   "bad-yaml-2",
			in1:    `foo: bar`,
			in2:    "#OHJ*#()F",

      + custom.withGradientMode('hue')
      + if std.length(desc) > 0 then
        timeSeries.panelOptions.withDescription(desc)
      else {},

    simple(title, targets, desc=''):
      self.base(title, targets, desc)
      + options.legend.withCalcs([])
      + options.legend.withDisplayMode('list'),

    short(title, targets, desc=''):
      self.base(title, targets, desc)
      + timeSeries.standardOptions.withUnit('short')

func TestAddSpecRoot(t *testing.T) {
	tests := []struct {
		desc   string
		in     string
		expect string
		err    error
	}{
		{
			desc: "empty",
			in:   ``,
			expect: `spec: {}
`,
			err: nil,
		},
		{
			desc: "add-root",
			in: `
a: va
b: foo`,
			expect: `spec:
  a: va
  b: foo
`,
			err: nil,
		},
		{
			desc:   "err",
			in:     `i can't be yaml, can I?`,
			expect: ``,

        int start = dstIndex;
        byte[] descr;
        int which = subCommand == NET_SERVER_ENUM2 ? 0 : 1;

        try {
            descr = DESCR[which].getBytes( "ASCII" );
        } catch( UnsupportedEncodingException uee ) {
            return 0;
        }

        writeInt2( subCommand & 0xFF, dst, dstIndex );
        dstIndex += 2;
        System.arraycopy( descr, 0, dst, dstIndex, descr.length );

)

func TestHttpProber(t *testing.T) {
	tests := []struct {
		desc                string
		statusCode          int
		expectedProbeResult ProbeResult
		expectedError       error
	}{
		{
			desc:                "Healthy - 200 status code",
			statusCode:          200,
			expectedProbeResult: Healthy,
			expectedError:       nil,
		},
		{
			desc:                "Unhealthy - 500 status code",
			statusCode:          500,

            desc: "don't use v3; v2 is orders of magnitude higher performance"
          - pkg: k8s.io/apimachinery/pkg/util/sets
            desc: "use istio.io/istio/pkg/util/sets"
          - pkg: k8s.io/utils/env
            desc: "use istio.io/istio/pkg/env"
          - pkg: k8s.io/utils/strings/slices
            desc: "use istio.io/istio/pkg/slices"
          - pkg: k8s.io/utils/pointer
            desc: "use istio.io/istio/pkg/ptr"

	tests := []struct {
		desc     string
		yamlStr  string
		want     []string
		wantErrs bool
	}{
		{
			desc:    "nil success",
			yamlStr: "",
			want:    nil,
		},
		{
			desc: "all components disabled",
			yamlStr: `
components:
  pilot:
    enabled: false
  ingressGateways:
  - enabled: false`,
			want: nil,
		},
		{
			desc: "only pilot component enabled",
			yamlStr: `

    }


    @Override
    protected int writeParametersWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;
        byte[] descr;
        int which = getSubCommand() == NET_SERVER_ENUM2 ? 0 : 1;

        try {
            descr = DESCR[ which ].getBytes("ASCII");
        }
        catch ( UnsupportedEncodingException uee ) {
            return 0;
        }

}

func TestReader(t *testing.T) {
	var vectors = []struct {
		desc   string
		input  []byte
		output []byte
		fail   bool
	}{{
		desc: "hello world",
		input: mustDecodeHex("" +
			"425a68393141592653594eece83600000251800010400006449080200031064c" +
			"4101a7a9a580bb9431f8bb9229c28482776741b0",
		),
		output: []byte("hello world\n"),
	}, {
		desc: "concatenated files",
		input: mustDecodeHex("" +

        ParameterizedClassDesc desc = ParameterizedClassDescFactory.createParameterizedClassDesc(method, 0, map);
        assertThat(desc.getRawClass(), is(sameClass(Set.class)));
        ParameterizedClassDesc[] args = desc.getArguments();
        assertThat(args.length, is(1));
        assertThat(args[0].getRawClass(), is(sameClass(Integer.class)));