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

/**
 * This exception is thrown when a storage-related error occurs.
 * It can be used to wrap underlying storage exceptions, providing a
 * consistent error handling mechanism for storage operations.
 */
public class StorageException extends FessSystemException {
    private static final long serialVersionUID = 1L;

   *
   * <p>Changes to the returned set will update the underlying multimap, and vice versa. However,
   * <i>adding</i> to the returned set is not possible.
   */
  @Override
  public Set<K> keySet() {
    return super.keySet();
  }

  /**
   * Returns a collection of all values in the multimap. Changes to the returned collection will
   * update the underlying multimap, and vice versa.
   *

import okio.ForwardingSource
import okio.asOkioSocket
import okio.buffer

/**
 * Adapts a [java.net.Socket] to MockWebServer's needs.
 *
 * Note that [asOkioSocket] returns a socket that closes the underlying [java.net.Socket] when both
 * of its component streams are closed. This class takes advantage of that.
 */
internal class MockWebServerSocket(
  val javaNetSocket: Socket,
) : Closeable,
  BufferedSocket {

        assertThrows(NullPointerException.class, () -> target.unwrap(null));
    }

    @Test
    @DisplayName("getPipe, getPipeType, getUncPath delegate to underlying pipe")
    void testBasicAccessors() {
        when(pipe.getPipeType()).thenReturn(0x123456);
        assertSame(pipe, target.getPipe());
        assertEquals(0x123456, target.getPipeType());

    }

    /**
     * Create a new SmbOperationException with cause
     *
     * @param errorCode the error code
     * @param message the error message
     * @param cause the underlying cause
     */
    public SmbOperationException(ErrorCode errorCode, String message, Throwable cause) {
        this(errorCode, message, cause, RetryPolicy.DEFAULT, Collections.emptyMap());
    }

    /**

 *       Future} is "completed" even if it is cancelled while its underlying work continues on a
 *       thread, an RPC, etc. The {@code Future} is also "completed" if it fails "early" -- for
 *       example, if the deadline expires on a {@code Future} returned from {@link
 *       Futures#withTimeout} while the {@code Future} it wraps continues its underlying work. So

package jcifs.smb1.https;

/**
 * A <code>URLStreamHandler</code> used to provide NTLM authentication
 * capabilities to the default HTTPS handler.  This acts as a wrapper,
 * handling authentication and passing control to the underlying
 * stream handler.
 */
public class Handler extends jcifs.smb1.http.Handler {

    /**
     * The default HTTPS port (<code>443</code>).
     */
    public static final int DEFAULT_HTTPS_PORT = 443;

	if !client.IsOnlineWS() {
		// make sure to check if the disk is offline, since the underlying
		// value is cached we should attempt to invalidate it if such calls
		// were attempted. This can lead to false success under certain conditions
		// - this change attempts to avoid stale information if the underlying
		// transport is already down.
		return "", errDiskNotFound
	}

  private final Hasher hasher;

  /**
   * Creates an output stream that hashes using the given {@link HashFunction}, and forwards all
   * data written to it to the underlying {@link OutputStream}.
   *
   * <p>The {@link OutputStream} should not be written to before or after the hand-off.
   */
  // TODO(user): Evaluate whether it makes sense to always piggyback the computation of a

    name: Example

# Let dex keep a list of passwords which can be used to login to dex.
enablePasswordDB: true

# A static list of passwords to login the end user. By identifying here, dex
# won't look in its underlying storage for passwords.
#
# If this option isn't chosen users may be added through the gRPC API.
staticPasswords:
  - email: "******@****.***"
    # bcrypt hash of the string "password"