But it might be useful to understand the _standard attributes_ defined by Gradle and its core plugins.

As a plugin author, these attributes, and the way they are defined, can serve as a basis for <<#sec:declaring_attributes,building your own set of attributes>> in your ecosystem plugin.

[[sec:standard_attributes]]
== Standard attributes defined by Gradle

Gradle defines a list of standard attributes used by Gradle's core plugins.

	"SA Eastern Standard Time":        {"-03", "-03"},     // America/Cayenne
	"Central Standard Time":           {"CST", "CDT"},     // America/Chicago
	"Central Brazilian Standard Time": {"-04", "-04"},     // America/Cuiaba
	"Mountain Standard Time":          {"MST", "MDT"},     // America/Denver
	"Greenland Standard Time":         {"-03", "-02"},     // America/Godthab

          "tokenizer": "standard",
          "filter": [
            "truncate20_filter",
            "lowercase",
            "arabic_stop",
            "arabic_normalization",
            "arabic_keywords",
            "arabic_override",
            "arabic_stemmer"
          ]
        },
        "armenian_analyzer": {
          "tokenizer":  "standard",
          "filter": [

	"github.com/minio/minio/internal/logger"
	"github.com/minio/pkg/v3/env"
)

// Standard constants for all storage class
const (
	// Reduced redundancy storage class
	RRS = "REDUCED_REDUNDANCY"
	// Standard storage class
	STANDARD = "STANDARD"
)

// Standard constats for config info storage class
const (
	ClassStandard = "standard"
	ClassRRS      = "rrs"
	Optimize      = "optimize"
	InlineBlock   = "inline_block"

                'org.gradle.jvm.environment': of('', 'standard-jvm')
            ])}

${variantOf('mainSourceElements', [
                'org.gradle.verificationtype': of('main-sources', ''),
                'org.gradle.category': of('verification', 'library'),
                'org.gradle.dependency.bundling': of('external', 'external'),
                'org.gradle.jvm.environment': of('', 'standard-jvm'),

        private final AtomicBoolean didWarn = new AtomicBoolean();

        CheckStandardLayoutSpec(Provider<Boolean> standard) {
            this.standard = standard;
        }

        @Override
        public boolean isSatisfiedBy(GenerateModuleMetadata element) {
            if (!standard.get() && !didWarn.getAndSet(true)) {

	return l.out
}

// SetOutput sets the output destination for the standard logger.
func SetOutput(w io.Writer) {
	std.SetOutput(w)
}

// Flags returns the output flags for the standard logger.
// The flag bits are [Ldate], [Ltime], and so on.
func Flags() int {
	return std.Flags()
}

// SetFlags sets the output flags for the standard logger.
// The flag bits are [Ldate], [Ltime], and so on.

        alsoPassedClassFile.assertHasLinkTo('../packages/org.gradle.passing', 'org.gradle.passing')
        alsoPassedClassFile.assertHasStandardOutput('this is\nstandard output')
        alsoPassedClassFile.assertHasStandardError('this is\nstandard error')

        def alsoPassedTestDetails = alsoPassedClassFile.testDetails('passedToo')
        alsoPassedTestDetails.assertDuration("1.000s")

Annotation processors and their dependencies for source set 'main'.

Attributes
    - org.gradle.category            = library
    - org.gradle.dependency.bundling = external
    - org.gradle.jvm.environment     = standard-jvm
    - org.gradle.libraryelements     = jar
    - org.gradle.usage               = java-runtime

--------------------------------------------------
Configuration compileClasspath

Many tools out there still use the standard output for logging.
By default, Gradle redirects standard output to the `QUIET` log level and standard error to the `ERROR` level.
This behavior is configurable.

The `project` object provides a link:{javadocPath}/org/gradle/api/logging/LoggingManager.html[LoggingManager], which allows you to change the log levels that standard out or error are redirected to when your build script is evaluated.