`return true != true`,
		},
		nil,
	},

	// Field.
	{
		"field",
		[]string{p, `ExportedType.ExportedField`},
		[]string{
			`type ExportedType struct`,
			`ExportedField int`,
			`Comment before exported field`,
			`Comment on line with exported field`,
			`other fields elided`,
		},
		nil,
	},

	// Field with -u.
	{
		"method with -u",

	return validationMatch{path: field.NewPath(path[0], path[1:]...), errorType: field.ErrorTypeRequired}
}
func invalid(path ...string) validationMatch {
	return validationMatch{path: field.NewPath(path[0], path[1:]...), errorType: field.ErrorTypeInvalid}
}
func invalidtypecode(path ...string) validationMatch {
	return validationMatch{path: field.NewPath(path[0], path[1:]...), errorType: field.ErrorTypeTypeInvalid}
}

		{"Header", Type, 0},
		{"Header.AccessTime", Field, 0},
		{"Header.ChangeTime", Field, 0},
		{"Header.Devmajor", Field, 0},
		{"Header.Devminor", Field, 0},
		{"Header.Format", Field, 10},
		{"Header.Gid", Field, 0},
		{"Header.Gname", Field, 0},
		{"Header.Linkname", Field, 0},
		{"Header.ModTime", Field, 0},
		{"Header.Mode", Field, 0},
		{"Header.Name", Field, 0},
		{"Header.PAXRecords", Field, 10},
		{"Header.Size", Field, 0},

			wantErrs: field.ErrorList{
				&field.Error{
					Type:  field.ErrorTypeInvalid,
					Field: "profiles[0].plugins.score.enabled[0]",
				},
				&field.Error{
					Type:  field.ErrorTypeInvalid,
					Field: "profiles[0].plugins.score.enabled[1]",
				},
				&field.Error{
					Type:  field.ErrorTypeInvalid,
					Field: "profiles[0].plugins.score.enabled[2]",
				},
				&field.Error{

func validateAttacher(attacher string, fldPath *field.Path) field.ErrorList {
	allErrs := field.ErrorList{}
	if len(attacher) == 0 {
		allErrs = append(allErrs, field.Required(fldPath, attacher))
	}
	return allErrs
}

// validateSource tests if the source is valid for VolumeAttachment.
func validateVolumeAttachmentSource(source *storage.VolumeAttachmentSource, fldPath *field.Path) field.ErrorList {
	allErrs := field.ErrorList{}

			Class: "UNIQUE",
			Fields: []schema.IndexOption{
				{Field: &schema.Field{Name: "FieldD"}},
				// Note: Duplicate Columns
				{Field: &schema.Field{Name: "FieldD"}},
			},
		},
		"uniq_field_e1_e2": {
			Name:  "uniq_field_e1_e2",
			Class: "UNIQUE",
			Fields: []schema.IndexOption{
				{Field: &schema.Field{Name: "FieldE1"}},
				{Field: &schema.Field{Name: "FieldE2"}},
			},
		},

     * @see #getString(Field, Object)
     */
    public static String getString(final Field field) throws IllegalAccessRuntimeException {
        assertArgumentNotNull("field", field);

        return getString(field, null);
    }

    /**
     * {@link Field}の値を {@link String}として取得します。
     *
     * @param field
     *            フィールド。{@literal null}であってはいけません

    public ${type} ${pfx}${cap}() {
      #if ( $field.to != "String" && $field.type == "java.util.List" && $field.multiplicity == "*" )
        return new WrapperList<${field.to}, ${packageModelV4}.${field.to}>(
                    () -> getDelegate().get${cap}(), l -> update(getDelegate().with${cap}(l)),
                    d -> new ${field.to}(d, this), ${field.to}::getDelegate);

        #if ( $field.type == "String" )
                this.${field.name} = "${field.defaultValue}";
        #elseif ( $field.type != "java.util.List" && $field.type != "java.util.Properties" )
                this.${field.name} = ${field.defaultValue};
        #end
      #end
    #end
            }
        }

	var allErrs field.ErrorList
	allItems := sets.New[T]()
	for i, item := range slice {
		idxPath := fldPath.Index(i)
		if allItems.Has(item) {
			allErrs = append(allErrs, field.Duplicate(idxPath, item))
		} else {
			allErrs = append(allErrs, validateItem(item, idxPath)...)