final ImmutableSet<V> createValues() {
    throw new AssertionError("should never be called");
  }

  /**
   * Guaranteed to throw an exception and leave the bimap unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")

   * {@code null}; it may either return a non-null value or throw an exception.
   *
   * <p>No observable state associated with this cache is modified until loading completes.
   *
   * @throws ExecutionException if a checked exception was thrown while loading the value
   * @throws UncheckedExecutionException if an unchecked exception was thrown while loading the
   *     value
   * @throws ExecutionError if an error was thrown while loading the value

            Type2Message.writeULong(invalidType, 8, Type2Message.NTLMSSP_TYPE1);

            // When & Then
            IOException thrown = assertThrows(IOException.class, () -> new Type2Message(invalidType));
            assertEquals("Not a Type 2 message.", thrown.getMessage());
        }
    }

    @Nested
    @DisplayName("Default Flags Tests")
    class DefaultFlagsTests {

        @Test

     *
     * @throws IOException
     *             thrown by {@code SmbFileInputStream} constructor
     */
    @Override
    public InputStream getInputStream() throws IOException {
        return new SmbFileInputStream(this);
    }

    @Override
    public SmbFileInputStream openInputStream() throws SmbException {
        return new SmbFileInputStream(this);

                        throw new ArtifactDescriptorException(result);
                    }
                }
                invalidDescriptor(session, trace, a, e);
                if ((getPolicy(session, a, request) & ArtifactDescriptorPolicy.IGNORE_INVALID) != 0) {
                    return null;
                }
                result.addException(e);
                throw new ArtifactDescriptorException(result);

   * instead. However, note that {@code checkIndex()} throws {@code IndexOutOfBoundsException} when
   * {@code size} is negative, while this method throws {@code IllegalArgumentException}.
   *
   * @param index a user-supplied index identifying a position in an array, list or string
   * @param size the size of that array, list or string
   * @return the value of {@code index}

        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Reads the contents of a file into a byte array and returns it.
     * <p>
     * <strong>Note:</strong> This method loads the entire file into memory.
     * For files larger than {@value #MAX_BUF_SIZE} bytes (10MB), an
     * {@link IORuntimeException} will be thrown to prevent OutOfMemoryError.

    public ProcessHelper processHelper;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        processHelper = new ProcessHelper();
    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        // Clean up any running processes
        processHelper.destroy();
        super.tearDown(testInfo);
    }

   * given values. The returned range is {@linkplain BoundType#CLOSED closed} on both ends.
   *
   * @throws ClassCastException if the values are not mutually comparable
   * @throws NoSuchElementException if {@code values} is empty
   * @throws NullPointerException if any of {@code values} is null
   * @since 14.0
   */

   * throwing exceptions like {@link NoSuchElementException} at the appropriate times, it throws
   * {@link PermittedMetaException} instances, which wrap a set of all exceptions that the iterator
   * could throw during the invocation of that method. This is necessary because, e.g., a call to
   * {@code iterator().remove()} of an unmodifiable list could throw either {@link