if (value instanceof final LocalDateTime ldt) {
            final ZonedDateTime zdt = ZonedDateTime.of(ldt, ZoneId.systemDefault());
            super.addFieldToSource(sourceMap, field, DateTimeFormatter.ISO_INSTANT.format(zdt));
        } else {
            super.addFieldToSource(sourceMap, field, value);
        }
    }

    @Override

        var value: String? = null
        accept(object : MemberValueVisitorAdapter() {
            override fun visitStringMemberValue(node: StringMemberValue) {
                value = node.value
            }
        })
        if (value == null) throw annotationMemberValueNotFound(typeOf<String>())
        return value!!
    }


internal
val MemberValue.intArrayValue: IntArray
    get() {
        var value: IntArray? = null

        assertEquals(negativeValue, ndrLongNegative.value, "Constructor should correctly initialize with a negative value.");

        // Test case 3: Zero value
        int zeroValue = 0;
        NdrLong ndrLongZero = new NdrLong(zeroValue);
        assertEquals(zeroValue, ndrLongZero.value, "Constructor should correctly initialize with zero.");

        // Test case 4: Max int value
        int maxIntValue = Integer.MAX_VALUE;

                                      const char* value) {
  cell->cell.Set({value});
}

const void TFE_MonitoringStringGaugeCellValue(
    TFE_MonitoringStringGaugeCell* cell, TF_Buffer* buf) {
  tensorflow::string value = cell->cell.value();
  void* data = tensorflow::port::Malloc(value.length());
  value.copy(static_cast<char*>(data), value.length(), 0);
  buf->data = data;
  buf->length = value.length();

  public void testHashCode() {
    for (double value : VALUES) {
      assertThat(Doubles.hashCode(value)).isEqualTo(Double.hashCode(value));
    }
  }

  @SuppressWarnings("InlineMeInliner") // We need to test our method.
  public void testIsFinite() {
    for (double value : NUMBERS) {
      assertThat(Doubles.isFinite(value)).isEqualTo(Double.isFinite(value));
    }
  }

        value = "ja-JP";
        assertEquals("ja", systemHelper.normalizeLang(value));

        value = "ja_JP";
        assertEquals("ja", systemHelper.normalizeLang(value));

        value = "ja_JP_AAA";
        assertEquals("ja", systemHelper.normalizeLang(value));

        value = "zh";
        assertEquals("zh", systemHelper.normalizeLang(value));

        value = "zh-cn";

    }

    /**
     * Converts value to lowercase if lowercase wildcard is enabled.
     *
     * @param value the value to convert
     * @return the converted value
     */
    protected String toLowercaseWildcard(final String value) {
        if (lowercaseWildcard) {
            return value.toLowerCase(Locale.ROOT);
        }
        return value;
    }

    /**

            if (key.isEmpty()) continue;
            if (!props.containsKey(key)) {
                missing.add(key);
                continue;
            }
            String value = props.get(key);
            if (value == null || value.trim().isEmpty()) {
                empty.add(key);
            }
        }

        if (!missing.isEmpty() || !empty.isEmpty()) {
            if (!missing.isEmpty()) {

  private static final LazyLogger log = new LazyLogger(ImmediateFuture.class);

  @ParametricNullness private final V value;

  ImmediateFuture(@ParametricNullness V value) {
    this.value = value;
  }

  @Override
  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  public void addListener(Runnable listener, Executor executor) {

    return old;
  }

  static boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
    if (future.value == expect) {
      future.value = update;
      return true;
    }
    return false;
  }

  final @Nullable Object value() {
    return value;
  }

  final @Nullable Listener listeners() {
    return listeners;
  }

  final void releaseWaiters() {}