// Arrange
        SecurityBlob blob = new SecurityBlob(new byte[] { 1, 2, 3 });

        // Force internal field to null via reflection to exercise defensive branch
        Field field = SecurityBlob.class.getDeclaredField("b");
        field.setAccessible(true);
        field.set(blob, null);

        // Act & Assert
        assertEquals(0, blob.length(), "length() should return 0 when internal array is null");

func (z *xlMetaDataDirDecoder) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}

        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

        validator = factory.getValidator();
    }

    // Test annotation attributes and defaults
    public void test_annotationAttributes() throws Exception {
        Field field = TestBean.class.getDeclaredField("cronExpression");
        CronExpression annotation = field.getAnnotation(CronExpression.class);

        assertNotNull(annotation);
        assertEquals("{org.lastaflute.validator.constraints.CronExpression.message}", annotation.message());

  transient volatile int busy;

  /** Package-private default constructor */
  Striped64() {}

  /** CASes the base field. */
  final boolean casBase(long cmp, long val) {
    return UNSAFE.compareAndSwapLong(this, BASE_OFFSET, cmp, val);
  }

  /** CASes the busy field from 0 to 1 to acquire lock. */
  final boolean casBusy() {
    return UNSAFE.compareAndSwapInt(this, BUSY_OFFSET, 0, 1);
  }

  /**

    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testConstants_charset() throws Exception {
    for (Field field : getConstantFields()) {
      Optional<Charset> charset = ((MediaType) field.get(null)).charset();
      if (field.getName().endsWith("_UTF_8")) {
        assertThat(charset).hasValue(UTF_8);
      } else {
        assertThat(charset).isAbsent();
      }
    }
  }

     */
    Waiter(boolean unused) {}

    Waiter() {
      // avoid volatile write, write is made visible by subsequent CAS on waitersField field
      putThread(this, Thread.currentThread());
    }

    // non-volatile write to the next field. Should be made visible by a subsequent CAS on
    // waitersField.
    void setNext(@Nullable Waiter next) {
      putNext(this, next);
    }

            // Use reflection to verify the information level
            Field infoLevel = Trans2QueryPathInformationResponse.class.getDeclaredField("informationLevel");
            infoLevel.setAccessible(true);
            assertEquals(Trans2QueryPathInformationResponse.SMB_QUERY_FILE_BASIC_INFO, infoLevel.getInt(resp));

            // Verify subCommand is set correctly
            Field subCmd = SmbComTransactionResponse.class.getDeclaredField("subCommand");

public abstract interface class okhttp3/sse/EventSource {
	public static final field Companion Lokhttp3/sse/EventSource$Companion;
	public abstract fun cancel ()V
	public static fun enqueue (Lokhttp3/Call;Lokhttp3/sse/EventSourceListener;)Lokhttp3/sse/EventSource;
	public static fun process (Lokhttp3/Response;Lokhttp3/sse/EventSourceListener;)V
	public abstract fun request ()Lokhttp3/Request;
}

public final class okhttp3/sse/EventSource$Companion {

        ASN1EncodableVector v = new ASN1EncodableVector();

        // crealm (field 2)
        v.add(new DERTaggedObject(true, 2, new DERGeneralString(userRealm)));

        // cname (field 3)
        ASN1EncodableVector principalNameVector = new ASN1EncodableVector();
        principalNameVector.add(new DERGeneralString(userName));