// For datasets of many double values created from an array, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();
      StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
      accumulator.addAll(values.asArray());
      for (double value : values.asIterable()) {

        final byte[] binary = fromObjectToBinary(obj);
        return fromBinaryToObject(binary);
    }

    /**
     * Converts an object to a byte array.
     *
     * @param obj the object to serialize (must not be {@literal null})
     * @return the byte array of the object
     */
    public static byte[] fromObjectToBinary(final Object obj) {
        assertArgumentNotNull("obj", obj);

        try {

      }
      Class<?> returnType = method.getReturnType();
      assertTrue(
          rootLocaleFormat("%s.%s() must return an array.", annotationClass, propertyName),
          returnType.isArray());
      assertWithMessage(
              rootLocaleFormat(
                  "%s.%s() must return an array of %s.",
                  annotationClass, propertyName, annotationClass.getDeclaringClass()))
          .that(returnType.getComponentType())

 *   <li>Structured text extraction with key-value pairs</li>
 *   <li>Top-level field extraction as metadata</li>
 *   <li>Nested structure flattening with configurable depth</li>
 *   <li>Array element extraction</li>
 *   <li>Configurable field separator and array formatting</li>
 * </ul>
 */
public class JsonExtractor extends AbstractExtractor {
    /** Logger instance for this class. */

            }
            if (value.getClass().isArray()) {
                // Handle both Object[] and primitive arrays safely
                final int newLength = Array.getLength(value);
                final Object[] values = Arrays.copyOf(oldValues, oldValues.length + newLength);
                for (int i = 0; i < newLength; i++) {
                    values[oldValues.length + i] = Array.get(value, i);
                }

    T[] result = newArray(array, array.length + 1);
    result[0] = element;
    arraycopy(array, 0, result, 1, array.length);
    return result;
  }

  /**
   * Returns a new array that appends {@code element} to {@code array}.
   *
   * @param array the array of elements to prepend
   * @param element the element to append to the end

        String value3 = "c";
        settings.array().add(key, value1);
        settings.array().add(key, value2);
        settings.array().add(key, value3);
        assertEquals(3, settings.array().get(key).length);
        assertEquals(value1, settings.array().get(key)[0]);
        assertEquals(value2, settings.array().get(key)[1]);
        assertEquals(value3, settings.array().get(key)[2]);
    }

    @Test

    T[] result = newArray(array, array.length + 1);
    result[0] = element;
    arraycopy(array, 0, result, 1, array.length);
    return result;
  }

  /**
   * Returns a new array that appends {@code element} to {@code array}.
   *
   * @param array the array of elements to prepend
   * @param element the element to append to the end

  private final int end; // exclusive

  private ImmutableLongArray(long[] array) {
    this(array, 0, array.length);
  }

  private ImmutableLongArray(long[] array, int start, int end) {
    this.array = array;
    this.start = start;
    this.end = end;
  }

  /** Returns the number of values in this array. */
  public int length() {
    return end - start;
  }

  private final int end; // exclusive

  private ImmutableIntArray(int[] array) {
    this(array, 0, array.length);
  }

  private ImmutableIntArray(int[] array, int start, int end) {
    this.array = array;
    this.start = start;
    this.end = end;
  }

  /** Returns the number of values in this array. */
  public int length() {
    return end - start;
  }