def values = descriptor.getAvailableValues()

        then:
        values == ["dynValue1", "dynValue2"] as Set
        1 * optionValueMethod.invoke(_,_) >> ["dynValue1", "dynValue2"]
    }

    def "should sort alphabetically by name by default"() {
        given:

        options[10].name == "stringValue"
        options[10].description == "string value"
        options[10].argumentType == String
        options[10].availableValues == ["dynValue1", "dynValue2"] as Set
    }

    def "can read options linked to property getter methods of a task"() {
        when:

	LiteralStyle
)

// NewEmptyDynValue returns the zero-valued DynValue.
func NewEmptyDynValue() *DynValue {
	// note: 0 is not a valid parse node identifier.
	dv, _ := NewDynValue(0, nil)
	return dv
}

// NewDynValue returns a DynValue that corresponds to a parse node id and value.
func NewDynValue(id int64, val interface{}) (*DynValue, error) {
	dv := &DynValue{ID: id}
	err := dv.SetValue(val)
	return dv, err
}

	if err != nil {
		t.Errorf("fail to get cel type: %s", err)
	}
	if expT.GetMapType() == nil {
		t.Errorf("got %v, wanted CEL map type", expT)
	}
}

func testValue(t *testing.T, id int64, val interface{}) *DynValue {
	t.Helper()
	dv, err := NewDynValue(id, val)
	if err != nil {
		t.Fatalf("NewDynValue(%d, %v) failed: %v", id, val, err)
	}
	return dv

	if helloVal.Equal(types.String("hello")) != types.True {
		t.Errorf("got %v, wanted types.String('hello')", helloVal)
	}
}

func testValue(t *testing.T, id int64, val interface{}) *apiservercel.DynValue {
	t.Helper()
	dv, err := apiservercel.NewDynValue(id, val)
	if err != nil {
		t.Fatalf("NewDynValue(%d, %v) failed: %v", id, val, err)
	}
	return dv

			if err != nil {
				t.Skip("The system may not support ELF, skipped.")
			}
			defer elfFile.Close()

			flags, err := elfFile.DynValue(elf.DT_FLAGS)
			if err != nil {
				t.Fatalf("failed to get DT_FLAGS: %v", err)
			}

			flags1, err := elfFile.DynValue(elf.DT_FLAGS_1)
			if err != nil {
				t.Fatalf("failed to get DT_FLAGS_1: %v", err)
			}

	if err != nil {
		t.Fatalf("could not read %s: %v", testdata, err)
	}
	defer f.Close()

	vals, err := f.DynValue(DT_VERNEEDNUM)
	if err != nil {
		t.Fatalf("DynValue(DT_VERNEEDNUM): got unexpected error %v", err)
	}

	if len(vals) != 1 || vals[0] != 1 {
		t.Errorf("DynValue(DT_VERNEEDNUM): got %v, want [1]", vals)
	}
}

func TestIssue59208(t *testing.T) {

		if t == tag {
			s, ok := getString(str, int(v))
			if ok {
				all = append(all, s)
			}
		}
	}
	return all, nil
}

// DynValue returns the values listed for the given tag in the file's dynamic
// section.
func (f *File) DynValue(tag DynTag) ([]uint64, error) {
	ds := f.SectionByType(SHT_DYNAMIC)
	if ds == nil {
		return nil, nil
	}
	d, err := ds.Data()
	if err != nil {

pkg debug/elf, const R_PPC64_REL24_P9NOTOC R_PPC64 #60348
pkg debug/elf, method (DynFlag1) GoString() string #56887
pkg debug/elf, method (DynFlag1) String() string #56887
pkg debug/elf, method (*File) DynValue(DynTag) ([]uint64, error) #56892
pkg debug/elf, type DynFlag1 uint32 #56887
pkg encoding/binary, var NativeEndian nativeEndian #57237
pkg errors, var ErrUnsupported error #41198

		{"VoidType", Type, 0},
		{"VoidType.CommonType", Field, 0},
	},
	"debug/elf": {
		{"(*File).Close", Method, 0},
		{"(*File).DWARF", Method, 0},
		{"(*File).DynString", Method, 1},
		{"(*File).DynValue", Method, 21},
		{"(*File).DynamicSymbols", Method, 4},
		{"(*File).ImportedLibraries", Method, 0},
		{"(*File).ImportedSymbols", Method, 0},
		{"(*File).Section", Method, 0},