if (throwContainerNotAvailable) {
                throw new ContainerNotAvailableException("");
            }
            if (throwRuntimeException) {
                throw new RuntimeException("Test exception");
            }
            return accessResultList;
        }

        @Override
        public void update(List<OpenSearchAccessResult> list) {
            // Do nothing in test

            andxCommand = (byte) 0xFF;
            andx = null;
        } else if (andx == null) {
            andxCommand = (byte) 0xFF;
            throw new RuntimeException("no andx command supplied with response");
        } else {

            /*
             * Set bufferIndex according to andxOffset
             */

            bufferIndex = headerStart + andxOffset;

            throw new IOException("Connection rejected by circuit breaker: " + e.getMessage(), e);
        } catch (RuntimeException e) {
            // Unwrap IOException from RuntimeException
            if (e.getCause() instanceof IOException) {
                throw (IOException) e.getCause();
            }
            throw new IOException("Connection failed", e);

  "unused", // many methods tested reflectively -- maybe prefer local @Keep annotations?
})
@NullUnmarked
public class NullPointerTesterTest extends TestCase {

  /** Non-NPE RuntimeException. */
  public static class FooException extends RuntimeException {
    private static final long serialVersionUID = 1L;
  }

  /**
   * Class for testing all permutations of static/non-static one-argument methods using
   * methodParameter().

    try {
      return generator.invoke(this, args);
    } catch (InvocationTargetException e) {
      throwIfUnchecked(e.getCause());
      throw new RuntimeException(e.getCause());
    } catch (Exception e) {
      throwIfUnchecked(e);
      throw new RuntimeException(e);
    }
  }

  private final class FreshInvocationHandler extends AbstractInvocationHandler {
    private final int identity = generateInt();

        TestIngester failingIngester = new TestIngester() {
            @Override
            public Map<String, Object> process(Map<String, Object> target, DataStoreParams paramMap) {
                throw new RuntimeException("Test exception");
            }
        };
        ingestFactory.ingesters.add(failingIngester);
        ComponentUtil.register(ingestFactory, "ingestFactory");

        // Reinitialize to pick up factory

  }

  /**
   * Thrown to indicate that an invalid response was returned from a call to {@link CacheLoader}.
   *
   * @since 11.0
   */
  public static final class InvalidCacheLoadException extends RuntimeException {
    public InvalidCacheLoadException(String message) {
      super(message);
    }
  }

        // andxOffset arbitrarily > 0
        ServerMessageBlock.writeInt2(80, buf, 36);
        // byteCount position: 33 + 1 + 8 = 42
        ServerMessageBlock.writeInt2(0, buf, 42);

        assertThrows(RuntimeException.class, () -> block.decode(buf, 0));
    }

    @Test
    @DisplayName("readAndXWireFormat reads chained plain SMB and marks received")
    void testReadAndXWireFormatWithPlainSMB() {

                lengthField.setAccessible(true);
                lengthField.setInt(this, length);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        @Override
        protected int readBytesWireFormat(byte[] buffer, int bufferIndex) {
            return 0;
        }

        @Override

    private void setFieldAccessible(Field field) {
        if (isExceptPrivateAccessible(field)) {
            return;
        }
        try {
            field.setAccessible(true);
        } catch (RuntimeException e) {
            throw new BeanFieldSetAccessibleFailureException(beanClass, field, e);
        }
    }

    private boolean isExceptPrivateAccessible(Field field) {