*/

package jcifs.smb1.netbios;

import java.io.IOException;
import java.io.InputStream;

/**
 * NetBIOS session request packet for establishing sessions.
 * This packet is sent to request a NetBIOS session with a remote host.
 */
public class SessionRequestPacket extends SessionServicePacket {

    private final Name calledName, callingName;

 */

package jcifs.netbios;

import java.io.IOException;
import java.io.InputStream;

import jcifs.Configuration;
import jcifs.NetbiosName;

/**
 * NetBIOS session request packet implementation.
 * This packet is used to initiate NetBIOS session connections.
 */
public class SessionRequestPacket extends SessionServicePacket {

    private final Name calledName, callingName;

     */
    protected int alloc_hint = 0;
    /**
     * The result code of the DCERPC operation
     */
    protected int result = 0;

    /**
     * Gets the packet type of this DCERPC message
     * @return the packet type
     */
    public int getPtype() {
        return ptype;
    }

    /**
     * Gets the flags of this DCERPC message
     * @return the message flags
     */

	return sys.initialized
}

// Loads bucket metadata for all buckets into BucketMetadataSys.
func (sys *BucketMetadataSys) init(ctx context.Context, buckets []string) {
	count := globalEndpoints.ESCount() * 10
	for {
		if len(buckets) < count {
			sys.concurrentLoad(ctx, buckets)
			break
		}
		sys.concurrentLoad(ctx, buckets[:count])
		buckets = buckets[count:]
	}

	sys.Lock()
	sys.initialized = true

        // Arrange
        NameServicePacket packet = new NodeStatusRequest(mockConfig, mockName);

        // Assert
        assertInstanceOf(NodeStatusRequest.class, packet);
        assertEquals(NameServicePacket.NBSTAT, packet.questionType);
        assertFalse(packet.isRecurDesired);
        assertFalse(packet.isBroadcast);
    }

    @Test

    crossVersionBuckets: List<List<String>>,
    private val model: CIBuildModel,
) : FunctionalTestBucketProvider {
    private val buckets: List<BuildTypeBucket> = crossVersionBuckets.map { GradleVersionRangeCrossVersionTestBucket(it[0], it[1]) }

    // For quickFeedbackCrossVersion and allVersionsCrossVersion, the buckets are split by Gradle version
    // By default, split them by CROSS_VERSION_BUCKETS
    override fun createFunctionalTestsFor(

		Cache: make(map[string]dataUsageEntry, len(oldCache.Cache)),
	}

	// Put all buckets into channel.
	bucketCh := make(chan BucketInfo, len(buckets))

	// Shuffle buckets to ensure total randomness of buckets, being scanned.
	// Otherwise same set of buckets get scanned across erasure sets always.
	// at any given point in time. This allows different buckets to be scanned
	// in different order per erasure set, this wider spread is needed when

        return bucketsOfFirstElement + bucketsOfRestElements
    } else {
        val buckets = arrayListOf(largestElement)
        var restCapacity = roughSizeOfEachBucket - toIntFunction(largestElement)
        while (restCapacity > 0 && list.isNotEmpty() && buckets.size < maxNumberInBucket) {
            val smallestElement = list.findLast { searched -> buckets.all { canRunTogether(it, searched) } } ?: break
            list.remove(smallestElement)

  static Object createTable(int buckets) {
    if (buckets < 2
        || buckets > Ints.MAX_POWER_OF_TWO
        || Integer.highestOneBit(buckets) != buckets) {
      throw new IllegalArgumentException("must be power of 2 between 2^1 and 2^30: " + buckets);
    }
    if (buckets <= BYTE_MAX_SIZE) {
      return new byte[buckets];
    } else if (buckets <= SHORT_MAX_SIZE) {

   */
  public static int consistentHash(HashCode hashCode, int buckets) {
    return consistentHash(hashCode.padToLong(), buckets);
  }

  /**
   * Assigns to {@code input} a "bucket" in the range {@code [0, buckets)}, in a uniform manner that
   * minimizes the need for remapping as {@code buckets} grows. That is, {@code consistentHash(h,
   * n)} equals:
   *
   * <ul>