@Override
    protected String asEsIndex() {
        if (indexName == null) {
            final String name = ComponentUtil.getFessConfig().getIndexConfigIndex();
            indexName = super.asEsIndex().replaceFirst(Pattern.quote("fess_config"), name);
        }
        return indexName;
    }

 * for access token management operations.
 */
public class EditBody extends EditForm {

    /**
     * Default constructor.
     */
    public EditBody() {
        super();
    }

  @Override
  Iterable<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Lists.newArrayList(contents);
  }

  @Override
  Iterable<Integer> filter(Iterable<Integer> elements, Predicate<? super Integer> predicate) {
    return Iterables.filter(elements, predicate);
  }

					return
				}
			}

			rpos += int64(n)
			sr.fillReady <- int64(n)
		}
	}()

	sr.fillReq <- struct{}{} // initial fill

	return sr
}

// remaining returns the number of unread bytes
// if EOF for the underlying reader has not yet been found,
// maximum possible integer value will be returned
func (s *scanner) remaining() int64 {
	if atomic.LoadInt64(&s.end) == maxInt {
		return maxInt

@ExtendWith(MockitoExtension.class)
public class JAASAuthenticatorTest {

    enum SubjectVariant {
        DEFAULT_NO_PS, // configuration null, no preset Subject
        DEFAULT_WITH_PS, // configuration null, but super.getSubject() returns non-null
        WITH_CONFIG // configuration provided via StaticJAASConfiguration
    }

    private JAASAuthenticator buildAuthenticator(SubjectVariant variant) {
        switch (variant) {

      this.task = task;
    }

    @Override
    public void run() {}

    private void setOwner(Thread thread) {
      super.setExclusiveOwnerThread(thread);
    }

    @VisibleForTesting
    @Nullable Thread getOwner() {
      return super.getExclusiveOwnerThread();
    }

    @Override
    public String toString() {
      return task.toString();
    }
  }

        override fun contains(element: Protocol?): Boolean {
          if (element == null) throw NullPointerException()
          return super.contains(element)
        }

        override fun indexOf(element: Protocol?): Int {
          if (element == null) throw NullPointerException()
          return super.indexOf(element)
        }
      } as List<Protocol>
    val client =
      OkHttpClient
        .Builder()

        transport = new TestableTransport();
    }

    @Nested
    @DisplayName("Static utility method tests")
    class StaticMethodTests {

        @Test
        @DisplayName("readn should read specified number of bytes")
        void shouldReadSpecifiedBytes() throws IOException {
            byte[] data = "Hello World Test".getBytes();
            InputStream is = new ByteArrayInputStream(data);

	metacacheMaxRunningAge = time.Minute

	// Max time between client calls before dropping an async cache listing.
	metacacheMaxClientWait = 3 * time.Minute

	// metacacheBlockSize is the number of file/directory entries to have in each block.
	metacacheBlockSize = 5000

	// metacacheSharePrefix controls whether prefixes on dirty paths are always shared.

The following self-signed certificate is issued for `consoleAdmin`. So, MinIO would associate it with the pre-defined `consoleAdmin` policy.

```
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            35:ac:60:46:ad:8d:de:18:dc:0b:f6:98:14:ee:89:e8
        Signature Algorithm: ED25519
        Issuer: CN = consoleAdmin
        Validity
            Not Before: Jul 19 15:08:44 2021 GMT