}
                    this.s[_i].decode(_src);
                }
            }
        }
    }

    /**
     * DFS storage information structure containing server and share details
     */
    public static class DfsStorageInfo extends NdrObject {

        /**
         * Default constructor for DfsStorageInfo
         */
        public DfsStorageInfo() {

    }

    @Test
    void testNewSyncContext() throws Exception {
        // SyncContext newSyncContext( RepositorySystemSession session, boolean shared );
    }

 *     the same connection for an initial exchange and its follow-ups may improve locality.
 *
 *  2. If there is a connection in the pool that can satisfy the request it is used. Note that it is
 *     possible for shared exchanges to make requests to different host names! See
 *     [RealConnection.isEligible] for details.
 *
 *  3. Attempt plans from prior connect attempts for this call. These occur as either follow-ups to

        assertTrue(ex.getMessage().contains("Connection failed"));
    }

    @Test
    @DisplayName("Should perform logon to IPC$ share")
    void testLogon() throws Exception {
        // Given: Mock transport, session and tree
        SmbTransportPoolImpl poolSpy = spy(pool);
        when(ctx.getTransportPool()).thenReturn(poolSpy);

  fun route(): Route

  /**
   * Returns the socket that this connection is using. Returns an
   * [SSL socket][javax.net.ssl.SSLSocket] if this connection is HTTPS. If this is an HTTP/2
   * connection the socket may be shared by multiple concurrent calls.
   */
  fun socket(): Socket

  /**
   * Returns the TLS handshake used to establish this connection, or null if the connection is not
   * HTTPS.
   */
  fun handshake(): Handshake?

/**
 * A set of tasks that are executed in sequential order.
 *
 * Work within queues is not concurrent. This is equivalent to each queue having a dedicated thread
 * for its work; in practice a set of queues may share a set of threads to save resources.
 */
class TaskQueue internal constructor(
  internal val taskRunner: TaskRunner,
  internal val name: String,
) {
  internal var shutdown = false

    @Size(max = 10)
    public String replaceAliases;

    /**
     * The flag to reset dictionaries.
     */
    @Size(max = 10)
    public String resetDictionaries;

    /**
     * The number of shards for doc.
     */
    @Size(max = 10)
    public String numberOfShardsForDoc = ComponentUtil.getFessConfig().getIndexNumberOfShards();

    /**
     * The auto expand replicas for doc.
     */
    @Size(max = 10)

    @Test
    public void testLeaseManager() {
        CIFSContext context = new BaseContext(new PropertyConfiguration());
        LeaseManager manager = new LeaseManager(context);
        
        String path = "/share/file.txt";
        int requestedState = Smb2LeaseState.SMB2_LEASE_FULL;
        
        Smb2LeaseKey key = manager.requestLease(path, requestedState);
        assertNotNull(key);
        

     * @see <a
     *      href="https://en.wikipedia.org/wiki/Octet_%28computing%29">https://en.wikipedia.org/wiki/Octet_(computing)</a>
     */
    // CHECKSTYLE_ON: LineLength
    // TODO Move me to Maven Shared Utils
    static class FileSizeFormat {
        enum ScaleUnit {
            BYTE {
                @Override
                public long bytes() {
                    return 1L;
                }

      new NullPointerTester().testAllPublicInstanceMethods(striped);
    }
  }

  public void testSizes() {
    // not bothering testing all variations, since we know they share implementations
    assertThat(Striped.lock(100).size()).isAtLeast(100);
    assertTrue(Striped.lock(256).size() == 256);
    assertThat(Striped.lazyWeakLock(100).size()).isAtLeast(100);