return d, fmt.Errorf("unexpected error returned by %s : status(%s)", ustr, resp.Status)
	}
	dec := json.NewDecoder(resp.Body)
	if err = dec.Decode(&d); err != nil {
		return d, err
	}
	return d, nil
}

func init() {
	flag.StringVar(&stsEndpoint, "sts-ep", "http://localhost:9000", "STS endpoint")
	flag.StringVar(&configEndpoint, "config-ep",
		"http://localhost:8080/auth/realms/minio/.well-known/openid-configuration",

    /**
     * Initializes the callback implementation after dependency injection.
     * Sets up configuration values and initializes the ingest factory if available.
     */
    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }

            SingletonLaContainerFactory.setExternalContextComponentDefRegister(new GenericExternalContextComponentDefRegister());
            SingletonLaContainerFactory.init();

            final Thread shutdownCallback = new Thread("ShutdownHook") {
                @Override
                public void run() {
                    if (logger.isDebugEnabled()) {

  )
  fun trustManager(): X509TrustManager = trustManager

  fun sslSocketFactory(): SSLSocketFactory = sslContext().socketFactory

  fun sslContext(): SSLContext =
    Platform.get().newSSLContext().apply {
      init(arrayOf<KeyManager>(keyManager), arrayOf<TrustManager>(trustManager), SecureRandom())
    }

  class Builder {
    private var heldCertificate: HeldCertificate? = null

    @Mock
    SmbFileHandleImpl fd;
    @Mock
    Configuration config;

    private SmbPipeInputStream newStreamWithInit(boolean smb2) throws CIFSException {
        when(handle.getPipe()).thenReturn(pipe);
        // init(th) behavior inside SmbFileInputStream constructor
        when(tree.isSMB2()).thenReturn(smb2);
        when(tree.getReceiveBufferSize()).thenReturn(4096);
        when(tree.getMaximumBufferSize()).thenReturn(65535);

     */
    public OpenSearchDataService(final String name, final String type) {
        index = name + "." + type;
    }

    /**
     * Initializes the service.
     */
    @PostConstruct
    public void init() {
        fesenClient.addOnConnectListener(() -> createMapping("data"));
    }

    /**
     * Stores an access result in the OpenSearch index.
     *
     * @param accessResult The access result to store.

            SMBUtil.writeInt4(ServerMessageBlock2.SMB2_FLAGS_SIGNED, data, 16);

            // Create valid signature using HmacSHA256
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(new SecretKeySpec(sessionKey, "HmacSHA256"));

            // Zero signature field for calculation
            for (int i = 0; i < SIGNATURE_LENGTH; i++) {
                data[SIGNATURE_OFFSET + i] = 0;
            }

	if size < 0 {
		return nil, errors.New("zip: size cannot be negative")
	}
	zr := new(Reader)
	var err error
	if err = zr.init(r, size); err != nil && err != ErrInsecurePath {
		return nil, err
	}
	return zr, err
}

func (r *Reader) init(rdr io.ReaderAt, size int64) error {
	end, baseOffset, err := readDirectoryEnd(rdr, size)
	if err != nil {
		return err
	}
	r.r = rdr

        return "id";
    }

    @BeforeAll
    protected static void initAll() {
        RestAssured.baseURI = getFessUrl();
        settingTestToken();
    }

    @BeforeEach
    protected void init() {
    }

    @AfterEach
    protected void tearDown() {
        final Map<String, Object> searchBody = createSearchBody(SEARCH_ALL_NUM);
        int count = 0;
        List<String> idList = getIdList(searchBody);

</p>

<h2 id="synchronization">Synchronization</h2>

<h3 id="init">Initialization</h3>

<p>
Program initialization runs in a single goroutine,
but that goroutine may create other goroutines,
which run concurrently.
</p>

<p class="rule">
If a package <code>p</code> imports package <code>q</code>, the completion of
<code>q</code>'s <code>init</code> functions happens before the start of any of <code>p</code>'s.
</p>