String name = fe.getName();
        if ( this.nameFilter == null ) {
            return true;
        }
        try {
            if ( !this.nameFilter.accept(this.parent, name) ) {
                return false;
            }
            return true;
        }
        catch ( CIFSException e ) {
            log.error("Failed to apply name filter", e);
            return false;

     */
    @Test
    public void testIsAssignableFrom() {
        assertThat(ClassUtil.isAssignableFrom(Number.class, Integer.class), is(true));
        assertThat(ClassUtil.isAssignableFrom(Integer.class, Number.class), is(not(true)));
        assertThat(ClassUtil.isAssignableFrom(int.class, Integer.class), is(true));
    }

    /**
     *
     */
    @Test
    public void testGetPackageName() {

        ""
      ]
    },
    "owner": true,
    "object": "",
    "claims": {},
    "denyOnly": false
  }
}
```

</details>

The response expected by MinIO, is a JSON body with a boolean:

```json
{
    "result": true
}
```

The following structure is also accepted:

```json
{
    "result": {
        "allow": true
    }
}
```

    }
    isCanBeResolved = false
    isCanBeConsumed = true
    isVisible = false
    outgoing.artifact(localRepository) {
        builtBy(publishPluginsToTestRepository)
    }
}

configurations.create("futureVersion") {
    isVisible = false
    isCanBeResolved = false
    isCanBeConsumed = true
    attributes {
        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))

    validations:
      required: true

  - type: textarea
    id: tests
    attributes:
      label: Which tests are flaking?
    validations:
      required: true

  - type: textarea
    id: since
    attributes:
      label: Since when has it been flaking?
    validations:
      required: true

  - type: input
    id: testgrid
    attributes:

    protected Random random = new SecureRandom();

    public String generateAccessToken() {
        return RandomStringUtils.random(ComponentUtil.getFessConfig().getApiAccessTokenLengthAsInteger(), 0, 0, true, true, null, random);
    }

    public String getAccessTokenFromRequest(final HttpServletRequest request) {
        final String token = request.getHeader("Authorization");
        if (token != null) {

        PropertyDoc readWriteProperty = propertyDoc('readWriteProperty', readable: true, writeable: true)
        PropertyDoc readOnlyProperty = propertyDoc('readOnlyProperty', readable: true, writeable: false)
        PropertyDoc writeOnlyProperty = propertyDoc('writeOnlyProperty', readable: false, writeable: true)
        _ * classDoc.classProperties >> [readWriteProperty, readOnlyProperty, writeOnlyProperty]

        @Override
        public int hashCode() {
            return hashCode;
        }

        @Override
        public boolean equals(Object o) {
            if (o == this) {
                return true;
            }

            if (!(o instanceof CacheKey)) {
                return false;
            }

            CacheKey other = (CacheKey) o;

            return pomHash == other.pomHash

    val extraSysProp = mutableListOf<String>()
    if (bundleGroovy4) {
        extraSysProp += "-DbundleGroovy4=true"
    }
    if (buildJvm.version != BuildToolBuildJvm.version) {
        extraSysProp += "-Dorg.gradle.ignoreBuildJavaVersionCheck=true"
    }
    val defaultParameters =
        (buildToolGradleParameters() + buildScanTags + extraSysProp + functionalTestParameters(Os.LINUX)).joinToString(

none # # Purge if bucket exists already # purge: false # # set versioning for # # bucket [true|false] # versioning: false # remove this key if you do not want versioning feature # # set objectlocking for # # bucket [true|false] NOTE: versioning is enabled by default if you use locking # objectlocking: false # - name: bucket2 # policy: none # purge: false # versioning: true # # set objectlocking for # # bucket [true|false] NOTE: versioning is enabled by default if you use locking # objectlocking: false...