*       RuntimeException} (though {@code get} implementations are discouraged from throwing such
   *       exceptions).
   * </ul>
   *
   * <p>The overall principle is to continue to treat every checked exception as a checked
   * exception, every unchecked exception as an unchecked exception, and every error as an error. In
   * addition, the cause of any {@code ExecutionException} is wrapped in order to ensure that the

    public T get() {
      // A 2-field variant of Double Checked Locking.
      if (!initialized) {
        synchronized (lock) {
          if (!initialized) {
            T t = delegate.get();
            value = t;
            initialized = true;
            return t;
          }
        }
      }
      // This is safe because we checked `initialized`.
      return uncheckedCastNullableTToT(value);
    }

### Exception Handling
```java
import org.codelibs.core.exception.*;

// Runtime exception wrappers eliminate try-catch boilerplate
try {
    // Code that might throw checked exceptions
    return ClassUtil.newInstance(className); // Wraps checked exceptions automatically
} catch (ClassNotFoundRuntimeException e) {
    // Handle the wrapped exception
    logger.error("Class not found: " + className, e);
}
```

      @ParametricNullness E fromElement,
      BoundType fromBoundType,
      @ParametricNullness E toElement,
      BoundType toBoundType) {
    // These are checked elsewhere, but NullPointerTester wants them checked eagerly.
    checkNotNull(fromBoundType);
    checkNotNull(toBoundType);
    return tailMultiset(fromElement, fromBoundType).headMultiset(toElement, toBoundType);
  }

    void mockInteraction_stubsThrow_andVerifiesInvocation() {
        // Arrange: Since SmbUnsupportedOperationException is a checked exception (extends IOException),
        // we need to use a method that can throw checked exceptions or wrap it in a RuntimeException
        @SuppressWarnings("unchecked")
        Supplier<String> supplier = mock(Supplier.class);

        assertTrue(Arrays.asList(clazz.getInterfaces()).contains(SmbResourceLocator.class), "Should extend SmbResourceLocator");

        // shouldForceSigning(): boolean, no params, no checked exceptions
        Method m1 = clazz.getMethod("shouldForceSigning");
        assertEquals(boolean.class, m1.getReturnType());
        assertEquals(0, m1.getParameterCount());

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;

import java.io.IOException;

/**
 * Base for all checked exceptions used by this library
 *
 * @author mbechler
 *
 */
public class CIFSException extends IOException {

    /**
     *
     */
    private static final long serialVersionUID = 7806460518865806784L;

   *
   * <ul>
   *   <li>All non-private static methods are checked such that passing null for any parameter
   *       that's not annotated nullable should throw {@link NullPointerException}.
   *   <li>If there is any non-private constructor or non-private static factory method declared by
   *       {@code cls}, all non-private instance methods will be checked too using the instance

   * RuntimeException}, {@link Error}, {@code declaredType1}, or {@code declaredType2}.
   *
   * @param throwable the Throwable to possibly propagate
   * @param declaredType1 any checked exception type declared by the calling method
   * @param declaredType2 any other checked exception type declared by the calling method
   * @deprecated Use a combination of two calls to {@link #throwIfInstanceOf} and one call to {@link

      this.adder = adder;
    }

    @Override
    @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
    public int add(int a, int b) {
      try {
        return adder.add(a, b);
      } catch (Exception e) { // sneaky checked exception
        // swallow!
        return 0;
      }
    }

    @Override
    public String toString() {