import java.io.DataOutput;
import java.io.IOException;

/**
 * An extension of {@code DataOutput} for writing to in-memory byte arrays; its methods offer
 * identical functionality but do not throw {@link IOException}.
 *
 * @author Jayaprabhakar Kadarkarai
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public interface ByteArrayDataOutput extends DataOutput {
  @Override
  void write(int b);

        }

        try {
            securityDescriptor = new SecurityDescriptor();
            bufferIndex += securityDescriptor.decode(buffer, bufferIndex, len);
        } catch (final IOException ioe) {
            throw new RuntimeException(ioe.getMessage());
        }

        return bufferIndex - start;
    }

    @Override
    public String toString() {
        return ("NtTransQuerySecurityResponse[" + super.toString() + "]");

   * buildOrThrow(), or vice versa. So in particular, if we modify alternatingKeysAndValues to
   * eliminate duplicate keys (for buildKeepingLast()) then we have to ensure that a later call to
   * buildOrThrow() will still throw as if the duplicates had not been eliminated. And the exception
   * message must mention two values that were associated with the duplicate key in two different

            referralData.setKey("key");
            // Should not throw exception
            referralData.replaceCache();
        }

        @Test
        @DisplayName("Should not replace cache when key is null")
        void testReplaceCacheWithNullKey() {
            referralData.setCacheMap(cacheMap);
            // Should not throw exception
            referralData.replaceCache();

  private ParseRequest(String rawValue, int radix) {
    this.rawValue = rawValue;
    this.radix = radix;
  }

  static ParseRequest fromString(String stringValue) {
    if (stringValue.length() == 0) {
      throw new NumberFormatException("empty string");
    }

    // Handle radix specifier if present
    String rawValue;
    int radix;
    char firstChar = stringValue.charAt(0);

                    String errorMsg = response != null ? response.getError() : "Response was null";
                    throw new IOException("Witness registration failed: " + errorMsg);
                }

            } catch (Exception e) {
                log.error("Failed to register for witness notifications", e);
                throw new RuntimeException(e);
            }
        });
    }

    /**

        void testReadOperationsWithNullBuffer() {
            // Read operations return 0 when given null buffer - no exceptions thrown
            assertEquals(0, response.readSetupWireFormat(null, 0, 0));
            assertEquals(0, response.readParametersWireFormat(null, 0, 0));

            // readDataWireFormat will throw when accessing null buffer
            assertThrows(NullPointerException.class, () -> {

        RandomHasherAction.pickAtRandom(random).performAction(random, sinksAndControl);
      }
      // We need to ensure that at least 4 bytes have been put into the hasher or else
      // Hasher#hash will throw an ISE.
      int intToPut = random.nextInt();
      for (Hasher hasher : sinksAndControl) {
        hasher.putInt(intToPut);
      }
      for (Sink sink : sinks) {
        HashCode unused = sink.hash();

    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String componentName = "cacheManager";
        try {
            throw new ContainerNotAvailableException(componentName);
        } catch (ContainerNotAvailableException e) {
            assertEquals(componentName + " is not available.", e.getMessage());
            assertNull(e.getCause());

            public int problemsReportedFor(BuilderProblem.Severity... severities) {
                return 0;
            }

            @Override
            public boolean reportProblem(P problem) {
                throw new IllegalStateException("empty problem collector");
            }

            @Override
            public Stream<P> problems(BuilderProblem.Severity severity) {
                return Stream.empty();