type UnknownUserError string

func (e UnknownUserError) Error() string {
	return "user: unknown user " + string(e)
}

// UnknownGroupIdError is returned by [LookupGroupId] when
// a group cannot be found.
type UnknownGroupIdError string

func (e UnknownGroupIdError) Error() string {
	return "group: unknown groupid " + string(e)
}

// UnknownGroupError is returned by [LookupGroup] when

func LookupGroup(name string) (*Group, error) {
	return lookupGroup(name)
}

// LookupGroupId looks up a group by groupid. If the group cannot be found, the
// returned error is of type [UnknownGroupIdError].
func LookupGroupId(gid string) (*Group, error) {
	return lookupGroupId(gid)
}

// GroupIds returns the list of group IDs that the user is a member of.
func (u *User) GroupIds() ([]string, error) {

		grp, found, errno = _C_getgrgid_r(_C_gid_t(gid),
			(*_C_char)(unsafe.Pointer(&buf[0])), _C_size_t(len(buf)))
		return syscall.Errno(errno)
	})
	if err == syscall.ENOENT || (err == nil && !found) {
		return nil, UnknownGroupIdError(strconv.Itoa(gid))
	}
	if err != nil {
		return nil, fmt.Errorf("user: lookup groupid %d: %v", gid, err)
	}
	return buildGroup(&grp), nil
}

func buildGroup(grp *_C_struct_group) *Group {

		if tt.name == "" {
			if err == nil {
				t.Errorf("findGroupId(%s): got nil error, expected err", tt.gid)
				continue
			}
			switch terr := err.(type) {
			case UnknownGroupIdError:
				if terr.Error() != "group: unknown groupid "+tt.gid {
					t.Errorf("findGroupId(%s): got %v, want %v", tt.name, terr, tt.name)
				}
			default:

pkg os/user, method (UnknownGroupError) Error() string
pkg os/user, method (UnknownGroupIdError) Error() string
pkg os/user, type Group struct
pkg os/user, type Group struct, Gid string
pkg os/user, type Group struct, Name string
pkg os/user, type UnknownGroupError string
pkg os/user, type UnknownGroupIdError string
pkg reflect, func StructOf([]StructField) Type

	if v, err := readColonFile(r, matchGroupIndexValue(id, 2), 3); err != nil {
		return nil, err
	} else if v != nil {
		return v.(*Group), nil
	}
	return nil, UnknownGroupIdError(id)
}

func findGroupName(name string, r io.Reader) (*Group, error) {
	if v, err := readColonFile(r, matchGroupIndexValue(name, 0), 3); err != nil {
		return nil, err
	} else if v != nil {

		{"NotifyContext", Func, 16},
		{"Reset", Func, 5},
		{"Stop", Func, 1},
	},
	"os/user": {
		{"(*User).GroupIds", Method, 7},
		{"(UnknownGroupError).Error", Method, 7},
		{"(UnknownGroupIdError).Error", Method, 7},
		{"(UnknownUserError).Error", Method, 0},
		{"(UnknownUserIdError).Error", Method, 0},
		{"Current", Func, 0},
		{"Group", Type, 7},
		{"Group.Gid", Field, 7},