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

func (z *metacache) 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
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "end":
			z.ended, err = dc.ReadTime()

        result = ParameterUtil.createConfigParameterMap(configParameters);
        assertEquals(2, result.get(ConfigName.FIELD).size());
        assertEquals("standard", result.get(ConfigName.FIELD).get("analyzer"));
        assertEquals("true", result.get(ConfigName.FIELD).get("store"));

        // Test with mixed parameters
        configParameters =

    }
  }

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

                    @Nullable public String foo() { return "bar"; }
                }
            """
        ) {
            assertHasErrors(
                "Field nonFinalField: Nullability breaking change.",
                "Field finalField: From non-nullable to nullable breaking change.",
                "Method com.example.Source.foo(): From non-null returning to null returning breaking change."
            )

    }

    @Benchmark
    public void termsSum() throws IOException {
        buildFactories(
            new AggregatorFactories.Builder().addAggregator(
                new TermsAggregationBuilder("t").field("int_1").subAggregation(new SumAggregationBuilder("s").field("int_2"))
            )
        );
    }

    @Benchmark

        "detail": [
            {
                "loc": ["body", "name"],
                "input": {},
                "msg": "Field required",
                "type": "missing",
            },
            {
                "loc": ["body", "price"],
                "input": {},
                "msg": "Field required",
                "type": "missing",
            },
        ]
    }

        DefaultArtifactDescriptorReader pomReader =
                (DefaultArtifactDescriptorReader) getContainer().lookup(ArtifactDescriptorReader.class);
        Field field = DefaultArtifactDescriptorReader.class.getDeclaredField("artifactResolver");
        field.setAccessible(true);
        field.set(pomReader, resolver);

        projectBuilder = getContainer().lookup(ProjectBuilder.class, "classpath");
    }

    @Test

                }
            }

        } else if (member instanceof JApiField) {

            JApiField field = (JApiField) member
            CtField oldField = field.oldFieldOptional.get()
            CtField newField = field.newFieldOptional.get()

            def oldNullability = nullabilityOf(oldField)
            def newNullability = nullabilityOf(newField)

   *
   * Then we declare the getters for these fields as @GwtIncompatible so that no one can try to use
   * them under J2CL—or, as an unfortunate side effect, under GWT. We do still give the fields
   * themselves their proper values under GWT, since GWT's EnumMap does need the Class instance.
   *
   * Note that sometimes these fields *do* have correct values under J2CL: They will if the caller