* <p>
     * This method uses {@link java.util.Base64.Encoder} for encoding.
     * </p>
     *
     * @param inData
     *            The data to encode
     * @return The encoded data, or an empty string if the input is null or empty
     */
    public static String encode(final byte[] inData) {
        if (ArrayUtil.isEmpty(inData)) {
            return "";
        }
        return Base64.getEncoder().encodeToString(inData);

    /**
     * Gets the current project (if any).
     *
     * @return the current project or {@code empty()} if not applicable
     */
    @Nonnull
    Optional<Project> getProject();

    /**
     * Gets the current mojo execution (if any).
     *
     * @return the current mojo execution or {@code empty()} if not applicable
     */
    @Nonnull
    Optional<MojoExecution> getMojoExecution();

    /**

        if (!result.hasExceptions()) {
            return Optional.empty();
        }

        List<MavenProject> sortedProjects = result.getTopologicallySortedProjects();

        boolean hasNoSuccess =
                sortedProjects.stream().noneMatch(project -> result.getBuildSummary(project) instanceof BuildSuccess);

        if (hasNoSuccess) {
            return Optional.empty();
        }

    assertEquals(Object[].class, array.getClass());
  }

  public void testToArray_emptyArray() {
    E[] empty = getSubjectGenerator().createArray(0);
    E[] array = collection.toArray(empty);
    assertEquals(
        "toArray(emptyT[]) should return an array of type T", empty.getClass(), array.getClass());
    assertEquals("toArray(emptyT[]).length:", getNumElements(), array.length);

        assertEquals("a,b,c,d,e,f", result);
    }

    @Test
    @DisplayName("Should handle empty array")
    void testJoinEmptyArray() {
        CharSequence[] empty = new CharSequence[0];
        String result = StringUtil.join(",", empty);
        assertEquals("", result);
    }

    @Test
    @DisplayName("Should handle null in middle of multiple elements")

     * If the virtual host is blank or null, returns an empty string.
     *
     * @param entity the RelatedQuery entity to extract the host key from
     * @return the virtual host key, or empty string if blank or null
     */
    protected String getHostKey(final RelatedQuery entity) {
        final String key = entity.getVirtualHost();
        return StringUtil.isBlank(key) ? StringUtil.EMPTY : key;
    }

    /**

  }

  private static final Map<Integer, Integer> EMPTY = emptyMap();
  private static final Map<Integer, Integer> SINGLETON = singletonMap(1, 2);

  public void testMapDifferenceEmptyEmpty() {
    MapDifference<Integer, Integer> diff = Maps.difference(EMPTY, EMPTY);
    assertTrue(diff.areEqual());
    assertEquals(EMPTY, diff.entriesOnlyOnLeft());
    assertEquals(EMPTY, diff.entriesOnlyOnRight());

        // Should not throw exception when adding empty list
        // This validates the early return optimization
        try {
            urlFilterService.addIncludeUrlFilter(sessionId, emptyList);
        } catch (final Exception e) {
            fail("Should not throw exception for empty list: " + e.getMessage());
        }

        // Since no items were added, the pattern list should be empty

type result struct {
	dir     string
	entries []string
}

// Test to read empty directory.
func setupTestReadDirEmpty(t *testing.T) (testResults []result) {
	// Add empty entry slice for this test directory.
	testResults = append(testResults, result{t.TempDir(), []string{}})
	return testResults
}

// Test to read non-empty directory with only files.
func setupTestReadDirFiles(t *testing.T) (testResults []result) {

    }

    // Edge/Invalid: empty string is invalid for valueOf
    @ParameterizedTest
    @EmptySource
    @DisplayName("valueOf(\"\") throws IllegalArgumentException for empty input")
    void valueOfRejectsEmpty(String empty) {
        assertThrows(IllegalArgumentException.class, () -> RequestParam.valueOf(empty));
    }

    // Invalid: null is not allowed for valueOf