requires.value().each { RequiredFeature feat ->
            required[feat.feature()] = feat.value()
        }
    }

    static Map<String, String> requiredFeatures(Annotation[] testAnnotations) {
        Map<String, String> required = [:]
        getAllAnnotations(testAnnotations, RequiredFeature).each { required[it.feature()] = it.value() }

	module declares its path as: badchain.example.com/c
	        but was required as: example.com/badchain/c
	restoring example.com/badchain/c@v1.0.0
-- update-a-expected --
go: example.com/badchain/a@upgrade (v1.1.0) indirectly requires example.com/badchain/c@v1.1.0: parsing go.mod:
	module declares its path as: badchain.example.com/c
	        but was required as: example.com/badchain/c
-- list-expected --

        and:
        succeeds(task)
        skipped(task)

        when:
        buildFile << """
            createReports.reports.configure {
                file1.required = false
                file2.required = false
                file2.outputLocation.set(file1.outputLocation)
            }
        """

        then:
        succeeds(task)
        executedAndNotSkipped(task)
    }

                    "type": "missing",
                    "loc": ["header", "x-token"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["header", "x-key"],
                    "msg": "Field required",
                    "input": None,
                },
            ]
        }
    ) | IsDict(

     *
     * @param name The name.
     * @param configAction An action that initialises the item. The action is executed when the item is required.
     */
    // TODO - exception when no default type
    void create(String name, Action<? super T> configAction);

    /**
     * Defines an item with the given name and type. The item is not created immediately, but is instead created as it is required.
     *

                    "type": "missing",
                    "loc": ["header", "x-token"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["header", "x-key"],
                    "msg": "Field required",
                    "input": None,
                },
            ]
        }
    ) | IsDict(

import org.codelibs.fess.app.web.CrudMode;
import org.lastaflute.web.validation.Required;
import org.lastaflute.web.validation.theme.conversion.ValidateTypeFailure;

/**
 * @author shinsuke
 * @author Keiichi Watanabe
 */
public class CreateForm {

    @Required
    public String dictId;

    @ValidateTypeFailure
    public Integer crudMode;

    @Required
    @Size(max = 1000)
    public String token;

    @Required

import org.lastaflute.web.validation.Required;
import org.lastaflute.web.validation.theme.conversion.ValidateTypeFailure;

/**
 * @author codelibs
 * @author Shunji Makino
 */
public class EditForm {

    @ValidateTypeFailure
    public int crudMode;

    @Required
    @ValidateTypeFailure
    public String id;

    @Required
    public String jobName;

    @Required

			required("apiVersion"),
			required("kind"),
		}},
		{name: "embedded", object: `
{
  "embedded": {}
}`, errors: []validationMatch{
			required("embedded", "apiVersion"),
			required("embedded", "kind"),
		}},
		{name: "nested", object: `
{
  "nested": {
    "embedded": {}
  }
}`, errors: []validationMatch{
			required("nested", "apiVersion"),

	ErrMissingWhereClause = errors.New("WHERE conditions required")
	// ErrUnsupportedRelation unsupported relations
	ErrUnsupportedRelation = errors.New("unsupported relations")
	// ErrPrimaryKeyRequired primary keys required
	ErrPrimaryKeyRequired = errors.New("primary key required")
	// ErrModelValueRequired model value required
	ErrModelValueRequired = errors.New("model value required")