SocketInputStream sis = new SocketInputStream(in);

        // Try to skip more than available
        // Skip uses read internally, which may throw IOException when it tries to read the next header
        try {
            long skipped = sis.skip(10);
            // If it doesn't throw, it should only skip what's available
            assertEquals(3, skipped);
        } catch (IOException e) {

      if (actual == FAILED) {
        // Handle this specially so that we can include the failureCause, if there is one.
        throw new IllegalStateException(
            "Expected the service " + this + " to be " + expected + ", but the service has FAILED",
            failureCause());
      }
      throw new IllegalStateException(
          "Expected the service " + this + " to be " + expected + ", but was " + actual);
    }
  }

        new AbstractLoadingCache<Object, Object>() {
          @Override
          public Object get(Object key) throws ExecutionException {
            Object v = valueRef.get();
            if (v == null) {
              throw new ExecutionException(cause);
            }
            return v;
          }

          @Override
          public @Nullable Object getIfPresent(Object key) {
            return valueRef.get();
          }

  /**
   * @param eventBus The {@link EventBus} that handled the event and the subscriber. Useful for
   *     broadcasting a new event based on the error.
   * @param event The event object that caused the subscriber to throw.
   * @param subscriber The source subscriber context.
   * @param subscriberMethod the subscribed method.
   */
  SubscriberExceptionContext(

                }
            }
        }
        try {
            factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
        } catch (final ParserConfigurationException e) {
            throw new ParserConfigurationRuntimeException(e);
        }
        return factory;
    }

    /**
     * Creates a new {@link DocumentBuilder}.
     *
     * @return A new {@link DocumentBuilder}.
     */

        br.addItem("Boundary Size");
        br.addElement(boundarySize);
        br.addItem("Limit Size");
        br.addElement(limitSize);
        final String msg = br.buildExceptionMessage();
        throw new Forced404NotFoundException(msg, UserMessages.empty()); // heavy attack!? so give no page to tell wasted action
    }

            updateCalls.add(user);
            if (updateThrowsException) {
                throw new RuntimeException("Update failed");
            }
        }

        @Override
        public void delete(User user) {
            deleteCalls.add(user);
            if (deleteThrowsException) {
                throw new RuntimeException("Delete failed");
            }
        }

        @Override

        if (isExceptPrivateAccessible(method)) {
            return;
        }
        try {
            method.setAccessible(true);
        } catch (RuntimeException e) {
            throw new BeanMethodSetAccessibleFailureException(beanDesc.getBeanClass(), method, e);
        }
    }

    private boolean isExceptPrivateAccessible(Method method) {
        // to avoid warning of JDK-internal access at Java11

    if (guard.monitor != this) {
      throw new IllegalMonitorStateException();
    }
    ReentrantLock lock = this.lock;
    boolean reentrant = lock.isHeldByCurrentThread();
    long startTime = 0L;

    locked:
    {
      if (!fair) {
        // Check interrupt status to get behavior consistent with fair case.
        if (Thread.interrupted()) {
          throw new InterruptedException();
        }

        infoField.set(response, fileInfo);

        CIFSException exception = assertThrows(CIFSException.class, () -> response.getInfo(FileFsSizeInformation.class),
                "Should throw CIFSException for incompatible class");

        assertEquals("Incompatible file information class", exception.getMessage());
    }

    @Test
    @DisplayName("Test writeBytesWireFormat returns 0")