println(failure)
      }
      throw failures.first()
    }
  }

  private fun testToAscii(
    input: String,
    output: String?,
    comment: String?,
  ) {
    val url = "https://$input/".toHttpUrlOrNull()
    assertThat(url?.host, name = comment ?: input).isEqualTo(output)
  }

          A result(Collector<T, A, R> collector, Iterable<T> inputs) {
        A accum = collector.supplier().get();
        for (T input : inputs) {
          collector.accumulator().accept(accum, input);
        }
        return accum;
      }
    },
    /** Get one accumulator for each element and merge the accumulators left-to-right. */
    MERGE_LEFT_ASSOCIATIVE {

  private static final class RoundToDoubleTester {
    private final BigDecimal input;
    private final Map<RoundingMode, Double> expectedValues = new EnumMap<>(RoundingMode.class);
    private boolean unnecessaryShouldThrow = false;

    RoundToDoubleTester(BigDecimal input) {
      this.input = input;
    }

    @CanIgnoreReturnValue

            throw new IORuntimeException(e);
        }
    }

    /**
     * Gets a byte array from an {@link InputStream}.
     * <p>
     * The input stream is not closed.
     * </p>
     *
     * @param is the input stream (must not be {@literal null})
     * @return the byte array
     */
    public static final byte[] getBytes(final InputStream is) {
        assertArgumentNotNull("is", is);

            newOutputs = outputs;
        }
    }

    /**
     * Gets the new input words.
     *
     * @return The new input words.
     */
    public String[] getNewInputs() {
        return newInputs;
    }

    /**
     * Sets the new input words.
     *
     * @param newInputs The new input words.
     */
    public void setNewInputs(final String[] newInputs) {

     * and object data from the byte array input stream.
     * </p>
     *
     * @param bytes the byte array to deserialize
     * @return the deserialized object
     */
    protected Object deserializeWithKryo(final byte[] bytes) {
        final Kryo kryo = kryoThreadLocal.get();
        try (final Input input = new Input(new ByteArrayInputStream(bytes))) {

    void testWriteReadInt4RoundTrip(long input) {
        byte[] buffer = new byte[8];
        SMBUtil.writeInt4(input, buffer, 0);
        int result = SMBUtil.readInt4(buffer, 0);
        assertEquals((int) (input & 0xFFFFFFFFL), result);
    }

    @ParameterizedTest
    @ValueSource(longs = { 0L, 1L, -1L, Long.MAX_VALUE, Long.MIN_VALUE, 0x123456789ABCDEF0L })

  @Param({"xxxx", "xxXx", "xXxX", "XXXX"})
  String text;

  private String input;

  private static final Splitter CHAR_SPLITTER = Splitter.on('X');
  private static final Splitter STRING_SPLITTER = Splitter.on("X");

  @BeforeExperiment
  @SuppressWarnings("InlineMeInliner") // String.repeat unavailable under Java 8
  void setUp() {
    input = Strings.repeat(text, length);
  }

  @Benchmark
  int charSplitter(int reps) {

        }

        @Test
        @DisplayName("Should encode input parameters correctly")
        void testEncodeIn() throws NdrException {
            // Given: Close handle message
            samr.SamrCloseHandle message = new samr.SamrCloseHandle(mockPolicyHandle);

            // When: Encoding input
            message.encode_in(mockNdrBuffer);

            // Then: Should encode handle

        StopwordsItem item4 = new StopwordsItem(1, "different");

        // Same input should have same hashCode regardless of id
        assertEquals(item1.hashCode(), item2.hashCode());
        assertEquals(item1.hashCode(), item3.hashCode());

        // Different input should have different hashCode
        assertNotSame(item1.hashCode(), item4.hashCode());
    }