import jcifs.internal.smb1.trans.SmbComTransaction;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * Trans2 FindNext2 request message for SMB1 directory enumeration continuation.
 * This class implements the TRANS2_FIND_NEXT2 transaction to retrieve subsequent
 * directory entries after a Trans2FindFirst2 request, supporting large directory listings.
 */
public class Trans2FindNext2 extends SmbComTransaction {

import jcifs.internal.smb2.lease.Smb2LeaseKey;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Lease V1 Create Context Request
 *
 * MS-SMB2 2.2.13.2.8
 */
public class LeaseV1CreateContextRequest implements CreateContextRequest {

    /**
     * Context name for lease request
     */
    public static final String CONTEXT_NAME = "RqLs";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();

	if !ok {
		return nil
	}
	h.Uid = int(sys.Uid)
	h.Gid = int(sys.Gid)
	if doNameLookups {
		// Best effort at populating Uname and Gname.
		// The os/user functions may fail for any number of reasons
		// (not implemented on that platform, cgo not enabled, etc).
		if u, ok := userMap.Load(h.Uid); ok {
			h.Uname = u.(string)
		} else if u, err := user.LookupId(strconv.Itoa(h.Uid)); err == nil {
			h.Uname = u.Username

        @Test
        @DisplayName("Should implement NegotiateContextRequest interface")
        void testImplementsNegotiateContextRequest() {
            EncryptionNegotiateContext context = new EncryptionNegotiateContext();

            assertTrue(context instanceof NegotiateContextRequest);
        }

        @Test
        @DisplayName("Should implement NegotiateContextResponse interface")

 * @author Louis Wasserman
 * @since 2.0
 */
@GwtCompatible
@SuppressWarnings("serial") // we're overriding default serialization
public abstract class ImmutableMultiset<E> extends ImmutableCollection<E> implements Multiset<E> {

  /**
   * Returns a {@code Collector} that accumulates the input elements into a new {@code
   * ImmutableMultiset}. Elements iterate in order by the <i>first</i> appearance of that element in

    }

    @Test
    @DisplayName("Context should implement CIFSContext interface")
    void testInterfaceImplementation() {
        // Then
        assertTrue(context instanceof jcifs.CIFSContext, "BaseContext should implement CIFSContext interface");
    }

    @Test
    @DisplayName("Context should extend AbstractCIFSContext")

    Function<String, String> unusedJapaneseToSpanish =
        Functions.compose(numberToSpanish, japaneseToInteger);
  }

  private static class HashCodeFunction implements Function<@Nullable Object, Integer> {
    @Override
    public Integer apply(@Nullable Object o) {
      return (o == null) ? 0 : o.hashCode();
    }
  }

  public void testComposeOfFunctionsIsAssociative() {

 * detailed at {@link ImmutableCollection}.
 *
 * @author Louis Wasserman
 * @since 14.0
 */
@GwtIncompatible // NavigableMap
public class ImmutableRangeMap<K extends Comparable<?>, V> implements RangeMap<K, V>, Serializable {

  private static final ImmutableRangeMap<Comparable<?>, Object> EMPTY =
      new ImmutableRangeMap<>(ImmutableList.<Range<Comparable<?>>>of(), ImmutableList.of());

  /**

import org.lastaflute.job.LaJob;
import org.lastaflute.job.LaJobRuntime;
import org.lastaflute.job.key.LaJobUnique;

/**
 * This job executes a script.
 */
public class ScriptExecutorJob implements LaJob {
    /**
     * Constructor.
     */
    public ScriptExecutorJob() {
        super();
    }

    private static final Logger logger = LogManager.getLogger(ScriptExecutorJob.class);

    @Override

import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@link Lists#cartesianProduct(List)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class CartesianList<E> extends AbstractList<List<E>> implements RandomAccess {

  private final transient ImmutableList<List<E>> axes;
  private final transient int[] axesSizeProduct;

  static <E> List<List<E>> create(List<? extends List<? extends E>> lists) {