// Create a simple BooleanQuery with MUST clause
        BooleanQuery.Builder boolQueryBuilder = new BooleanQuery.Builder();
        TermQuery termQuery = new TermQuery(new Term("field", "value"));
        boolQueryBuilder.add(termQuery, BooleanClause.Occur.MUST);
        BooleanQuery booleanQuery = boolQueryBuilder.build();

        QueryContext context = new QueryContext("test", false);

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Marks a dependency injection point for constructor, method, or field injection.
 * <p>
 * This annotation is used to identify injection points where the container should

			wantErr: `Each form field that you specify in a form must appear in the list of policy conditions. "X-Amz-Meta-Name" not specified in the policy.`,
		},
		{
			name:    "unknown key XAmzChecksumAlgo is error as it does not appear in policy",
			fv:      defaultFormVals.Clone().Set(http.CanonicalHeaderKey(xhttp.AmzChecksumAlgo), "algo-val"),

        SMBUtil.writeInt4(expectedLength, buffer, 0);

        int result = response.readParametersWireFormat(buffer, 0, buffer.length);

        assertEquals(4, result);

        // Access private field to verify length was set
        Field lengthField = response.getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredField("length");
        lengthField.setAccessible(true);
        int actualLength = (int) lengthField.get(response);

        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

    }
  }

  @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();
      }
    }
  }

        final Map<TypeVariable<?>, Type> map = ParameterizedClassDescFactory.getTypeVariables(Hoge.class);
        final Field field = Hoge.class.getField("foo");
        final ParameterizedClassDesc desc = ParameterizedClassDescFactory.createParameterizedClassDesc(field, map);
        assertThat(desc.getRawClass(), is(sameClass(Map.class)));

        final ParameterizedClassDesc[] args = desc.getArguments();

        queryBuilderList.add(builder);
    }

    protected void regOBA(String field) {
        registerOrderBy(field, true);
    }

    protected void regOBD(String field) {
        registerOrderBy(field, false);
    }

    protected void registerOrderBy(String field, boolean ascOrDesc) {
        assertObjectNotNull("field", field);
        if (fieldSortBuilderList == 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
		}

        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());