byte[] data = createTestData(32);

        // When
        String result = Hexdump.toHexString(data, 0, data.length);

        // Then
        assertNotNull(result);
        assertFalse(result.isEmpty());
        // Should contain hex representation of first bytes
        assertTrue(result.startsWith("00010203"));
        assertEquals(64, result.length()); // 32 bytes * 2 chars per byte
    }

    @ParameterizedTest

    assertThat(factory.getSinkContents()).isEqualTo(expected);
  }

  private void assertContainsExpectedLines(String separator) throws IOException {
    String expected = expectedLines.isEmpty() ? "" : Joiner.on(separator).join(expectedLines);
    if (!lines.isEmpty()) {
      // if we wrote any lines in writeLines(), there will be a trailing newline
      expected += separator;
    }
    assertThat(factory.getSinkContents()).isEqualTo(expected);

        } else {
            return toDouble(o.toString());
        }
    }

    private static Double toDouble(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Double.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * Converts to {@literal double}.
     *
     * @param o

    @Override
    protected SortedSet<Integer> create(Integer[] elements) {
      SortedSet<Integer> set = nullCheckedTreeSet(elements);
      int tooHigh = set.isEmpty() ? 0 : set.last() + 1;
      set.add(tooHigh);
      return checkedCreate(set).headSet(tooHigh);
    }
  }

  public static class ContiguousSetTailsetGenerator extends AbstractContiguousSetGenerator {

    set.clear();
    assertTrue(set.isEmpty());
    assertEquals(singleton("foo"), sortedTable.rowKeySet());
  }

  public void testRowKeySetTailSet() {
    sortedTable = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    Set<String> set = sortedTable.rowKeySet().tailSet("cat");
    assertEquals(singleton("foo"), set);
    set.clear();
    assertTrue(set.isEmpty());

                    if (arList.isEmpty()) {
                        emptyListCount++;
                    } else {
                        emptyListCount = 0; // reset
                    }
                    long hitCount = ((OpenSearchResultList<OpenSearchAccessResult>) arList).getTotalHits();
                    while (hitCount > 0) {
                        if (arList.isEmpty()) {

            return ((Boolean) o) ? (byte) 1 : (byte) 0;
        } else {
            return toByte(o.toString());
        }
    }

    private static Byte toByte(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Byte.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * Converts to {@literal byte}.
     *
     * @param o

                sb.append(LS);
                sb.append("from the specified remote repositories:");
                sb.append(LS).append("  ");

                if (remoteRepositories.isEmpty()) {
                    sb.append("(none)");
                }

                for (Iterator<ArtifactRepository> i = remoteRepositories.iterator(); i.hasNext(); ) {

        String queryId = JsonPath.from(searchResponse).getString("query_id");
        assertTrue(queryId != null && !queryId.isEmpty(), "queryId should not be null");

        // Now test the favorites API
        Map<String, String> params = new HashMap<>();
        params.put("queryId", queryId);

        given().contentType("application/json")

    public void test_drainAll_empty() {
        LogNotificationHelper helper = new LogNotificationHelper();
        List<LogNotificationEvent> events = helper.drainAll();
        assertNotNull(events);
        assertTrue(events.isEmpty());
    }

    @Test
    public void test_drainAll_clears() {
        LogNotificationHelper helper = new LogNotificationHelper();
        helper.offer(new LogNotificationEvent(1000L, "ERROR", "org.test", "msg", null));