import common.requiresNotEc2Agent
import model.CIBuildModel
import model.Stage

class SmokeIdeTests(model: CIBuildModel, stage: Stage) : OsAwareBaseGradleBuildType(os = Os.LINUX, stage = stage, init = {
    id(buildTypeId(model))
    name = "Smoke Ide Tests"
    description = "Tests against IDE sync process"

    requirements {
        // These tests are usually heavy and the build time is twice on EC2 agents

		if !filepath.IsAbs(a.QueueDir) {
			return errors.New("queueDir path should be absolute")
		}
	}

	return nil
}

// AMQPTarget - AMQP target
type AMQPTarget struct {
	initOnce once.Init

	id         event.TargetID
	args       AMQPArgs
	conn       *amqp091.Connection
	connMutex  sync.Mutex
	store      store.Store[event.Event]
	loggerOnce logger.LogOnce

	quitCh chan struct{}
}

  }

  override fun isDuplex(): Boolean {
    return delegate.isDuplex()
  }

  override fun toString(): String {
    return javaClass.simpleName + "(" + delegate.toString() + ")"
  }

  init {
    requireNotNull(delegate) { "delegate == null" }
    this.delegate = delegate
  }

    }

    public void test_init() {
        final DictionaryManager dictionaryManager = new DictionaryManager();
        dictionaryManager.init();
        assertEquals(0, dictionaryManager.creatorList.size());

        dictionaryManager.addCreator(new CharMappingCreator());
        dictionaryManager.init();
        assertEquals(1, dictionaryManager.creatorList.size());
    }

    /*

 */

package jcifs.smb1.util;

public class RC4
{

    byte[] s;
    int i, j;

    public RC4()
    {
    }
    public RC4(byte[] key)
    {
        init(key, 0, key.length);
    }

    public void init(byte[] key, int ki, int klen)
    {
        s = new byte[256];

        for (i = 0; i < 256; i++)
            s[i] = (byte)i;

        for (i = j = 0; i < 256; i++) {

    /**
     * 
     * @param key
     * @return RC4 cipher
     */
    public static Cipher getArcfour ( byte[] key ) {
        try {
            Cipher c = Cipher.getInstance("RC4");
            c.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "RC4"));
            return c;
        }
        catch (
            NoSuchAlgorithmException |
            NoSuchPaddingException |
            InvalidKeyException e ) {

) : Project({
    this.id(testCoverage.asId(model))
    this.name = testCoverage.asName()
}) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
    init {
        functionalTests.forEach(this::buildType)
    }

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.entity;

/**
 * @author shinsuke
 *
 */
public interface AccessResult<IDTYPE> {
    void init(ResponseData responseData, ResultData resultData);

    IDTYPE getId();

    void setId(IDTYPE id);

    String getSessionId();

    void setSessionId(String sessionId);

    String getRuleId();

                error);
    }

    public ArtifactMetadata(Artifact af) {
        /*
        if ( af != null )
        {
            init( af );
        }
        */
    }
    // ------------------------------------------------------------------
    //    public void init( ArtifactMetadata af )
    //    {
    //        setGroupId( af.getGroupId() );
    //        setArtifactId( af.getArtifactId() );

	public final fun resolvePrivateAddresses ()Z
	public final fun resolvePublicAddresses ()Z
	public final fun url ()Lokhttp3/HttpUrl;
}

public final class okhttp3/dnsoverhttps/DnsOverHttps$Builder {
	public fun <init> ()V
	public final fun bootstrapDnsHosts (Ljava/util/List;)Lokhttp3/dnsoverhttps/DnsOverHttps$Builder;
	public final fun bootstrapDnsHosts ([Ljava/net/InetAddress;)Lokhttp3/dnsoverhttps/DnsOverHttps$Builder;