starting build "be215a65-dea8-4984-adab-1ba868e208d7" using release legacy

FETCHSOURCE
BUILD
Starting Step #0
Step #0: Already have image (with digest): gcr.io/cloud-builders/git
Step #0: Cloning into 'oss-fuzz'...
Finished Step #0
Starting Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c"
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Already have image (with digest): gcr.io/cloud-builders/docker
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Sending build context to Docker daemon  3.584kB

Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Step 1/7 : FROM gcr.io/oss-fuzz-base/base-builder-jvm
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": latest: Pulling from oss-fuzz-base/base-builder-jvm
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": b549f31133a9: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 950ef7e48fca: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": dbc1400359b3: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": bf138baf0e0c: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a18d8b15bcb6: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9141c5292b93: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 333bc152e38b: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d2e04246cd74: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 34a42f545004: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1ad3ce4450d4: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 87444af55c70: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f52137f63bcd: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0faee0d18542: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 840382fa6087: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 02a08d7577cc: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9bf56742bb1d: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f8412fff7558: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 7556f5345239: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 068e5843bad0: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 732ca0fc96c1: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d3bd634949a2: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 17777fe92006: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 19f7622fef68: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d8d65189d018: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5892392064d0: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9483678fd6d2: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5363690b9d63: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 7cf4a1cdb0ed: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67ab928ffae2: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1f7369c21809: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a7f76cb85d41: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": ad4194293ae3: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 13b4112edd58: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 28f4509e9b20: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": c04682c1355a: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 4531fc26693a: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 3c8092a0ee2f: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f53647bbe05a: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": fce1bd5d6f0c: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": ec36753f8c44: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 333bc152e38b: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0516f0a12735: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": b3762eefd7b6: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d2e04246cd74: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67f78b8bf27c: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 39e3b36a99d6: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d79b358c5548: Pulling fs layer
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 34a42f545004: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9483678fd6d2: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5363690b9d63: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1ad3ce4450d4: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": b3762eefd7b6: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 87444af55c70: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 3c8092a0ee2f: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67f78b8bf27c: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f52137f63bcd: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": ec36753f8c44: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 39e3b36a99d6: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67ab928ffae2: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 13b4112edd58: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f53647bbe05a: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": c04682c1355a: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0516f0a12735: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 732ca0fc96c1: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 28f4509e9b20: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d79b358c5548: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0faee0d18542: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1f7369c21809: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": fce1bd5d6f0c: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 4531fc26693a: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f8412fff7558: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d3bd634949a2: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a7f76cb85d41: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 068e5843bad0: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9bf56742bb1d: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 840382fa6087: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 02a08d7577cc: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5892392064d0: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d8d65189d018: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 19f7622fef68: Waiting
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a18d8b15bcb6: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a18d8b15bcb6: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": dbc1400359b3: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": dbc1400359b3: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d2e04246cd74: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 333bc152e38b: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 333bc152e38b: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": b549f31133a9: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": b549f31133a9: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": bf138baf0e0c: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": bf138baf0e0c: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 87444af55c70: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 87444af55c70: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f52137f63bcd: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f52137f63bcd: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 840382fa6087: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 840382fa6087: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0faee0d18542: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0faee0d18542: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9bf56742bb1d: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9bf56742bb1d: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 02a08d7577cc: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 02a08d7577cc: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 950ef7e48fca: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 950ef7e48fca: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1ad3ce4450d4: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1ad3ce4450d4: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 7556f5345239: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 7556f5345239: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 068e5843bad0: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 068e5843bad0: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f8412fff7558: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f8412fff7558: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 732ca0fc96c1: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 732ca0fc96c1: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 17777fe92006: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 17777fe92006: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d3bd634949a2: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d3bd634949a2: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d8d65189d018: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d8d65189d018: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 19f7622fef68: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5892392064d0: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5892392064d0: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5363690b9d63: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5363690b9d63: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 7cf4a1cdb0ed: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 7cf4a1cdb0ed: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9483678fd6d2: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": b549f31133a9: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67ab928ffae2: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67ab928ffae2: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a7f76cb85d41: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a7f76cb85d41: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": ad4194293ae3: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": ad4194293ae3: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1f7369c21809: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1f7369c21809: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 13b4112edd58: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 13b4112edd58: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 28f4509e9b20: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 28f4509e9b20: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": c04682c1355a: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 4531fc26693a: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 34a42f545004: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 34a42f545004: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 3c8092a0ee2f: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f53647bbe05a: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f53647bbe05a: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": ec36753f8c44: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": b3762eefd7b6: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0516f0a12735: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67f78b8bf27c: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 39e3b36a99d6: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 39e3b36a99d6: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d79b358c5548: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d79b358c5548: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": fce1bd5d6f0c: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": fce1bd5d6f0c: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9141c5292b93: Verifying Checksum
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9141c5292b93: Download complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 950ef7e48fca: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": dbc1400359b3: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": bf138baf0e0c: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a18d8b15bcb6: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9141c5292b93: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 333bc152e38b: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d2e04246cd74: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 34a42f545004: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1ad3ce4450d4: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 87444af55c70: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f52137f63bcd: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0faee0d18542: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 840382fa6087: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 02a08d7577cc: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9bf56742bb1d: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f8412fff7558: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 7556f5345239: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 068e5843bad0: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 732ca0fc96c1: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d3bd634949a2: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 17777fe92006: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 19f7622fef68: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d8d65189d018: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5892392064d0: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 9483678fd6d2: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 5363690b9d63: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 7cf4a1cdb0ed: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67ab928ffae2: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 1f7369c21809: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": a7f76cb85d41: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": ad4194293ae3: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 13b4112edd58: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 28f4509e9b20: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": c04682c1355a: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 4531fc26693a: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 3c8092a0ee2f: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": f53647bbe05a: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": fce1bd5d6f0c: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": ec36753f8c44: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0516f0a12735: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": b3762eefd7b6: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 67f78b8bf27c: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 39e3b36a99d6: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": d79b358c5548: Pull complete
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Digest: sha256:bd13a763de1a0fb22099442094e7e0049657a8c47f01e9d7af8bb849e0ad4699
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Status: Downloaded newer image for gcr.io/oss-fuzz-base/base-builder-jvm:latest
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> 9c68eaf55d1f
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Step 2/7 : RUN apt-get update && apt-get install -y locales
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> Running in 87d7a32fd746
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:1 http://security.ubuntu.com/ubuntu focal-security InRelease [128 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Hit:2 http://archive.ubuntu.com/ubuntu focal InRelease
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:3 http://archive.ubuntu.com/ubuntu focal-updates InRelease [128 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:4 http://security.ubuntu.com/ubuntu focal-security/universe i386 Packages [859 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:5 http://archive.ubuntu.com/ubuntu focal-backports InRelease [128 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:6 http://security.ubuntu.com/ubuntu focal-security/universe amd64 Packages [1300 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:7 http://archive.ubuntu.com/ubuntu focal-updates/main i386 Packages [1369 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:8 http://archive.ubuntu.com/ubuntu focal-updates/universe i386 Packages [1017 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:9 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 Packages [4850 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:10 http://archive.ubuntu.com/ubuntu focal-updates/universe amd64 Packages [1588 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Fetched 11.4 MB in 1s (9056 kB/s)
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Reading package lists...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Reading package lists...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Building dependency tree...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Reading state information...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": The following packages were automatically installed and are no longer required:
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":   autotools-dev libsigsegv2 m4
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Use 'apt autoremove' to remove them.
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": The following NEW packages will be installed:
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":   locales
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": 0 upgraded, 1 newly installed, 0 to remove and 0 not upgraded.
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Need to get 3864 kB of archives.
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": After this operation, 17.6 MB of additional disk space will be used.
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Get:1 http://archive.ubuntu.com/ubuntu focal-updates/main amd64 locales all 2.31-0ubuntu9.18 [3864 kB]
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": debconf: delaying package configuration, since apt-utils is not installed
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Fetched 3864 kB in 1s (7696 kB/s)
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Selecting previously unselected package locales.
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": (Reading database ... 
(Reading database ... 5%
(Reading database ... 10%
(Reading database ... 15%
(Reading database ... 20%
(Reading database ... 25%
(Reading database ... 30%
(Reading database ... 35%
(Reading database ... 40%
(Reading database ... 45%
(Reading database ... 50%
(Reading database ... 55%
(Reading database ... 60%
(Reading database ... 65%
(Reading database ... 70%
(Reading database ... 75%
(Reading database ... 80%
(Reading database ... 85%
(Reading database ... 90%
(Reading database ... 95%
(Reading database ... 100%
(Reading database ... 17483 files and directories currently installed.)
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Preparing to unpack .../locales_2.31-0ubuntu9.18_all.deb ...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Unpacking locales (2.31-0ubuntu9.18) ...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Setting up locales (2.31-0ubuntu9.18) ...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Generating locales (this might take a while)...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Generation complete.
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Removing intermediate container 87d7a32fd746
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> d78615f62d90
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Step 3/7 : RUN locale-gen en_US.UTF-8
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> Running in 460f788aabf1
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Generating locales (this might take a while)...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":   en_US.UTF-8... done
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Generation complete.
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Removing intermediate container 460f788aabf1
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> a25467ad2bdc
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Step 4/7 : ENV LC_ALL=en_US.UTF-8
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> Running in 6cb34e811d7a
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Removing intermediate container 6cb34e811d7a
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> 1705ef0d9e0a
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Step 5/7 : RUN git clone --depth=1 https://github.com/micronaut-projects/micronaut-fuzzing.git
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> Running in fd49ddfdae5a
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Cloning into 'micronaut-fuzzing'...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Removing intermediate container fd49ddfdae5a
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> b86ed508c3b2
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Step 6/7 : RUN micronaut-fuzzing/oss-fuzz/checkout.sh
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> Running in 3d9d9736e120
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Cloning into 'micronaut-core'...
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Updating files:  92% (11936/12973)
Updating files:  93% (12065/12973)
Updating files:  94% (12195/12973)
Updating files:  95% (12325/12973)
Updating files:  96% (12455/12973)
Updating files:  97% (12584/12973)
Updating files:  98% (12714/12973)
Updating files:  99% (12844/12973)
Updating files: 100% (12973/12973)
Updating files: 100% (12973/12973), done.
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Removing intermediate container 3d9d9736e120
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> e0b7c1e52f4a
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Step 7/7 : RUN ln -s micronaut-fuzzing/oss-fuzz/build.sh .
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> Running in 630e7ac8b390
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Removing intermediate container 630e7ac8b390
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c":  ---> 1c999b7ae637
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Successfully built 1c999b7ae637
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Successfully tagged gcr.io/oss-fuzz/micronaut:latest
Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c": Successfully tagged us-central1-docker.pkg.dev/oss-fuzz/unsafe/micronaut:latest
Finished Step #1 - "build-42af8d2d-4a3b-41ce-b96e-e5728df7da0c"
Starting Step #2 - "srcmap"
Step #2 - "srcmap": Already have image: gcr.io/oss-fuzz/micronaut
Step #2 - "srcmap": ++ tempfile
Step #2 - "srcmap": + SRCMAP=/tmp/fileWcuwxP
Step #2 - "srcmap": + echo '{}'
Step #2 - "srcmap": + PATHS_TO_SCAN=/src
Step #2 - "srcmap": + [[ jvm == \g\o ]]
Step #2 - "srcmap": ++ find /src -name .git -type d
Step #2 - "srcmap": + for DOT_GIT_DIR in $(find $PATHS_TO_SCAN -name ".git" -type d)
Step #2 - "srcmap": ++ dirname /src/micronaut-core/.git
Step #2 - "srcmap": + GIT_DIR=/src/micronaut-core
Step #2 - "srcmap": + cd /src/micronaut-core
Step #2 - "srcmap": ++ git config --get remote.origin.url
Step #2 - "srcmap": + GIT_URL=https://github.com/micronaut-projects/micronaut-core.git
Step #2 - "srcmap": ++ git rev-parse HEAD
Step #2 - "srcmap": + GIT_REV=136d1331e458524844e0546f379d34c979acba1c
Step #2 - "srcmap": + jq_inplace /tmp/fileWcuwxP '."/src/micronaut-core" = { type: "git", url: "https://github.com/micronaut-projects/micronaut-core.git", rev: "136d1331e458524844e0546f379d34c979acba1c" }'
Step #2 - "srcmap": ++ tempfile
Step #2 - "srcmap": + F=/tmp/fileM3H6Kb
Step #2 - "srcmap": + cat /tmp/fileWcuwxP
Step #2 - "srcmap": + jq '."/src/micronaut-core" = { type: "git", url: "https://github.com/micronaut-projects/micronaut-core.git", rev: "136d1331e458524844e0546f379d34c979acba1c" }'
Step #2 - "srcmap": + mv /tmp/fileM3H6Kb /tmp/fileWcuwxP
Step #2 - "srcmap": + for DOT_GIT_DIR in $(find $PATHS_TO_SCAN -name ".git" -type d)
Step #2 - "srcmap": ++ dirname /src/micronaut-fuzzing/.git
Step #2 - "srcmap": + GIT_DIR=/src/micronaut-fuzzing
Step #2 - "srcmap": + cd /src/micronaut-fuzzing
Step #2 - "srcmap": ++ git config --get remote.origin.url
Step #2 - "srcmap": + GIT_URL=https://github.com/micronaut-projects/micronaut-fuzzing.git
Step #2 - "srcmap": ++ git rev-parse HEAD
Step #2 - "srcmap": + GIT_REV=a965b9dd2f93e3d8e207ec6fa9e35efad8febc9c
Step #2 - "srcmap": + jq_inplace /tmp/fileWcuwxP '."/src/micronaut-fuzzing" = { type: "git", url: "https://github.com/micronaut-projects/micronaut-fuzzing.git", rev: "a965b9dd2f93e3d8e207ec6fa9e35efad8febc9c" }'
Step #2 - "srcmap": ++ tempfile
Step #2 - "srcmap": + F=/tmp/fileRaMtMH
Step #2 - "srcmap": + cat /tmp/fileWcuwxP
Step #2 - "srcmap": + jq '."/src/micronaut-fuzzing" = { type: "git", url: "https://github.com/micronaut-projects/micronaut-fuzzing.git", rev: "a965b9dd2f93e3d8e207ec6fa9e35efad8febc9c" }'
Step #2 - "srcmap": + mv /tmp/fileRaMtMH /tmp/fileWcuwxP
Step #2 - "srcmap": ++ find /src -name .svn -type d
Step #2 - "srcmap": ++ find /src -name .hg -type d
Step #2 - "srcmap": + '[' '' '!=' '' ']'
Step #2 - "srcmap": + cat /tmp/fileWcuwxP
Step #2 - "srcmap": + rm /tmp/fileWcuwxP
Step #2 - "srcmap": {
Step #2 - "srcmap":   "/src/micronaut-core": {
Step #2 - "srcmap":     "type": "git",
Step #2 - "srcmap":     "url": "https://github.com/micronaut-projects/micronaut-core.git",
Step #2 - "srcmap":     "rev": "136d1331e458524844e0546f379d34c979acba1c"
Step #2 - "srcmap":   },
Step #2 - "srcmap":   "/src/micronaut-fuzzing": {
Step #2 - "srcmap":     "type": "git",
Step #2 - "srcmap":     "url": "https://github.com/micronaut-projects/micronaut-fuzzing.git",
Step #2 - "srcmap":     "rev": "a965b9dd2f93e3d8e207ec6fa9e35efad8febc9c"
Step #2 - "srcmap":   }
Step #2 - "srcmap": }
Finished Step #2 - "srcmap"
Starting Step #3 - "compile-libfuzzer-coverage-x86_64"
Step #3 - "compile-libfuzzer-coverage-x86_64": Already have image (with digest): gcr.io/cloud-builders/docker
Step #3 - "compile-libfuzzer-coverage-x86_64": ---------------------------------------------------------------
Step #3 - "compile-libfuzzer-coverage-x86_64": vm.mmap_rnd_bits = 28
Step #3 - "compile-libfuzzer-coverage-x86_64": ---------------------------------------------------------------
Step #3 - "compile-libfuzzer-coverage-x86_64": CC=clang
Step #3 - "compile-libfuzzer-coverage-x86_64": CXX=clang++
Step #3 - "compile-libfuzzer-coverage-x86_64": CFLAGS=-O1   -fno-omit-frame-pointer   -gline-tables-only   -Wno-error=incompatible-function-pointer-types   -Wno-error=int-conversion   -Wno-error=deprecated-declarations   -Wno-error=implicit-function-declaration   -Wno-error=implicit-int   -Wno-error=unknown-warning-option   -Wno-error=vla-cxx-extension   -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION  -fprofile-instr-generate -fcoverage-mapping -pthread -Wl,--no-as-needed -Wl,-ldl -Wl,-lm -Wno-unused-command-line-argument -fno-sanitize=leak
Step #3 - "compile-libfuzzer-coverage-x86_64": CXXFLAGS=-O1   -fno-omit-frame-pointer   -gline-tables-only   -Wno-error=incompatible-function-pointer-types   -Wno-error=int-conversion   -Wno-error=deprecated-declarations   -Wno-error=implicit-function-declaration   -Wno-error=implicit-int   -Wno-error=unknown-warning-option   -Wno-error=vla-cxx-extension   -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION  -fprofile-instr-generate -fcoverage-mapping -pthread -Wl,--no-as-needed -Wl,-ldl -Wl,-lm -Wno-unused-command-line-argument -stdlib=libc++ -fno-sanitize=leak
Step #3 - "compile-libfuzzer-coverage-x86_64": RUSTFLAGS=--cfg fuzzing -Cdebuginfo=1 -Cforce-frame-pointers -Cinstrument-coverage -C link-arg=-lc++
Step #3 - "compile-libfuzzer-coverage-x86_64": ---------------------------------------------------------------
Step #3 - "compile-libfuzzer-coverage-x86_64": + set -e
Step #3 - "compile-libfuzzer-coverage-x86_64": + export JAVA_HOME=/workspace/out/libfuzzer-coverage-x86_64/jdk
Step #3 - "compile-libfuzzer-coverage-x86_64": + JAVA_HOME=/workspace/out/libfuzzer-coverage-x86_64/jdk
Step #3 - "compile-libfuzzer-coverage-x86_64": ++ sed -n 's/^managed-jazzer = "\(.*\)"/\1/p' micronaut-fuzzing/gradle/libs.versions.toml
Step #3 - "compile-libfuzzer-coverage-x86_64": + JAZZER_VERSION=0.30.0
Step #3 - "compile-libfuzzer-coverage-x86_64": + curl -L -O https://corretto.aws/downloads/latest/amazon-corretto-25-x64-linux-jdk.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":   % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  Dload  Upload   Total   Spent    Left  Speed
Step #3 - "compile-libfuzzer-coverage-x86_64": 
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
Step #3 - "compile-libfuzzer-coverage-x86_64": 
  6  217M    6 14.4M    0     0  69.3M      0  0:00:03 --:--:--  0:00:03 69.3M
100  217M  100  217M    0     0   222M      0 --:--:-- --:--:-- --:--:--  263M
Step #3 - "compile-libfuzzer-coverage-x86_64": + mkdir -p /workspace/out/libfuzzer-coverage-x86_64/jdk
Step #3 - "compile-libfuzzer-coverage-x86_64": + tar -xz --strip-components=1 -f amazon-corretto-25-x64-linux-jdk.tar.gz --directory /workspace/out/libfuzzer-coverage-x86_64/jdk
Step #3 - "compile-libfuzzer-coverage-x86_64": + rm -rf /workspace/out/libfuzzer-coverage-x86_64/jdk/jmods /workspace/out/libfuzzer-coverage-x86_64/jdk/lib/src.zip
Step #3 - "compile-libfuzzer-coverage-x86_64": + curl -fL -O https://github.com/CodeIntelligenceTesting/jazzer/releases/download/v0.30.0/jazzer-linux-x86-64.tar.gz
Step #3 - "compile-libfuzzer-coverage-x86_64":   % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  Dload  Upload   Total   Spent    Left  Speed
Step #3 - "compile-libfuzzer-coverage-x86_64": 
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
Step #3 - "compile-libfuzzer-coverage-x86_64": 
100 7120k  100 7120k    0     0  20.6M      0 --:--:-- --:--:-- --:--:-- 20.6M
Step #3 - "compile-libfuzzer-coverage-x86_64": + rm -rf jazzer
Step #3 - "compile-libfuzzer-coverage-x86_64": + mkdir jazzer
Step #3 - "compile-libfuzzer-coverage-x86_64": + tar -xz -f jazzer-linux-x86-64.tar.gz --directory jazzer
Step #3 - "compile-libfuzzer-coverage-x86_64": + cp jazzer/jazzer /workspace/out/libfuzzer-coverage-x86_64/micronaut_jazzer_driver
Step #3 - "compile-libfuzzer-coverage-x86_64": + cp jazzer/jazzer_standalone.jar /workspace/out/libfuzzer-coverage-x86_64/micronaut_jazzer_agent_deploy.jar
Step #3 - "compile-libfuzzer-coverage-x86_64": + chmod +x /workspace/out/libfuzzer-coverage-x86_64/micronaut_jazzer_driver
Step #3 - "compile-libfuzzer-coverage-x86_64": + export PATH=/workspace/out/libfuzzer-coverage-x86_64/jdk/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/out:/usr/lib/jvm/java-17-openjdk-amd64/bin
Step #3 - "compile-libfuzzer-coverage-x86_64": + PATH=/workspace/out/libfuzzer-coverage-x86_64/jdk/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/out:/usr/lib/jvm/java-17-openjdk-amd64/bin
Step #3 - "compile-libfuzzer-coverage-x86_64": + mkdir -p /root/.gradle
Step #3 - "compile-libfuzzer-coverage-x86_64": ++ pwd
Step #3 - "compile-libfuzzer-coverage-x86_64": + echo auto.include.git.dirs=/src
Step #3 - "compile-libfuzzer-coverage-x86_64": ++ cd micronaut-core
Step #3 - "compile-libfuzzer-coverage-x86_64": ++ git rev-parse --abbrev-ref HEAD
Step #3 - "compile-libfuzzer-coverage-x86_64": + export OSSFUZZ_MICRONAUT_BRANCH=5.3.x
Step #3 - "compile-libfuzzer-coverage-x86_64": + OSSFUZZ_MICRONAUT_BRANCH=5.3.x
Step #3 - "compile-libfuzzer-coverage-x86_64": + cd micronaut-fuzzing
Step #3 - "compile-libfuzzer-coverage-x86_64": + mkdir -p checkouts
Step #3 - "compile-libfuzzer-coverage-x86_64": + touch checkouts/catalog-micronaut-core.sha1
Step #3 - "compile-libfuzzer-coverage-x86_64": + ./gradlew --max-workers 2 micronaut-fuzzing-tests:prepareClusterFuzz
Step #3 - "compile-libfuzzer-coverage-x86_64": Fetching distribution.
Step #3 - "compile-libfuzzer-coverage-x86_64": Downloading https://services.gradle.org/distributions/gradle-9.8.1-bin.zip
Step #3 - "compile-libfuzzer-coverage-x86_64": ..............10%..............20%...............30%..............40%...............50%..............60%...............70%..............80%...............90%..............100%
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": Welcome to Gradle 9.8.1!
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": Here are the highlights of this release:
Step #3 - "compile-libfuzzer-coverage-x86_64":  - Java 27 support
Step #3 - "compile-libfuzzer-coverage-x86_64":  - Maven mirror settings reuse
Step #3 - "compile-libfuzzer-coverage-x86_64":  - Linked problem locations in build output
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": For more details see https://docs.gradle.org/9.8.1/release-notes.html
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": Starting a Gradle Daemon (subsequent builds will be faster)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": > Starting Daemon> IDLE│···············│ 0% INITIALIZING [96ms]│···············│ 0% INITIALIZING [196ms]│···············│ 0% INITIALIZING [296ms]│···············│ 0% INITIALIZING [396ms]│···············│ 0% INITIALIZING [496ms]│···············│ 0% INITIALIZING [596ms]│···············│ 0% INITIALIZING [696ms]│···············│ 0% INITIALIZING [796ms]> Evaluating settings│···············│ 0% INITIALIZING [897ms]│···············│ 0% INITIALIZING [997ms]│···············│ 0% INITIALIZING [1s]│···············│ 0% INITIALIZING [2s]│···············│ 0% INITIALIZING [3s]│···············│ 0% INITIALIZING [4s]> Evaluating settings > Compiling settings file 'settings.gradle.kts'│···············│ 0% INITIALIZING [5s]│···············│ 0% INITIALIZING [6s]│···············│ 0% INITIALIZING [7s]│···············│ 0% INITIALIZING [8s]│···············│ 0% INITIALIZING [9s]> Evaluating settings> Evaluating settings > Evaluating settings│···············│ 0% INITIALIZING [10s]> Evaluating settings > Evaluating settings > Compiling settings file 'jazzer-p│···············│ 0% INITIALIZING [11s]> Evaluating settings > Evaluating settings> Evaluating settings > Evaluating settings > Loading projects> Evaluating settings > Evaluating settings > :build-logic│···············│ 0% INITIALIZING [12s]> Evaluating settings > Evaluating settings > Resolve dependencies of detachedC│···············│ 0% INITIALIZING [13s]> Evaluating settings > Evaluating settings> Evaluating settings > Evaluating settings > Resolve dependencies of classpath
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │···············│ 0% INITIALIZING [14s]> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath  (16 lines not showing)> IDLE  (13 lines not showing)> Evaluating settings > Evaluating settings > Resolve dependencies of classpath  (2 lines not showing)> IDLE> IDLE> IDLE> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> IDLE│···············│ 0% INITIALIZING [15s]> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath  (2 lines not showing)> IDLE> IDLE> IDLE> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> IDLE│···············│ 0% INITIALIZING [16s]> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> IDLE> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> IDLE> IDLE│···············│ 0% INITIALIZING [17s]> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> IDLE> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> IDLE│···············│ 0% INITIALIZING [18s]> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath  (8 lines not showing)> IDLE> IDLE> IDLE> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Evaluating settings > Resolve dependencies of classpath> IDLE> IDLE> IDLE> Evaluating settings > Evaluating settings > Resolve dependencies of classpath│···············│ 0% INITIALIZING [19s]> IDLE> Evaluating settings > Evaluating settings> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> Evaluating settings > Evaluating settings > Resolve files of configuration 'c│···············│ 0% INITIALIZING [20s]> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c│···············│ 0% INITIALIZING [21s]> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c│···············│ 0% INITIALIZING [22s]> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c│···············│ 0% INITIALIZING [23s]> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE│···············│ 0% INITIALIZING [24s]> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c│···············│ 0% INITIALIZING [25s]> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE│···············│ 0% INITIALIZING [26s]> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE│···············│ 0% INITIALIZING [27s]> Evaluating settings > Evaluating settings > Resolve files of configuration 'c│···············│ 0% INITIALIZING [28s]> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c│···············│ 0% INITIALIZING [29s]│···············│ 0% INITIALIZING [30s]> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c│···············│ 0% INITIALIZING [31s]> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE> Evaluating settings > Evaluating settings > Resolve files of configuration 'c> IDLE│···············│ 0% INITIALIZING [32s]> Evaluating settings > Evaluating settings│···············│ 0% INITIALIZING [33s]│···············│ 0% INITIALIZING [34s]│···············│ 0% INITIALIZING [35s]│···············│ 0% INITIALIZING [36s]│···············│ 0% INITIALIZING [37s]│···············│ 0% INITIALIZING [38s]│···············│ 0% INITIALIZING [39s]│···············│ 0% INITIALIZING [40s]> Evaluating settings > Evaluating settings > Compiling settings file 'jazzer-p│···············│ 0% INITIALIZING [41s]> Evaluating settings > Evaluating settings> Evaluating settings > Resolve dependencies of incomingCatalogForMn0 > microna> Evaluating settings > Resolve dependencies of incomingCatalogForMn0 > jackson> Evaluating settings > Resolve dependencies of incomingCatalogForMn0 > kotlinx> Evaluating settings > Resolve dependencies of incomingCatalogForMn0 > netty-b> Evaluating settings > Resolve dependencies of incomingCatalogForMn0> Evaluating settings│···············│ 0% INITIALIZING [42s]> Evaluating settings > Resolve dependencies of incomingCatalogForMnLogging0 > > Evaluating settings> Evaluating settings > Resolve dependencies of incomingCatalogForMnTest0 > jun> Evaluating settings > Resolve dependencies of incomingCatalogForMnTest0 > kot> Evaluating settings > Resolve dependencies of incomingCatalogForMnTest0 > mic> Evaluating settings│···············│ 0% INITIALIZING [43s]Type-safe project accessors is an incubating feature.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │···············│ 0% INITIALIZING [44s]> IDLE> Evaluating settings> IDLE> IDLE> Evaluating settings > :micronaut-jazzer-plugin> Evaluating settings > :micronaut-jazzer-plugin > Requesting from remote build│···············│ 0% INITIALIZING [45s]> Evaluating settings > :micronaut-jazzer-plugin> Evaluating settings > :micronaut-jazzer-plugin > Building task graph of build> Evaluating settings > :micronaut-jazzer-plugin> Evaluating settings > :micronaut-jazzer-plugin > :build-logic:extractPluginRe> Evaluating settings > :micronaut-jazzer-plugin > :build-logic:compileJava > R│···············│ 0% INITIALIZING [46s]│···············│ 0% INITIALIZING [47s]│···············│ 0% INITIALIZING [48s]│···············│ 0% INITIALIZING [49s]│···············│ 0% INITIALIZING [50s]> Evaluating settings > :micronaut-jazzer-plugin > :build-logic:compileJava│···············│ 0% INITIALIZING [51s]│···············│ 0% INITIALIZING [52s]│···············│ 0% INITIALIZING [53s]│···············│ 0% INITIALIZING [54s]│···············│ 0% INITIALIZING [55s]│···············│ 0% INITIALIZING [56s]│···············│ 0% INITIALIZING [57s]│···············│ 0% INITIALIZING [58s]│···············│ 0% INITIALIZING [59s]│···············│ 0% INITIALIZING [1m]│···············│ 0% INITIALIZING [1m 1s]> Evaluating settings > :micronaut-jazzer-plugin > :build-logic:compileGroovyPl│···············│ 0% INITIALIZING [1m 2s]> Evaluating settings > :micronaut-jazzer-plugin > :build-logic:jar> Evaluating settings > :micronaut-jazzer-plugin│···············│ 0% INITIALIZING [1m 3s]> Evaluating settings > :micronaut-jazzer-plugin > Requesting from remote build> Evaluating settings > :micronaut-jazzer-plugin > Compiling build file 'jazzer│···············│ 0% INITIALIZING [1m 4s]> Evaluating settings> Evaluating settings > Compiling settings file 'settings.gradle.kts'Catalog changed for micronaut-core: triggering build.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │···············│ 0% INITIALIZING [1m 5s]> IDLE> Evaluating settings> IDLE> IDLE│···············│ 0% INITIALIZING [1m 6s]│···············│ 0% INITIALIZING [1m 7s]│···············│ 0% INITIALIZING [1m 8s]│···············│ 0% INITIALIZING [1m 9s]│···············│ 0% INITIALIZING [1m 10s]│···············│ 0% INITIALIZING [1m 11s]│···············│ 0% INITIALIZING [1m 12s]│···············│ 0% INITIALIZING [1m 13s]│···············│ 0% INITIALIZING [1m 14s]│···············│ 0% INITIALIZING [1m 15s]│···············│ 0% INITIALIZING [1m 16s]│···············│ 0% INITIALIZING [1m 17s]│···············│ 0% INITIALIZING [1m 18s]│···············│ 0% INITIALIZING [1m 19s]│···············│ 0% INITIALIZING [1m 20s]│···············│ 0% INITIALIZING [1m 21s]│···············│ 0% INITIALIZING [1m 22s]│···············│ 0% INITIALIZING [1m 23s]│···············│ 0% INITIALIZING [1m 24s]│···············│ 0% INITIALIZING [1m 25s]│···············│ 0% INITIALIZING [1m 26s]│···············│ 0% INITIALIZING [1m 27s]│···············│ 0% INITIALIZING [1m 28s]│···············│ 0% INITIALIZING [1m 29s]│···············│ 0% INITIALIZING [1m 30s]│···············│ 0% INITIALIZING [1m 31s]│···············│ 0% INITIALIZING [1m 32s]│···············│ 0% INITIALIZING [1m 33s]│···············│ 0% INITIALIZING [1m 34s]│···············│ 0% INITIALIZING [1m 35s]│···············│ 0% INITIALIZING [1m 36s]│···············│ 0% INITIALIZING [1m 37s]│···············│ 0% INITIALIZING [1m 38s]│···············│ 0% INITIALIZING [1m 39s]│···············│ 0% INITIALIZING [1m 40s]│···············│ 0% INITIALIZING [1m 41s]│···············│ 0% INITIALIZING [1m 42s]│···············│ 0% INITIALIZING [1m 43s]│···············│ 0% INITIALIZING [1m 44s]│···············│ 0% INITIALIZING [1m 45s]│···············│ 0% INITIALIZING [1m 46s]│···············│ 0% INITIALIZING [1m 47s]│···············│ 0% INITIALIZING [1m 48s]│···············│ 0% INITIALIZING [1m 49s]│···············│ 0% INITIALIZING [1m 50s]│···············│ 0% INITIALIZING [1m 51s]│···············│ 0% INITIALIZING [1m 52s]│···············│ 0% INITIALIZING [1m 53s]│···············│ 0% INITIALIZING [1m 54s]│···············│ 0% INITIALIZING [1m 55s]│···············│ 0% INITIALIZING [1m 56s]│···············│ 0% INITIALIZING [1m 57s]│···············│ 0% INITIALIZING [1m 58s]│···············│ 0% INITIALIZING [1m 59s]│···············│ 0% INITIALIZING [2m]│···············│ 0% INITIALIZING [2m 1s]│···············│ 0% INITIALIZING [2m 2s]│···············│ 0% INITIALIZING [2m 3s]│···············│ 0% INITIALIZING [2m 4s]│···············│ 0% INITIALIZING [2m 5s]│···············│ 0% INITIALIZING [2m 6s]│···············│ 0% INITIALIZING [2m 7s]│···············│ 0% INITIALIZING [2m 8s]│···············│ 0% INITIALIZING [2m 9s]│···············│ 0% INITIALIZING [2m 10s]│···············│ 0% INITIALIZING [2m 11s]│···············│ 0% INITIALIZING [2m 12s]│···············│ 0% INITIALIZING [2m 13s]│···············│ 0% INITIALIZING [2m 14s]│···············│ 0% INITIALIZING [2m 15s]│···············│ 0% INITIALIZING [2m 16s]│···············│ 0% INITIALIZING [2m 17s]│···············│ 0% INITIALIZING [2m 18s]│···············│ 0% INITIALIZING [2m 19s]│···············│ 0% INITIALIZING [2m 20s]│···············│ 0% INITIALIZING [2m 21s]│···············│ 0% INITIALIZING [2m 22s]│···············│ 0% INITIALIZING [2m 23s]│···············│ 0% INITIALIZING [2m 24s]│···············│ 0% INITIALIZING [2m 25s]│···············│ 0% INITIALIZING [2m 26s]│···············│ 0% INITIALIZING [2m 27s]│···············│ 0% INITIALIZING [2m 28s]│···············│ 0% INITIALIZING [2m 29s]│···············│ 0% INITIALIZING [2m 30s]│···············│ 0% INITIALIZING [2m 31s]│···············│ 0% INITIALIZING [2m 32s]│···············│ 0% INITIALIZING [2m 33s]│···············│ 0% INITIALIZING [2m 34s]│···············│ 0% INITIALIZING [2m 35s]│···············│ 0% INITIALIZING [2m 36s]│···············│ 0% INITIALIZING [2m 37s]│···············│ 0% INITIALIZING [2m 38s]│···············│ 0% INITIALIZING [2m 39s]│···············│ 0% INITIALIZING [2m 40s]│···············│ 0% INITIALIZING [2m 41s]│···············│ 0% INITIALIZING [2m 42s]│···············│ 0% INITIALIZING [2m 43s]│···············│ 0% INITIALIZING [2m 44s]> Evaluating settings > Resolve dependencies of classpath> Evaluating settings > Resolve files of configuration 'classpath' > Resolve fi> Evaluating settings > Resolve files of configuration 'classpath' > MergeInstr> Evaluating settings > Resolve files of configuration 'classpath' > MergeInstr> Evaluating settings > Resolve files of configuration 'classpath' > ExternalDe> Evaluating settings > Resolve files of configuration 'classpath' > ExternalDe> Evaluating settings > Resolve files of configuration 'classpath' > MergeInstr> Evaluating settings > Resolve files of configuration 'classpath' > ExternalDe> IDLE│···············│ 0% INITIALIZING [2m 45s]> Evaluating settings > Resolve files of configuration 'classpath' > ExternalDe> IDLE> Evaluating settings > Resolve files of configuration 'classpath'> Evaluating settings > Resolve files of configuration 'classpath' > MergeInstr> Evaluating settings > Resolve files of configuration 'classpath' > ExternalDe│···············│ 0% INITIALIZING [2m 46s]> Evaluating settings│···············│ 0% INITIALIZING [2m 47s]│···············│ 0% CONFIGURING [2m 47s]> Resolve dependencies of incomingCatalogForMnLogging0 > micronaut-logging-bom-> Resolve dependencies of incomingCatalogForMnTest0 > micronaut-test-bom-5.0.0.> Resolve dependencies of incomingCatalogForMnTest0 > rest-assured-bom-6.0.0.po> Resolve dependencies of incomingCatalogForMnTest0 > testcontainers-bom-2.0.5.> IDLE│···············│ 0% CONFIGURING [2m 48s]> Loading projects> Building buildSrc > Evaluating settings> Building buildSrc > :micronaut-core:buildSrc│▏··············│ 1% CONFIGURING [2m 48s]> Building buildSrc > Building task graph of build ':micronaut-core:buildSrc' >> Building buildSrc > :micronaut-core:buildSrc:extractPluginRequests > Requesti│▏··············│ 1% CONFIGURING [2m 49s]> Building buildSrc > :micronaut-core:buildSrc:generatePluginAdapters > Request> Building buildSrc > :micronaut-core:buildSrc:generatePluginAdapters > Unpacki> Building buildSrc > :micronaut-core:buildSrc:compileJava│▏··············│ 1% CONFIGURING [2m 50s]> Building buildSrc > :micronaut-core:buildSrc:compileJava > Requesting from re> Building buildSrc > :micronaut-core:buildSrc:compileGroovy│▏··············│ 1% CONFIGURING [2m 51s]> Building buildSrc > :micronaut-core:buildSrc:compileGroovy > Requesting from │▏··············│ 1% CONFIGURING [2m 52s]> Building buildSrc > :micronaut-core:buildSrc:compileGroovyPlugins > Requestin> Building buildSrc > :micronaut-core:buildSrc:jar> Building buildSrc > Resolve files of configuration ':micronaut-core:buildSrc:│▏··············│ 1% CONFIGURING [2m 53s]> :micronaut-core> :micronaut-core > Resolve files of configuration 'classpath' > Resolve files > :micronaut-core > Resolve files of configuration 'classpath' > Resolve files > IDLE│▏··············│ 1% CONFIGURING [2m 54s]> :micronaut-core > Resolve files of configuration 'classpath' > MergeInstrumen> :micronaut-core > Resolve files of configuration 'classpath' > MergeInstrumen> :micronaut-core > Resolve files of configuration 'classpath' > ExternalDepend> :micronaut-core > Resolve files of configuration 'classpath' > ExternalDepend> IDLE> :micronaut-core > Resolve files of configuration 'classpath' > ExternalDepend│▏··············│ 1% CONFIGURING [2m 55s]> IDLE> :micronaut-core > Resolve files of configuration 'classpath' > ExternalDepend> IDLE│▏··············│ 1% CONFIGURING [2m 56s]> :micronaut-core > Resolve files of configuration 'classpath'> :micronaut-core > :micronaut-core:benchmarks│▏··············│ 1% CONFIGURING [2m 57s]│▏··············│ 1% CONFIGURING [2m 58s]│▏··············│ 1% CONFIGURING [2m 59s]│▏··············│ 1% CONFIGURING [3m]> :micronaut-core > :micronaut-core:benchmarks > Requesting from remote build c> :micronaut-core > :micronaut-core:benchmarks > Resolve files of configuration> :micronaut-core > :micronaut-core:benchmarks│▏··············│ 1% CONFIGURING [3m 1s]> :micronaut-core > :micronaut-core:benchmarks > Compiling build file '../micro│▏··············│ 1% CONFIGURING [3m 2s]│▏··············│ 1% CONFIGURING [3m 3s]│▏··············│ 1% CONFIGURING [3m 4s]> :micronaut-core > :micronaut-core:benchmarks│▎··············│ 2% CONFIGURING [3m 4s]> :micronaut-core > :micronaut-core:micronaut-aop > Requesting from remote buil> :micronaut-core > :micronaut-core:micronaut-aop > Compiling build file '../mi> :micronaut-core > :micronaut-core:micronaut-aop│▎··············│ 2% CONFIGURING [3m 5s]│▎··············│ 2% CONFIGURING [3m 6s]> :micronaut-core > :micronaut-core:micronaut-aop > Requesting from remote buil> :micronaut-core > :micronaut-core:micronaut-aop > Compiling build file '../mi│▎··············│ 2% CONFIGURING [3m 7s]> :micronaut-core > :micronaut-core:micronaut-aop│▍··············│ 3% CONFIGURING [3m 7s]> :micronaut-core > :micronaut-core:micronaut-buffer-netty > Requesting from re> :micronaut-core > :micronaut-core:micronaut-buffer-netty> :micronaut-core > :micronaut-core:micronaut-buffer-netty > Requesting from re> :micronaut-core > :micronaut-core:micronaut-buffer-netty > Compiling build fi│▍··············│ 3% CONFIGURING [3m 8s]│▋··············│ 4% CONFIGURING [3m 8s]> :micronaut-core > :micronaut-core:micronaut-context> :micronaut-core > :micronaut-core:micronaut-context > Compiling build file '.> :micronaut-core > :micronaut-core:micronaut-context│▊··············│ 5% CONFIGURING [3m 8s]> :micronaut-core > :micronaut-core:micronaut-context-propagation > Compiling b│▊··············│ 5% CONFIGURING [3m 9s]> :micronaut-core > :micronaut-core:micronaut-context-propagation> :micronaut-core > :micronaut-core:micronaut-context-propagation > Compiling b│▊··············│ 5% CONFIGURING [3m 10s]> :micronaut-core > :micronaut-core:micronaut-context-propagation│▉··············│ 6% CONFIGURING [3m 10s]> :micronaut-core > :micronaut-core:micronaut-context-python > Requesting from > :micronaut-core > :micronaut-core:micronaut-context-python> :micronaut-core > :micronaut-core:micronaut-context-python > Compiling build > :micronaut-core > :micronaut-core:micronaut-context-python│█··············│ 7% CONFIGURING [3m 11s]> :micronaut-core > :micronaut-core:micronaut-context-python-netty> :micronaut-core > :micronaut-core:micronaut-context-python-netty > Compiling > :micronaut-core > :micronaut-core:micronaut-context-python-netty > Packing bu│█▎·············│ 8% CONFIGURING [3m 11s]> :micronaut-core > :micronaut-core:micronaut-core> :micronaut-core > :micronaut-core:micronaut-core > Requesting from remote bui> :micronaut-core > :micronaut-core:micronaut-core > Compiling build file '../m│█▎·············│ 8% CONFIGURING [3m 12s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Configure project :micronaut-core:micronaut-core
Step #3 - "compile-libfuzzer-coverage-x86_64": w: file:///src/micronaut-core/core/build.gradle.kts:42:42: 'val properties: (Mutable)Map<String, out Any?>' is deprecated. Deprecated in Java.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█▍·············│ 9% CONFIGURING [3m 12s]> IDLE> :micronaut-core > :micronaut-core:micronaut-core-bom > Requesting from remote> IDLE> IDLE> :micronaut-core > :micronaut-core:micronaut-core-bom> :micronaut-core > :micronaut-core:micronaut-core-bom > Requesting from remote> :micronaut-core > :micronaut-core:micronaut-core-bom > Compiling build file '│█▍·············│ 9% CONFIGURING [3m 13s]> :micronaut-core > :micronaut-core:micronaut-core-bom > :micronaut-core:micron│█▌·············│ 10% CONFIGURING [3m 13s]│█▌·············│ 10% CONFIGURING [3m 14s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Configure project :micronaut-core:micronaut-core-bom
Step #3 - "compile-libfuzzer-coverage-x86_64": w: file:///src/micronaut-core/core-bom/build.gradle.kts:5:9: 'val properties: (Mutable)Map<String, out Any?>' is deprecated. Deprecated in Java.
Step #3 - "compile-libfuzzer-coverage-x86_64": w: file:///src/micronaut-core/core-bom/build.gradle.kts:6:11: 'val properties: (Mutable)Map<String, out Any?>' is deprecated. Deprecated in Java.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█▋·············│ 11% CONFIGURING [3m 14s]> IDLE> :micronaut-core > :micronaut-core:micronaut-core-bom > :micronaut-core:micron> IDLE> IDLE│█▋·············│ 11% CONFIGURING [3m 15s]│█▉·············│ 12% CONFIGURING [3m 15s]│██·············│ 13% CONFIGURING [3m 15s]│██▏············│ 14% CONFIGURING [3m 16s]│██▎············│ 15% CONFIGURING [3m 16s]│██▌············│ 16% CONFIGURING [3m 17s]│██▋············│ 17% CONFIGURING [3m 17s]│██▊············│ 18% CONFIGURING [3m 17s]│██▊············│ 18% CONFIGURING [3m 18s]│███············│ 20% CONFIGURING [3m 18s]│███▏···········│ 21% CONFIGURING [3m 18s]│███▏···········│ 21% CONFIGURING [3m 19s]│███▎···········│ 22% CONFIGURING [3m 19s]│███▎···········│ 22% CONFIGURING [3m 20s]│███▍···········│ 23% CONFIGURING [3m 20s]│███▋···········│ 24% CONFIGURING [3m 20s]│███▋···········│ 24% CONFIGURING [3m 21s]│███▊···········│ 25% CONFIGURING [3m 21s]│███▉···········│ 26% CONFIGURING [3m 21s]│███▉···········│ 26% CONFIGURING [3m 22s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Configure project :micronaut-core:micronaut-http-netty
Step #3 - "compile-libfuzzer-coverage-x86_64": w: file:///src/micronaut-core/http-netty/build.gradle.kts:53:26: 'fun <U : Task> RegisteringDomainObjectDelegateProviderWithTypeAndAction<out TaskContainer, U>.provideDelegate(receiver: Any?, property: KProperty<*>): ExistingDomainObjectDelegate<TaskProvider<U>>' is deprecated. Use 'val task = tasks.register<Type>(name) { }' instead. See the Gradle 9.6 upgrading guide.
Step #3 - "compile-libfuzzer-coverage-x86_64": w: file:///src/micronaut-core/http-netty/build.gradle.kts:53:26: 'fun <T : Any, C : PolymorphicDomainObjectContainer<T>, U : T> C.registering(type: KClass<U>, action: U.() -> Unit): RegisteringDomainObjectDelegateProviderWithTypeAndAction<out C, U>' is deprecated. Use 'val element = register<Type>(name) { }' instead. See the Gradle 9.6 upgrading guide.
Step #3 - "compile-libfuzzer-coverage-x86_64": w: file:///src/micronaut-core/http-netty/build.gradle.kts:53:26: 'fun <T> ExistingDomainObjectDelegate<out T>.getValue(receiver: Any?, property: KProperty<*>): T' is deprecated. Use the named() API instead. See the Gradle 9.6 upgrading guide.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████···········│ 27% CONFIGURING [3m 22s]> IDLE> :micronaut-core > :micronaut-core:micronaut-core-bom > :micronaut-core:micron> IDLE> IDLE│████▎··········│ 28% CONFIGURING [3m 22s]│████▎··········│ 28% CONFIGURING [3m 23s]│████▍··········│ 29% CONFIGURING [3m 23s]│████▍··········│ 29% CONFIGURING [3m 24s]│████▌··········│ 30% CONFIGURING [3m 24s]│████▋··········│ 31% CONFIGURING [3m 24s]│████▋··········│ 31% CONFIGURING [3m 25s]│████▉··········│ 32% CONFIGURING [3m 25s]│█████··········│ 33% CONFIGURING [3m 25s]│█████··········│ 33% CONFIGURING [3m 26s]│█████▏·········│ 34% CONFIGURING [3m 26s]│█████▎·········│ 35% CONFIGURING [3m 26s]│█████▎·········│ 35% CONFIGURING [3m 27s]│█████▌·········│ 36% CONFIGURING [3m 27s]│█████▋·········│ 37% CONFIGURING [3m 27s]│█████▋·········│ 37% CONFIGURING [3m 28s]│█████▊·········│ 38% CONFIGURING [3m 28s]│██████·········│ 40% CONFIGURING [3m 28s]│██████·········│ 40% CONFIGURING [3m 29s]│██████▏········│ 41% CONFIGURING [3m 29s]│██████▏········│ 41% CONFIGURING [3m 30s]│██████▎········│ 42% CONFIGURING [3m 30s]│██████▍········│ 43% CONFIGURING [3m 30s]│██████▍········│ 43% CONFIGURING [3m 31s]│██████▋········│ 44% CONFIGURING [3m 31s]│██████▊········│ 45% CONFIGURING [3m 31s]│██████▊········│ 45% CONFIGURING [3m 32s]│██████▉········│ 46% CONFIGURING [3m 32s]│███████········│ 47% CONFIGURING [3m 32s]│███████········│ 47% CONFIGURING [3m 33s]│███████▎·······│ 48% CONFIGURING [3m 33s]│███████▍·······│ 49% CONFIGURING [3m 33s]│███████▍·······│ 49% CONFIGURING [3m 34s]│███████▌·······│ 50% CONFIGURING [3m 34s]│███████▋·······│ 51% CONFIGURING [3m 34s]│███████▉·······│ 52% CONFIGURING [3m 35s]│████████·······│ 53% CONFIGURING [3m 35s]│████████▏······│ 54% CONFIGURING [3m 35s]│████████▏······│ 54% CONFIGURING [3m 36s]│████████▎······│ 55% CONFIGURING [3m 36s]│████████▌······│ 56% CONFIGURING [3m 36s]│████████▌······│ 56% CONFIGURING [3m 37s]│████████▋······│ 57% CONFIGURING [3m 37s]│████████▊······│ 58% CONFIGURING [3m 37s]│████████▊······│ 58% CONFIGURING [3m 38s]│█████████······│ 60% CONFIGURING [3m 38s]> :micronaut-core > :micronaut-core:micronaut-core-bom > :micronaut-core:test-u│█████████▏·····│ 61% CONFIGURING [3m 38s]> :micronaut-core > :micronaut-core:micronaut-core-bom > Resolve dependencies o│█████████▎·····│ 62% CONFIGURING [3m 38s]> :micronaut-core > :micronaut-core:test-suite> :micronaut-core > :micronaut-core:test-suite > Compiling build file '../micro│█████████▎·····│ 62% CONFIGURING [3m 39s]> :micronaut-core > :micronaut-core:test-suite│█████████▍·····│ 63% CONFIGURING [3m 39s]> :micronaut-core > :micronaut-core:test-suite-annotation-remapper> :micronaut-core > :micronaut-core:test-suite-annotation-remapper > Compiling │█████████▋·····│ 64% CONFIGURING [3m 39s]> :micronaut-core > :micronaut-core:test-suite-annotation-remapper-visitor > Re> :micronaut-core > :micronaut-core:test-suite-annotation-remapper-visitor > Co│█████████▋·····│ 64% CONFIGURING [3m 40s]│█████████▊·····│ 65% CONFIGURING [3m 40s]> :micronaut-core > :micronaut-core:test-suite-crema-graalvm > Requesting from > :micronaut-core > :micronaut-core:test-suite-crema-graalvm > Compiling build │█████████▉·····│ 66% CONFIGURING [3m 40s]> :micronaut-core > :micronaut-core:test-suite-dev-python > Requesting from rem│█████████▉·····│ 66% CONFIGURING [3m 41s]> :micronaut-core > :micronaut-core:test-suite-dev-python > Compiling build fil│██████████·····│ 67% CONFIGURING [3m 41s]> :micronaut-core > :micronaut-core:test-suite-groovy> :micronaut-core > :micronaut-core:test-suite-groovy > Requesting from remote > :micronaut-core > :micronaut-core:test-suite-groovy > Compiling build file '.│██████████▎····│ 68% CONFIGURING [3m 41s]> :micronaut-core > :micronaut-core:test-suite-helper > Requesting from remote │██████████▍····│ 69% CONFIGURING [3m 41s]> :micronaut-core > :micronaut-core:test-suite-http-client-jdk-ssl│██████████▍····│ 69% CONFIGURING [3m 42s]> :micronaut-core > :micronaut-core:test-suite-http-client-jdk-ssl > Compiling │██████████▌····│ 70% CONFIGURING [3m 42s]> :micronaut-core > :micronaut-core:test-suite-http-client-tck-jdk > Requesting> :micronaut-core > :micronaut-core:test-suite-http-client-tck-jdk > Compiling │██████████▋····│ 71% CONFIGURING [3m 42s]> :micronaut-core > :micronaut-core:test-suite-http-client-tck-netty> :micronaut-core > :micronaut-core:test-suite-http-client-tck-netty > Compilin│██████████▋····│ 71% CONFIGURING [3m 43s]│██████████▉····│ 72% CONFIGURING [3m 43s]> :micronaut-core > :micronaut-core:test-suite-http-server-tck-jdk> :micronaut-core > :micronaut-core:test-suite-http-server-tck-jdk > Compiling > :micronaut-core > :micronaut-core:test-suite-http-server-tck-jdk│███████████····│ 73% CONFIGURING [3m 43s]> :micronaut-core > :micronaut-core:test-suite-http-server-tck-netty > Requesti> :micronaut-core > :micronaut-core:test-suite-http-server-tck-netty > Compilin│███████████····│ 73% CONFIGURING [3m 44s]│███████████▏···│ 74% CONFIGURING [3m 44s]> :micronaut-core > :micronaut-core:test-suite-http2-server-tck-netty > Request> :micronaut-core > :micronaut-core:test-suite-http2-server-tck-netty > Compili│███████████▎···│ 75% CONFIGURING [3m 44s]> :micronaut-core > :micronaut-core:test-suite-jakarta-inject-bean-import│███████████▌···│ 76% CONFIGURING [3m 44s]> :micronaut-core > :micronaut-core:test-suite-javax-inject│███████████▌···│ 76% CONFIGURING [3m 45s]> :micronaut-core > :micronaut-core:test-suite-javax-inject > Compiling build f> :micronaut-core > :micronaut-core:test-suite-javax-inject│███████████▋···│ 77% CONFIGURING [3m 45s]> :micronaut-core > :micronaut-core:test-suite-jdt > Requesting from remote bui> :micronaut-core > :micronaut-core:test-suite-jdt > Compiling build file '../m> :micronaut-core > :micronaut-core:test-suite-jdt│███████████▊···│ 78% CONFIGURING [3m 45s]> :micronaut-core > :micronaut-core:test-suite-kotlin > Compiling build file '.│███████████▊···│ 78% CONFIGURING [3m 46s]> :micronaut-core > :micronaut-core:test-suite-kotlin> :micronaut-core > :micronaut-core:test-suite-kotlin > Compiling build file '.│████████████···│ 80% CONFIGURING [3m 46s]> :micronaut-core > :micronaut-core:test-suite-kotlin-graalvm > Requesting from> :micronaut-core > :micronaut-core:test-suite-kotlin-graalvm > Compiling build> :micronaut-core > :micronaut-core:test-suite-kotlin-graalvm│████████████···│ 80% CONFIGURING [3m 47s]> :micronaut-core > :micronaut-core:test-suite-kotlin-graalvm > Compiling build> :micronaut-core > :micronaut-core:test-suite-kotlin-graalvm│████████████▏··│ 81% CONFIGURING [3m 47s]> :micronaut-core > :micronaut-core:test-suite-kotlin-ksp-all-open > Compiling > :micronaut-core > :micronaut-core:test-suite-kotlin-ksp-all-open│████████████▏··│ 81% CONFIGURING [3m 48s]> :micronaut-core > :micronaut-core:test-suite-kotlin-ksp-all-open > Compiling │████████████▎··│ 82% CONFIGURING [3m 48s]> :micronaut-core > :micronaut-core:test-suite-kotlinx-reactor > Requesting fro> :micronaut-core > :micronaut-core:test-suite-kotlinx-reactor > Compiling buil> :micronaut-core > :micronaut-core:test-suite-kotlinx-reactor> :micronaut-core > :micronaut-core:test-suite-kotlinx-reactor > Requesting fro> :micronaut-core > :micronaut-core:test-suite-kotlinx-reactor > Compiling buil│████████████▎··│ 82% CONFIGURING [3m 49s]> :micronaut-core > :micronaut-core:test-suite-kotlinx-reactor│████████████▍··│ 83% CONFIGURING [3m 49s]> :micronaut-core > :micronaut-core:test-suite-logback> :micronaut-core > :micronaut-core:test-suite-logback > Compiling build file '│████████████▋··│ 84% CONFIGURING [3m 49s]> :micronaut-core > :micronaut-core:test-suite-logback-external-configuration >│████████████▊··│ 85% CONFIGURING [3m 49s]> :micronaut-core > :micronaut-core:test-suite-logback-graalvm│████████████▊··│ 85% CONFIGURING [3m 50s]> :micronaut-core > :micronaut-core:test-suite-logback-graalvm > Compiling buil│████████████▉··│ 86% CONFIGURING [3m 50s]> :micronaut-core > :micronaut-core:test-suite-logback-no-xml> :micronaut-core > :micronaut-core:test-suite-logback-no-xml > Compiling build│█████████████··│ 87% CONFIGURING [3m 50s]> :micronaut-core > :micronaut-core:test-suite-logback-test-xml > Requesting fr> :micronaut-core > :micronaut-core:test-suite-logback-test-xml > Compiling bui│█████████████▎·│ 88% CONFIGURING [3m 51s]> :micronaut-core > :micronaut-core:test-suite-logback-working-directory> :micronaut-core > :micronaut-core:test-suite-logback-working-directory > Comp│█████████████▍·│ 89% CONFIGURING [3m 51s]> :micronaut-core > :micronaut-core:test-suite-netty-ssl-graalvm> :micronaut-core > :micronaut-core:test-suite-netty-ssl-graalvm > Compiling bu│█████████████▌·│ 90% CONFIGURING [3m 51s]> :micronaut-core > :micronaut-core:test-suite-property-source > Requesting fro│█████████████▌·│ 90% CONFIGURING [3m 52s]> :micronaut-core > :micronaut-core:test-suite-property-source > Compiling buil│█████████████▋·│ 91% CONFIGURING [3m 52s]> :micronaut-core > :micronaut-core:test-suite-python> :micronaut-core > :micronaut-core:test-suite-python > Compiling build file '.│█████████████▉·│ 92% CONFIGURING [3m 52s]> :micronaut-core > :micronaut-core:test-suite-python-corpus > Requesting from │█████████████▉·│ 92% CONFIGURING [3m 53s]> :micronaut-core > :micronaut-core:test-suite-python-corpus > Compiling build │██████████████·│ 93% CONFIGURING [3m 53s]> :micronaut-core│██████████████▏│ 94% CONFIGURING [3m 53s]> root project> root project > Requesting from remote build cache│██████████████▏│ 94% CONFIGURING [3m 54s]> root project > :micronaut-fuzzing-annotation-processor > Requesting from remo> root project > :micronaut-fuzzing-annotation-processor> root project > :micronaut-fuzzing-annotation-processor > Requesting from remo│██████████████▎│ 95% CONFIGURING [3m 55s]> root project > :micronaut-fuzzing-api > Requesting from remote build cache> root project > :micronaut-fuzzing-api> root project > :micronaut-fuzzing-api > Requesting from remote build cache│██████████████▌│ 96% CONFIGURING [3m 55s]> root project > :micronaut-fuzzing-runner > Requesting from remote build cache│██████████████▋│ 97% CONFIGURING [3m 55s]> root project > :micronaut-fuzzing-tests > Requesting from remote build cache> root project > :micronaut-fuzzing-tests > Resolve dependencies of classpath >│██████████████▋│ 97% CONFIGURING [3m 56s]> root project > :micronaut-fuzzing-tests > Resolve dependencies of classpath> root project > :micronaut-fuzzing-tests > Resolve dependencies of classpath >> root project > :micronaut-fuzzing-tests > Resolve dependencies of classpath> root project > :micronaut-fuzzing-tests > Resolve dependencies of classpath >> root project > :micronaut-fuzzing-tests > Resolve dependencies of classpath >> IDLE> root project > :micronaut-fuzzing-tests > Building task graph of build ':micr> root project > :micronaut-fuzzing-tests > Building task graph of build ':micr> IDLE│██████████████▋│ 97% CONFIGURING [3m 57s]> root project > :micronaut-fuzzing-tests > Building task graph of build ':micr> IDLE> root project > :micronaut-fuzzing-tests > Building task graph of build ':micr> root project > :micronaut-fuzzing-tests > Building task graph of build ':micr> root project > :micronaut-fuzzing-tests > Building task graph of build ':micr  (1 line not showing)│██████████████▋│ 97% CONFIGURING [3m 58s]> IDLE> IDLE> IDLE> root project > :micronaut-fuzzing-tests > Building task graph of build ':micr> root project > :micronaut-fuzzing-tests> root project > :micronaut-fuzzing-tests> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp│██████████████▋│ 97% CONFIGURING [3m 59s]> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> IDLE│██████████████▋│ 97% CONFIGURING [4m]│██████████████▋│ 97% CONFIGURING [4m 1s]│██████████████▋│ 97% CONFIGURING [4m 2s]│██████████████▋│ 97% CONFIGURING [4m 3s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-core:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/value/ConvertibleValues.java:73: warning: [removal] resolveInterfaceTypeArgument(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         Optional<Class<?>> type = GenericTypeUtils.resolveInterfaceTypeArgument(getClass(), ConvertibleValues.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 3s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests│██████████████▋│ 97% CONFIGURING [4m 4s]/src/micronaut-core/core/src/main/java/io/micronaut/core/convert/value/ConvertibleMultiValues.java:142: warning: [removal] resolveInterfaceTypeArgument(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         Optional<Class<?>> type = GenericTypeUtils.resolveInterfaceTypeArgument(getClass(), ConvertibleMultiValues.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 4s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests│██████████████▋│ 97% CONFIGURING [4m 5s]/src/micronaut-core/core/src/main/java/io/micronaut/core/serialize/ObjectSerializer.java:45: warning: [removal] JdkSerializer in io.micronaut.core.serialize has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     ObjectSerializer JDK = new JdkSerializer();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 5s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests│██████████████▋│ 97% CONFIGURING [4m 6s]/src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionService.java:35: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: DefaultMutableConversionService is a subclass of the containing class ConversionService
Step #3 - "compile-libfuzzer-coverage-x86_64":     ConversionService SHARED = new DefaultMutableConversionService();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 6s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/Indexed.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The indexed type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the indexed type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:52: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: ImmutableArgumentConversionContext<T> is a subclass of the containing class ConversionContext
Step #3 - "compile-libfuzzer-coverage-x86_64":     ArgumentConversionContext<Boolean> BOOLEAN = ImmutableArgumentConversionContext.of(Argument.BOOLEAN);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:57: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: ImmutableArgumentConversionContext<T> is a subclass of the containing class ConversionContext
Step #3 - "compile-libfuzzer-coverage-x86_64":     ArgumentConversionContext<Integer> INT = ImmutableArgumentConversionContext.of(Argument.INT);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:62: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: ImmutableArgumentConversionContext<T> is a subclass of the containing class ConversionContext
Step #3 - "compile-libfuzzer-coverage-x86_64":     ArgumentConversionContext<Long> LONG = ImmutableArgumentConversionContext.of(Argument.LONG);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:67: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: ImmutableArgumentConversionContext<T> is a subclass of the containing class ConversionContext
Step #3 - "compile-libfuzzer-coverage-x86_64":     ArgumentConversionContext<String> STRING = ImmutableArgumentConversionContext.of(Argument.STRING);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:72: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: ImmutableArgumentConversionContext<T> is a subclass of the containing class ConversionContext
Step #3 - "compile-libfuzzer-coverage-x86_64":     ArgumentConversionContext<List<String>> LIST_OF_STRING = ImmutableArgumentConversionContext.of(Argument.LIST_OF_STRING);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:77: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: ImmutableArgumentConversionContext<T> is a subclass of the containing class ConversionContext
Step #3 - "compile-libfuzzer-coverage-x86_64":     ArgumentConversionContext<Map> MAP = ImmutableArgumentConversionContext.of(Argument.of(Map.class));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:92: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The locale to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the locale to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:99: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The standard charset used in conversion
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the standard charset used in conversion.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionContext.java:120: warning: [TypeParameterShadowing] Found aliased type parameters: T declared in with
Step #3 - "compile-libfuzzer-coverage-x86_64":             public <T extends Annotation> T synthesize(Class<T> annotationClass) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeParameterShadowing)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'public <T2 extends Annotation> T2 synthesize(Class<T2> annotationClass) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 6s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeVariableResolver.java:32: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Obtain a map of the type parameters for the argument
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns obtain a map of the type parameters for the argument.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeVariableResolver.java:39: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type parameters as an array
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type parameters as an array.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeVariableResolver.java:47: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Return the first type parameter if it is present
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns return the first type parameter if it is present.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 6s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeVariableResolver.java:58: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns return the first type parameter if it is present.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ErrorsContext.java:64: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Check whether errors exist
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns check whether errors exist.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionError.java:28: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The cause
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the cause.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ConversionError.java:33: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The original rejected value
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the original rejected value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/convert/ArgumentConversionContext.java:34: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link Argument} being converted
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link Argument} being converted.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 6s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests│██████████████▋│ 97% CONFIGURING [4m 7s]/src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:44: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:49: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the type primitive.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:81: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the return type reactive.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 7s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:108: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the return type a reactive completable type.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:116: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the return type asynchronous.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:125: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the return type either async or reactive.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:133: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether this is a container type.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether this is a container type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:141: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the argument has any type variables
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the argument has any type variables.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:209: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the return type {@link java.util.Optional}.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:218: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Has the return type been specified to emit a single result with {@code SingleResult}.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:275: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the type an array.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/type/TypeInformation.java:353: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Is an ANSI format.
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is an ANSI format.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 7s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotatedElement.java:29: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the element is nullable.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the element is nullable.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotatedElement.java:36: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the element is nullable.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the element is nullable.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotatedElement.java:43: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the element is declared as not being null
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the element is declared as not being null.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotatedElement.java:50: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the element is declared as not being null
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the element is declared as not being null.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/naming/Named.java:26: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the component
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the component.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 7s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadata.java:63: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: EmptyAnnotationMetadata is a subclass of the containing class AnnotationMetadata
Step #3 - "compile-libfuzzer-coverage-x86_64":     AnnotationMetadata EMPTY_METADATA = new EmptyAnnotationMetadata();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 7s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests│██████████████▋│ 97% CONFIGURING [4m 8s]/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationMetadata.java:1656: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         return this == AnnotationMetadata.EMPTY_METADATA;
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return this.equals(AnnotationMetadata.EMPTY_METADATA);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/reflect/ReflectionUtils.java:222: warning: [TypeParameterUnusedInFormals] Declaring a type parameter that is only used in the return type is a misuse of generics: operations on the type parameter are unchecked, it hides unsafe casts at invocations of the method, and it interacts badly with method overload resolution.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public static <R, T> R invokeMethod(T instance, Method method, @Nullable Object... arguments) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeParameterUnusedInFormals)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/reflect/ReflectionUtils.java:253: warning: [TypeParameterUnusedInFormals] Declaring a type parameter that is only used in the return type is a misuse of generics: operations on the type parameter are unchecked, it hides unsafe casts at invocations of the method, and it interacts badly with method overload resolution.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public static <R, T> R invokeMethodPropagating(@Nullable T instance, Method method, @Nullable Object... arguments) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeParameterUnusedInFormals)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/reflect/ReflectionUtils.java:276: warning: [TypeParameterUnusedInFormals] Declaring a type parameter that is only used in the return type is a misuse of generics: operations on the type parameter are unchecked, it hides unsafe casts at invocations of the method, and it interacts badly with method overload resolution.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public static <R, T> R invokeInaccessibleMethod(T instance, Method method, @Nullable Object... arguments) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeParameterUnusedInFormals)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/reflect/ReflectionUtils.java:447: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param type The type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns an optional with the declared field.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/reflect/ReflectionUtils.java:461: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param aClass A class
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns all the interfaces.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/reflect/ReflectionUtils.java:470: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param aClass     A class
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a set with the interfaces.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/reflect/ReflectionUtils.java:492: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param declaringType The declaring type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a {@link NoSuchMethodError}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1342: warning: [MixedMutabilityReturnType] This method returns both mutable and immutable collections or maps from different paths. This may be confusing for users of the method.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public <T extends Annotation> List<AnnotationValue<T>> getAnnotations(String member, Class<T> type) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/MixedMutabilityReturnType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return ImmutableList.of();'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1387: warning: [MixedMutabilityReturnType] This method returns both mutable and immutable collections or maps from different paths. This may be confusing for users of the method.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public <T extends Annotation> List<AnnotationValue<T>> getAnnotations(String member) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/MixedMutabilityReturnType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return ImmutableList.of(annotationValue);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:277: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value mapper.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:295: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The retention policy.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the retention policy.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:311: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (stereotypes != null || !values.containsKey(AnnotationUtil.STEREOTYPES_MEMBER)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:430: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object rawValue = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:521: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:545: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:569: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:592: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:616: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:640: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:664: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:688: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:721: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object o = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:734: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object o = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:747: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object o = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:782: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object o = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1121: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             return values.containsKey(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1144: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param member      The member
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is the value of the annotation true.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1204: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (values.containsKey(AnnotationUtil.STEREOTYPES_MEMBER)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1218: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (values.containsKey(AnnotationUtil.STEREOTYPES_MEMBER)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1220: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             attributes.remove(AnnotationUtil.STEREOTYPES_MEMBER);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1227: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The convertible values
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the convertible values.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1244: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             Object value = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1266: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             Object dv = defaults.get(member.toString());
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1347: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1389: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1422: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1458: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object v = values.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1539: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (this == other) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (this.equals(other)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 8s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1545: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (values == other.values && getClass() == AnnotationValue.class && other.getClass() == AnnotationValue.class
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(values, other.values) && getClass() == AnnotationValue.class && other.getClass() == AnnotationValue.class' or 'if (values.equals(other.values) && getClass() == AnnotationValue.class && other.getClass() == AnnotationValue.class'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1546: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             && getDefaultValues() == other.getDefaultValues()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '&& Objects.equals(getDefaultValues(), other.getDefaultValues())) {' or '&& getDefaultValues().equals(other.getDefaultValues())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1560: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (declared == otherDeclared && defaults == otherDefaults) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(declared, otherDeclared) && defaults == otherDefaults) {' or 'if (declared.equals(otherDeclared) && defaults == otherDefaults) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1560: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (declared == otherDeclared && defaults == otherDefaults) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (declared == otherDeclared && Objects.equals(defaults, otherDefaults)) {' or 'if (declared == otherDeclared && defaults.equals(otherDefaults)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1575: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (!declared.containsKey(member.getKey()) && !isNonBinding(member.getKey(), nonBinding)
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1588: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object listed = declared.get(AnnotationUtil.NON_BINDING_ATTRIBUTE);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1589: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object otherListed = otherDeclared.get(AnnotationUtil.NON_BINDING_ATTRIBUTE);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1637: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (!declared.containsKey(member) && !isNonBinding(member, nonBinding)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1649: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (otherDeclared.containsKey(member)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1650: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             otherValue = otherDeclared.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1651: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         } else if (otherDefaults.containsKey(member)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1652: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             otherValue = otherDefaults.get(member);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1688: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (element == null || otherElement == null ? element != otherElement : !matchesValue(element, otherElement)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if ((element == null || otherElement == null) ? element != otherElement : !matchesValue(element, otherElem'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 9s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1688: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (element == null || otherElement == null ? element != otherElement : !matchesValue(element, otherElement)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (element == null || otherElement == null ? !Objects.equals(element, otherElement) : !matchesValue(element, otherElement)) {' or 'if (element == null || otherElement == null ? !element.equals(otherElement) : !matchesValue(element, otherElement)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1722: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (getClass() != AnnotationValue.class || values.containsKey(AnnotationUtil.STEREOTYPES_MEMBER)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1748: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (values == other.values && getClass() == AnnotationValue.class && other.getClass() == AnnotationValue.class) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(values, other.values) && getClass() == AnnotationValue.class && other.getClass() == AnnotationValue.class) {' or 'if (values.equals(other.values) && getClass() == AnnotationValue.class && other.getClass() == AnnotationValue.class) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1755: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (values == otherValues) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(values, otherValues)) {' or 'if (values.equals(otherValues)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:1766: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             Object otherValue = otherValues.get(member.getKey());
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 9s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests/src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:2134: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (values.containsKey(AnnotationUtil.STEREOTYPES_MEMBER)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:2137: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             attributes.remove(AnnotationUtil.STEREOTYPES_MEMBER);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core/src/main/java/io/micronaut/core/annotation/AnnotationValue.java:2145: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Object rawValue = ArrayUtils.firstElement(values.get(member));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 9s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests│██████████████▋│ 97% CONFIGURING [4m 10s]│██████████████▋│ 97% CONFIGURING [4m 11s]│██████████████▋│ 97% CONFIGURING [4m 12s]│██████████████▋│ 97% CONFIGURING [4m 13s]│██████████████▋│ 97% CONFIGURING [4m 14s]│██████████████▋│ 97% CONFIGURING [4m 15s]│██████████████▋│ 97% CONFIGURING [4m 16s]│██████████████▋│ 97% CONFIGURING [4m 17s]│██████████████▋│ 97% CONFIGURING [4m 18s]│██████████████▋│ 97% CONFIGURING [4m 19s]Note: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 19s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% CONFIGURING [4m 19s]> IDLE> IDLE> root project > :micronaut-fuzzing-tests > :micronaut-core:micronaut-core:comp> root project > :micronaut-fuzzing-tests> root project > :micronaut-fuzzing-tests > :micronaut-jazzer-plugin:compileJav> root project > :micronaut-fuzzing-tests > :micronaut-jazzer-plugin:compileJav│██████████████▋│ 97% CONFIGURING [4m 20s]> IDLE│██████████████▋│ 97% CONFIGURING [4m 21s]> root project > :micronaut-fuzzing-tests > Resolve files of configuration 'cla│██████████████▋│ 97% CONFIGURING [4m 22s]> root project > :micronaut-fuzzing-tests > Resolve files of configuration 'cla> IDLE> root project > :micronaut-fuzzing-tests> root project > :micronaut-fuzzing-tests > Requesting from remote build cache> root project > :micronaut-fuzzing-tests│██████████████▋│ 97% CONFIGURING [4m 23s]> root project > :micronaut-fuzzing-tests > Resolve dependencies of :micronaut-> root project > :micronaut-fuzzing-tests > Resolve dependencies of :micronaut-> root project > :micronaut-fuzzing-tests > Resolve dependencies of :micronaut-> root project > :micronaut-fuzzing-tests > Resolve dependencies of :micronaut-  (2 lines not showing)> IDLE> IDLE> IDLE│██████████████▋│ 97% CONFIGURING [4m 24s]> root project > :micronaut-fuzzing-tests > Resolve dependencies of :micronaut-> IDLE> root project > :micronaut-fuzzing-tests > Resolve files of configuration ':mi> root project > :micronaut-fuzzing-tests > Resolve files of configuration ':mi│██████████████▋│ 97% CONFIGURING [4m 25s]> IDLE│██████████████▊│ 98% CONFIGURING [4m 25s]> root project> root project > Requesting from remote build cache│███████████████│ 100% CONFIGURING [4m 25s]> IDLE> Building task graph of root build│███████████████│ 100% CONFIGURING [4m 26s]> Building task graph of root build > byte-buddy-1.18.7-sources.jar> Building task graph of root build > brotli4j-1.23.0-sources.jar> Building task graph of root build > netty-codec-haproxy-4.2.19.Final-sources.> Building task graph of root build> Building task graph of root build > jzlib-1.1.3-sources.jar> Building task graph of root build > bcpkix-jdk18on-1.86-sources.jar> Building task graph of root build│███████████████│ 100% CONFIGURING [4m 27s]> Building task graph of root build > netty-codec-http-4.2.19.Final-sources.jar> Building task graph of root build> Building task graph of root build > netty-common-4.2.19.Final-sources.jar > 7> Building task graph of root build > slf4j-api-2.0.17-sources.jar> Building task graph of root build> Building task graph of root build > bcutil-jdk18on-1.86-sources.jar│███████████████│ 100% CONFIGURING [4m 28s]> Building task graph of root build > bcprov-jdk18on-1.86-sources.jar > 4.1 MiB> Building task graph of root build> Building task graph of root build > jakarta.inject-api-2.0.1-sources.jar> Building task graph of root build > Resolve dependencies of :micronaut-fuzzin> Building task graph of root build > Resolve dependencies of :micronaut-fuzzin> IDLE> Building task graph of root build > Resolve dependencies of :micronaut-fuzzin> IDLE> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic│███████████████│ 100% CONFIGURING [4m 29s]> Building task graph of build ':micronaut-core'> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> Building task graph of build ':micronaut-core'> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> IDLE│███████████████│ 100% CONFIGURING [4m 30s]> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> IDLE> IDLE│███████████████│ 100% CONFIGURING [4m 31s]> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> IDLE> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> IDLE│███████████████│ 100% CONFIGURING [4m 32s]> Building task graph of build ':micronaut-core'> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> IDLE> IDLE> IDLE> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic│███████████████│ 100% CONFIGURING [4m 33s]> IDLE> IDLE> Building task graph of build ':micronaut-core'> Building task graph of build ':micronaut-core' > Resolve dependencies of :mic> Building task graph of build ':micronaut-core'│···············│ 0% EXECUTING [4m 33s]> :micronaut-core:micronaut-module-info:compileJava > Requesting from remote bu> :micronaut-fuzzing-api:generateMicronautDescriptor > Requesting from remote b│▋··············│ 4% EXECUTING [4m 34s]> :micronaut-fuzzing-api:sourcesJar> :micronaut-core:micronaut-module-info:jar│▊··············│ 5% EXECUTING [4m 34s]> :micronaut-core:micronaut-core:micronautVersionInfo > Requesting from remote > :micronaut-fuzzing-annotation-processor:generateMicronautDescriptor > Request│█▏·············│ 8% EXECUTING [4m 34s]> IDLE> :micronaut-core:micronaut-core:jar│█▍·············│ 9% EXECUTING [4m 34s]> :micronaut-fuzzing-runner:generateMicronautDescriptor > Requesting from remot> :micronaut-core:micronaut-inject:compileJava│█▌·············│ 10% EXECUTING [4m 34s]> :micronaut-fuzzing-api:compileJava > Requesting from remote build cache> :micronaut-fuzzing-api:compileJava> :micronaut-core:micronaut-inject:compileJava > Resolve files of configuration│█▉·············│ 12% EXECUTING [4m 34s]> :micronaut-fuzzing-runner:compileJava│█▉·············│ 12% EXECUTING [4m 35s]> :micronaut-fuzzing-runner:compileJava > Requesting from remote build cache> :micronaut-core:micronaut-inject:compileJava> :micronaut-fuzzing-runner:compileJava> :micronaut-core:micronaut-inject:compileJava > Requesting from remote build c> :micronaut-core:micronaut-inject:compileJava│██▎············│ 15% EXECUTING [4m 35s]> :micronaut-fuzzing-tests:generateMicronautDescriptor > Requesting from remote│██▌············│ 16% EXECUTING [4m 35s]> IDLE│██▌············│ 16% EXECUTING [4m 36s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-inject:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/ApplicationContext.java:95: warning: [removal] registerSingleton(Object,boolean) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     default ApplicationContext registerSingleton(Object singleton, boolean inject) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/ApplicationContext.java:112: warning: [removal] registerSingleton(Object) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     default ApplicationContext registerSingleton(Object singleton) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/ApplicationContext.java:90: warning: [removal] <T>registerSingleton(Class<T>,T) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     default <T> ApplicationContext registerSingleton(Class<T> type, T singleton) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":   where T is a type-variable:
Step #3 - "compile-libfuzzer-coverage-x86_64":     T extends Object declared in method <T>registerSingleton(Class<T>,T)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/ApplicationContext.java:85: warning: [removal] <T>registerSingleton(Class<T>,T,@org.jspecify.annotations.Nullable Qualifier<T>) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     default <T> ApplicationContext registerSingleton(Class<T> type, T singleton, @Nullable Qualifier<T> qualifier) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":   where T is a type-variable:
Step #3 - "compile-libfuzzer-coverage-x86_64":     T extends Object declared in method <T>registerSingleton(Class<T>,T,@org.jspecify.annotations.Nullable Qualifier<T>)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanContext.java:420: warning: [removal] registerSingleton(Object,boolean) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     default BeanContext registerSingleton(Object singleton, boolean inject) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanContext.java:403: warning: [removal] registerSingleton(Object) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     default BeanContext registerSingleton(Object singleton) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanContext.java:415: warning: [removal] <T>registerSingleton(Class<T>,T) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     default <T> BeanContext registerSingleton(Class<T> type, T singleton) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":   where T is a type-variable:
Step #3 - "compile-libfuzzer-coverage-x86_64":     T extends Object declared in method <T>registerSingleton(Class<T>,T)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanContext.java:410: warning: [removal] <T>registerSingleton(Class<T>,T,@org.jspecify.annotations.Nullable Qualifier<T>) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     default <T> BeanContext registerSingleton(Class<T> type, T singleton, @Nullable Qualifier<T> qualifier) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":   where T is a type-variable:
Step #3 - "compile-libfuzzer-coverage-x86_64":     T extends Object declared in method <T>registerSingleton(Class<T>,T,@org.jspecify.annotations.Nullable Qualifier<T>)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanContext.java:421: warning: [removal] registerSingleton(Object,boolean) in BeanDefinitionRegistry has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return (BeanContext) BeanDefinitionRegistry.super.registerSingleton(singleton, inject);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 36s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/AbstractBeanResolutionContext.java:1949: warning: [removal] getField() in FieldInjectionPoint has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         public Field getField() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 36s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE│██▌············│ 16% EXECUTING [4m 37s]/src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanDefinitionDelegate.java:134: warning: [removal] resolveDynamicQualifier() in QualifiedBeanType has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Qualifier<T> resolveDynamicQualifier() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":   where T is a type-variable:
Step #3 - "compile-libfuzzer-coverage-x86_64":     T extends Object declared in interface QualifiedBeanType
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 37s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultFieldInjectionPoint.java:141: warning: [removal] getField() in FieldInjectionPoint has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Field getField() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 37s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultRuntimeBeanDefinition.java:195: warning: [removal] resolveDynamicQualifier() in QualifiedBeanType has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Qualifier<T> resolveDynamicQualifier() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":   where T is a type-variable:
Step #3 - "compile-libfuzzer-coverage-x86_64":     T extends Object declared in interface QualifiedBeanType
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 37s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/AbstractBeanDefinitionBeanConstructor.java:35: warning: [removal] AbstractBeanConstructor in io.micronaut.core.beans has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public abstract class AbstractBeanDefinitionBeanConstructor<T> extends AbstractBeanConstructor<T> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/AbstractBeanDefinitionBeanConstructor.java:35: warning: [removal] AbstractBeanConstructor in io.micronaut.core.beans has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public abstract class AbstractBeanDefinitionBeanConstructor<T> extends AbstractBeanConstructor<T> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 38s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/AbstractExecutableMethod.java:49: warning: [removal] AbstractExecutable in io.micronaut.context has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public abstract class AbstractExecutableMethod<T, R> extends AbstractExecutable<T, R> implements UnsafeExecutable<T, R>, ExecutableMethod<T, R>, EnvironmentConfigurable {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/AbstractExecutableMethod.java:49: warning: [removal] AbstractExecutable in io.micronaut.context has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public abstract class AbstractExecutableMethod<T, R> extends AbstractExecutable<T, R> implements UnsafeExecutable<T, R>, ExecutableMethod<T, R>, EnvironmentConfigurable {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 38s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/inject/annotation/AnnotationMetadataSupport.java:175: warning: [removal] Provided in io.micronaut.context.annotation has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Provided.class,
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 38s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE│██▌············│ 16% EXECUTING [4m 39s]/src/micronaut-core/inject/src/main/java/io/micronaut/context/ApplicationContext.java:61: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The application environment
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the application environment.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 39s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/ApplicationContext.java:280: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param classLoader The class loader to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the application context builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 39s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanContext.java:390: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The class loader used by this context
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the class loader used by this context.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanContext.java:395: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Get the configured bean validator, if any.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns get the configured bean validator, if any.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 39s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/LifeCycle.java:32: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the component is running
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the component is running.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 39s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE│██▌············│ 16% EXECUTING [4m 40s]/src/micronaut-core/inject/src/main/java/io/micronaut/context/event/ApplicationEventPublisher.java:32: warning: [ClassInitializationDeadlock] Possible class initialization deadlock: NoOpApplicationEventPublisher is a subclass of the containing class ApplicationEventPublisher<T>
Step #3 - "compile-libfuzzer-coverage-x86_64":     ApplicationEventPublisher<?> NO_OP = new NoOpApplicationEventPublisher();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ClassInitializationDeadlock)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/PropertyPlaceholderResolver.java:38: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The prefix used
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the prefix used.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/Environment.java:237: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The active property sources
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the active property sources.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/Environment.java:281: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The application packages
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the application packages.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/Environment.java:286: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The placeholder resolver
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the placeholder resolver.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/Environment.java:350: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The class loader for the environment
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the class loader for the environment.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 40s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/Qualifier.java:43: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param beanType   The bean type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the qualified candidate or null it cannot be qualified.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/PropertySource.java:40: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the property source
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the property source.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/PropertySource.java:54: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The origin of the property source.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/PropertySource.java:62: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the property source has upper case underscore separated keys
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the property source has upper case underscore separated keys.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/env/PropertySource.java:219: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The location.
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the location.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 40s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionTraceMode.java:56: warning: [ImmutableEnumChecker] enums should be immutable: 'BeanResolutionTraceMode' has field 'resolutionTracer' of type 'io.micronaut.context.@org.jspecify.annotations.Nullable BeanResolutionTracer', the declaration of type 'io.micronaut.context.@org.jspecify.annotations.Nullable BeanResolutionTracer' is not annotated with @com.google.errorprone.annotations.Immutable
Step #3 - "compile-libfuzzer-coverage-x86_64":     private final @Nullable BeanResolutionTracer resolutionTracer;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ImmutableEnumChecker)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 40s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionTracer.java:246: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The bean context that resolves the bean
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean context that resolves the bean.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionTracer.java:277: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The kind of injection point
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the kind of injection point.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionTracer.java:282: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The bean that declares the injection point
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean that declares the injection point.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionTracer.java:287: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The name of the field or method that declares the injection point, {@code <init>} for a constructor
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the field or method that declares the injection point, {@code <init>} for a constructor.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionTracer.java:292: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The argument resolved: the parameter, the field, the annotation member or the event type
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the argument resolved: the parameter, the field, the annotation member or the event type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 40s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/RuntimeBeanDefinition.java:334: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The bean context the bean belongs to
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean context the bean belongs to.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/RuntimeBeanDefinition.java:485: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The number of injection points the definition declared
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the number of injection points the definition declared.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/RuntimeBeanDefinition.java:499: warning: [TypeParameterUnusedInFormals] Declaring a type parameter that is only used in the return type is a misuse of generics: operations on the type parameter are unchecked, it hides unsafe casts at invocations of the method, and it interacts badly with method overload resolution.
Step #3 - "compile-libfuzzer-coverage-x86_64":         <V> @Nullable V getInjectedBean(int index);
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeParameterUnusedInFormals)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 40s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinitionReference.java:54: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The class name of the backing {@link BeanDefinition}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the class name of the backing {@link BeanDefinition}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinitionReference.java:76: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is this class context scope
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is this class context scope.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinitionReference.java:83: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the underlying bean type present on the classpath
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is the underlying bean type present on the classpath.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinitionReference.java:88: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is this bean a singleton.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinitionReference.java:108: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is this bean a configuration properties.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinitionReference.java:127: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether this reference is a proxy target.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether this reference is a proxy target.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanType.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the bean definition is the {@link io.micronaut.context.annotation.Primary}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the bean definition is the {@link io.micronaut.context.annotation.Primary}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 40s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanType.java:124: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The class name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the class name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:65: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type information for the bean.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:131: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The scope of the bean
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the scope of the bean.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:138: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the scope
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the scope.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:145: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the scope is singleton
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the scope is singleton.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 40s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:225: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the bean declared with {@link io.micronaut.context.annotation.EachProperty} or
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the bean declared with {@link io.micronaut.context.annotation.EachProperty} or'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:233: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the type configuration properties.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is the type configuration properties.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:246: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type that declares this definition, null if not applicable.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type that declares this definition, null if not applicable.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:278: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return All required components for this entity definition
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns all required components for this entity definition.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:366: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link ExecutableMethod} instances for this definition
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link ExecutableMethod} instances for this definition.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 41s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanDefinition.java:528: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the bean definition is abstract
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the bean definition is abstract.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 41s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanConfiguration.java:33: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The package for the bean configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the package for the bean configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanConfiguration.java:38: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The package name this configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the package name this configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/inject/BeanConfiguration.java:113: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":         return new ConditionalBeanConfiguration(thePackage, (beanContext -> false));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return new ConditionalBeanConfiguration(thePackage,  beanContext -> false);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanRegistration.java:171: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The owner of what was created for this bean, or null for a registration the container does not own
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the owner of what was created for this bean, or null for a registration the container does not own.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanRegistration.java:191: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return An immutable snapshot of the dependents the owner of this registration holds, empty without an owner
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns an immutable snapshot of the dependents the owner of this registration holds, empty without an owner.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanRegistration.java:232: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Teh bean identifier
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns teh bean identifier.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanRegistration.java:239: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The bean definition
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean definition.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanRegistration.java:246: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The bean instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanRegistration.java:253: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The bean instance, or null when a {@code @Nullable} factory method produced none
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean instance, or null when a {@code @Nullable} factory method produced none.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 41s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanRegistration.java:266: warning: [EqualsGetClass] Prefer instanceof to getClass when implementing Object#equals. Note that this may be a behaviour change.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean equals(Object o) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EqualsGetClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof BeanRegistration)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/scope/CreatedBean.java:35: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The bean definition.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean definition.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/scope/CreatedBean.java:40: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The bean
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultBeanDependencies.java:59: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The interceptor candidates retained for the lifecycle of the owner, unresolved until creation captures them
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the interceptor candidates retained for the lifecycle of the owner, unresolved until creation captures them.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultBeanDependencies.java:66: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The retained candidates as the nullable list the resolution context and registration contracts use,
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the retained candidates as the nullable list the resolution context and registration contracts use,'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 41s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultBeanDependencies.java:90: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         boolean removed = remaining.removeIf(candidate -> candidate == registration);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'boolean removed = remaining.removeIf(candidate -> Objects.equals(candidate, registration));' or 'boolean removed = remaining.removeIf(candidate -> candidate.equals(registration));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultBeanDependencies.java:134: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 } else if (failure != e) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '} else if (!failure.equals(e)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultBeanDependencies.java:153: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The shared registrations resolved through this owner, which it does not own and only orders destruction by
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the shared registrations resolved through this owner, which it does not own and only orders destruction by.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultBeanDependencies.java:170: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether this owner stopped accepting new dependencies
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether this owner stopped accepting new dependencies.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 41s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultBeanDependencies.java:281: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (!isResolvable() || destructionContext != null && !destructionContext.isDestructionInvocationActive()
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!isResolvable() || (destructionContext != null && !destructionContext.isDestructionInvocationActive())'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/DefaultBeanDependencies.java:282: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             || destructionContext == null && context.isDependencyResolutionClosed()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '|| (destructionContext == null && context.isDependencyResolutionClosed())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 41s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:127: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The property resolver
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the property resolver.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:282: warning: [IdentityHashMapUsage] IdentityHashMap usage shouldn't be intermingled with Map
Step #3 - "compile-libfuzzer-coverage-x86_64":             stored = new IdentityHashMap<>();
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/IdentityHashMapUsage)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:370: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The context
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the context.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:375: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The class requested at the root of this resolution context
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the class requested at the root of this resolution context.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:381: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The path that this resolution has taken so far
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the path that this resolution has taken so far.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:386: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The configuration path.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:402: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param key The key
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the attribute value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:462: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The current bean identifier
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the current bean identifier.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:481: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The dependent beans that must be destroyed by an upstream bean
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the dependent beans that must be destroyed by an upstream bean.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:488: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The current dependent beans that must be destroyed by an upstream bean
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:497: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The current dependent beans that must be destroyed by an upstream bean.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:554: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The dependent factory beans that was used to create the bean in context
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:746: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The current path segment
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the current path segment.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:774: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The type requested
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type requested.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:779: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The declaring type qualifier
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:786: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The inject point
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the inject point.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:791: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The name of the segment. For a field this is the field name, for a method the method name and for a constructor the type name
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the segment. For a field this is the field name, for a method the method name and for a constructor the type name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject/src/main/java/io/micronaut/context/BeanResolutionContext.java:796: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The argument to create the type. For a field this will be empty
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the argument to create the type. For a field this will be empty.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 41s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE/src/micronaut-core/inject/src/main/java/io/micronaut/context/env/ConfigurationPath.java:40: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Creates a new path.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns creates a new path.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 41s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE│██▌············│ 16% EXECUTING [4m 42s]│██▌············│ 16% EXECUTING [4m 43s]│██▌············│ 16% EXECUTING [4m 44s]│██▌············│ 16% EXECUTING [4m 45s]│██▌············│ 16% EXECUTING [4m 46s]│██▌············│ 16% EXECUTING [4m 47s]│██▌············│ 16% EXECUTING [4m 48s]│██▌············│ 16% EXECUTING [4m 49s]│██▌············│ 16% EXECUTING [4m 50s]│██▌············│ 16% EXECUTING [4m 51s]│██▌············│ 16% EXECUTING [4m 52s]│██▌············│ 16% EXECUTING [4m 53s]│██▌············│ 16% EXECUTING [4m 54s]│██▌············│ 16% EXECUTING [4m 55s]│██▌············│ 16% EXECUTING [4m 56s]│██▌············│ 16% EXECUTING [4m 57s]│██▌············│ 16% EXECUTING [4m 58s]Note: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██▌············│ 16% EXECUTING [4m 58s]> IDLE> IDLE> :micronaut-core:micronaut-inject:compileJava> IDLE│██▌············│ 16% EXECUTING [4m 59s]> :micronaut-core:micronaut-inject:compileJava > Packing build cache entry│██▉············│ 19% EXECUTING [5m]> :micronaut-core:micronaut-inject:jar│███············│ 20% EXECUTING [5m]> :micronaut-core:micronaut-core-reactive:compileKotlin > Resolve files of conf> :micronaut-core:micronaut-core-reactive:compileKotlin > Resolve files of conf> IDLE> :micronaut-core:micronaut-core-reactive:compileKotlin > Resolve files of conf> IDLE│███············│ 20% EXECUTING [5m 1s]│███············│ 20% EXECUTING [5m 2s]> :micronaut-core:micronaut-core-reactive:compileKotlin > Resolve files of conf│███············│ 20% EXECUTING [5m 3s]> :micronaut-core:micronaut-core-reactive:compileKotlin > Resolve files of conf> IDLE> IDLE> :micronaut-core:micronaut-core-reactive:compileKotlin > Resolve files of conf> IDLE│███············│ 20% EXECUTING [5m 4s]> :micronaut-core:micronaut-core-reactive:compileKotlin│███············│ 20% EXECUTING [5m 5s]> :micronaut-core:micronaut-core-reactive:compileKotlin > Resolve files of conf> :micronaut-core:micronaut-core-reactive:compileKotlin > Resolve files of conf> :micronaut-core:micronaut-core-reactive:compileKotlin> IDLE│███············│ 20% EXECUTING [5m 6s]│███▍···········│ 22% EXECUTING [5m 6s]│████▋··········│ 31% EXECUTING [5m 6s]> :micronaut-core:micronaut-http:generatePomFileForMavenPublication│██████▍········│ 43% EXECUTING [5m 6s]> :micronaut-core:micronaut-http-netty:generatePomFileForMavenPublication│███████▋·······│ 51% EXECUTING [5m 6s]> :micronaut-core:micronaut-http-server-netty:sourcesJar│███████▉·······│ 52% EXECUTING [5m 6s]> :micronaut-core:micronaut-aop:sourcesJar│███████▉·······│ 53% EXECUTING [5m 6s]> :micronaut-core:micronaut-http:sourcesJar│████████·······│ 53% EXECUTING [5m 7s]> :micronaut-core:micronaut-inject:sourcesJar│████████·······│ 54% EXECUTING [5m 7s]> :micronaut-core:micronaut-core:sourcesJar│████████▎······│ 55% EXECUTING [5m 7s]> :micronaut-core:micronaut-json-core:sourcesJar│████████▌······│ 56% EXECUTING [5m 7s]> :micronaut-core:micronaut-router:sourcesJar│████████▌······│ 57% EXECUTING [5m 7s]> :micronaut-core:micronaut-aop:kotlinSourcesJar│████████▊······│ 58% EXECUTING [5m 7s]> :micronaut-core:micronaut-http:kotlinSourcesJar> IDLE│████████▊······│ 58% EXECUTING [5m 8s]│████████▊······│ 58% EXECUTING [5m 9s]│████████▊······│ 58% EXECUTING [5m 10s]│████████▊······│ 58% EXECUTING [5m 11s]│████████▊······│ 58% EXECUTING [5m 12s]│████████▉······│ 59% EXECUTING [5m 12s]> :micronaut-core:micronaut-core-reactive:compileJava> :micronaut-core:micronaut-core-reactive:compileJava > Requesting from remote > :micronaut-core:micronaut-core-reactive:compileJava│████████▉······│ 59% EXECUTING [5m 13s]│████████▉······│ 59% EXECUTING [5m 14s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-core-reactive:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/CompletionAwareSubscriber.java:49: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether is complete
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether is complete.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/TypedSubscriber.java:41: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type argument
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type argument.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/SingleThreadedBufferingSubscriber.java:36: warning: [JdkObsolete] It is very rare for LinkedList to out-perform ArrayList or ArrayDeque. Avoid it unless you're willing to invest a lot of time into benchmarking. Caveat: LinkedList supports null elements, but ArrayDeque does not.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected final Queue<T> upstreamBuffer = new LinkedList<>();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/JdkObsolete)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'protected final Queue<T> upstreamBuffer = new ArrayDeque<>();'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/SingleThreadedBufferingSubscriber.java:44: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (upstreamState) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (upstreamState) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/SingleThreadedBufferingSubscriber.java:64: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (upstreamState) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (upstreamState) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/SingleThreadedBufferingSubscriber.java:81: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (upstreamState) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (upstreamState) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/SingleThreadedBufferingSubscriber.java:166: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param subscriber The subscriber
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/SingleThreadedBufferingSubscriber.java:173: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The subscription
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the subscription.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/subscriber/SingleThreadedBufferingSubscriber.java:269: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":             switch (upstreamState) {
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (upstreamState) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/processor/SingleThreadedBufferingProcessor.java:72: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param downstreamSubscriber The downstream subscriber
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/processor/SingleThreadedBufferingProcessor.java:78: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (upstreamState) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (upstreamState) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/SingleSubscriberPublisher.java:68: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Obtain the current subscriber
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns obtain the current subscriber.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/Publishers.java:483: warning: [UnusedMethod] Method 'packageOf' is never used.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private static String packageOf(Class<?> type) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/Publishers.java:210: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A list of known reactive types.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a list of known reactive types.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/Publishers.java:217: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A list of known single types.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a list of known single types.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/Publishers.java:224: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A list of known single types.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a list of known single types.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████▉······│ 59% EXECUTING [5m 14s]> IDLE> :micronaut-core:micronaut-core-reactive:compileJava> IDLE> IDLE/src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/Publishers.java:442: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 future.get().whenComplete((aVoid, throwable) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = future.get().whenComplete((aVoid, throwable) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/Publishers.java:521: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public static <T> T convertPublisher(Object object, Class<T> publisherType) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "Publishers.convertPublisher(ConversionService.SHARED, object, publisherType)", imports = {"io.micronaut.core.async.publisher.Publishers", "io.micronaut.core.convert.ConversionService"})'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████▉······│ 59% EXECUTING [5m 14s]> IDLE> :micronaut-core:micronaut-core-reactive:compileJava> IDLE> IDLE/src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:114: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             future.whenComplete((list, throwable) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'future = future.whenComplete((list, throwable) -> {' or 'var unused = future.whenComplete((list, throwable) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:131: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         result.whenComplete((list, throwable) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'result = result.whenComplete((list, throwable) -> {' or 'var unused = result.whenComplete((list, throwable) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:201: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         cancelling(stage, result);
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = cancelling(stage, result);' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:239: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             cancelling(next, result);
Step #3 - "compile-libfuzzer-coverage-x86_64":                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = cancelling(next, result);' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:248: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         cancelling(stage, result);
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = cancelling(stage, result);' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████▉······│ 59% EXECUTING [5m 14s]> IDLE> :micronaut-core:micronaut-core-reactive:compileJava> IDLE> IDLE/src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:323: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             derived.whenComplete((value, throwable) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'derived = derived.whenComplete((value, throwable) -> {' or 'var unused = derived.whenComplete((value, throwable) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:333: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param throwable The failure of a future
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the failure without the {@link CompletionException} wrapper the future may have added.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:362: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         future.whenComplete((value, throwable) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'future = future.whenComplete((value, throwable) -> {' or 'var unused = future.whenComplete((value, throwable) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████▉······│ 59% EXECUTING [5m 14s]> IDLE> :micronaut-core:micronaut-core-reactive:compileJava> IDLE> IDLE/src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletionStagePublishers.java:593: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             source.whenComplete((value, throwable) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'source = source.whenComplete((value, throwable) -> {' or 'var unused = source.whenComplete((value, throwable) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/CompletableFuturePublisher.java:85: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                             future.whenComplete((s, throwable) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'future = future.whenComplete((s, throwable) -> {' or 'var unused = future.whenComplete((s, throwable) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████▉······│ 59% EXECUTING [5m 14s]> IDLE> :micronaut-core:micronaut-core-reactive:compileJava> IDLE> IDLE/src/micronaut-core/core-reactive/src/main/java/io/micronaut/core/async/publisher/DelayedSubscriber.java:138: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (completion == COMPLETE) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (completion.equals(COMPLETE)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 29 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████▉······│ 59% EXECUTING [5m 14s]> IDLE> :micronaut-core:micronaut-core-reactive:compileJava> IDLE> IDLE│████████▉······│ 59% EXECUTING [5m 15s]│█████████▏·····│ 61% EXECUTING [5m 15s]> :micronaut-core:micronaut-aop:compileKotlin > Resolve files of configuration > :micronaut-core:micronaut-aop:compileKotlin > Resolve files of configuration > :micronaut-core:micronaut-aop:compileKotlin > Resolve files of configuration > IDLE> IDLE> :micronaut-core:micronaut-aop:compileKotlin > Requesting from remote build ca> :micronaut-core:micronaut-aop:compileKotlin│█████████▏·····│ 61% EXECUTING [5m 16s]│█████████▏·····│ 61% EXECUTING [5m 17s]> :micronaut-core:micronaut-aop:compileJava > Requesting from remote build cach> :micronaut-core:micronaut-aop:compileJava│█████████▏·····│ 61% EXECUTING [5m 18s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-aop:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/ExactInterceptorBindingQualifier.java:332: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             return value == otherValue;
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return Objects.equals(value, otherValue);' or 'return value.equals(otherValue);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/ExactInterceptorBindingQualifier.java:366: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (!otherMembers.containsKey(member.getKey()) || !sameValue(member.getValue(), otherMembers.get(member.getKey()))) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/ExactInterceptorBindingQualifier.java:366: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (!otherMembers.containsKey(member.getKey()) || !sameValue(member.getValue(), otherMembers.get(member.getKey()))) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/InterceptorKind.java:74: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The associated annotation type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the associated annotation type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/InterceptorKind.java:81: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The associated annotation name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the associated annotation name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/MethodInvocationContext.java:70: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (executableMethod == this || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(executableMethod, this) || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {' or 'if (executableMethod.equals(this) || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/MethodInvocationContext.java:70: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (executableMethod == this || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (executableMethod == this || !Objects.equals(executableMethod.getAnnotationMetadata(), getAnnotationMetadata())) {' or 'if (executableMethod == this || !executableMethod.getAnnotationMetadata().equals(getAnnotationMetadata())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/MethodInvocationContext.java:86: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (executableMethod == this) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(executableMethod, this)) {' or 'if (executableMethod.equals(this)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/MethodInvocationContext.java:96: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (executableMethod == this || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(executableMethod, this) || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {' or 'if (executableMethod.equals(this) || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/MethodInvocationContext.java:96: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (executableMethod == this || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (executableMethod == this || !Objects.equals(executableMethod.getAnnotationMetadata(), getAnnotationMetadata())) {' or 'if (executableMethod == this || !executableMethod.getAnnotationMetadata().equals(getAnnotationMetadata())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 19s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/MethodInvocationContext.java:106: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (executableMethod == this || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(executableMethod, this) || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {' or 'if (executableMethod.equals(this) || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/MethodInvocationContext.java:106: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (executableMethod == this || executableMethod.getAnnotationMetadata() != getAnnotationMetadata()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (executableMethod == this || !Objects.equals(executableMethod.getAnnotationMetadata(), getAnnotationMetadata())) {' or 'if (executableMethod == this || !executableMethod.getAnnotationMetadata().equals(getAnnotationMetadata())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/InvocationContext.java:55: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The target object
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the target object.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/InvocationContext.java:80: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return An enum representing the kind of interception that is occurring.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/kotlin/KotlinInterceptedMethod.java:32: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Coroutine's context
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns coroutine's context.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/InterceptedMethod.java:47: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     static InterceptedMethod of(MethodInvocationContext<?, ?> context) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "InterceptedMethod.of(context, ConversionService.SHARED)", imports = {"io.micronaut.aop.InterceptedMethod", "io.micronaut.core.convert.ConversionService"})'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 19s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/runtime/RuntimeProxyDefinition.java:52: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The bean context.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean context.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/runtime/RuntimeProxyDefinition.java:57: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The intercepted methods.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the intercepted methods.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/runtime/RuntimeProxyDefinition.java:62: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The proxy bean definition.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the proxy bean definition.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/runtime/RuntimeProxyDefinition.java:74: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return true if introduction proxy. Otherwise, around proxy.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if introduction proxy. Otherwise, around proxy.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/runtime/RuntimeProxyDefinition.java:79: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return true if around proxy with a proxy target
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if around proxy with a proxy target.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/runtime/RuntimeProxyDefinition.java:92: warning: [ArrayRecordComponent] Record components should not be arrays.
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 Interceptor<K, Object>[] interceptors) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ArrayRecordComponent)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/runtime/DefaultRuntimeProxyDefinition.java:56: warning: [ArrayRecordComponent] Record components should not be arrays.
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                Object[] constructorValues,
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ArrayRecordComponent)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 19s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/ConstructorInvocationContext.java:28: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The bean type.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 19s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/chain/TargetInterceptors.java:169: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         return targetRegistration != null && targetBean != null && targetRegistration.getBean() == targetBean
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return targetRegistration != null && targetBean != null && Objects.equals(targetRegistration.getBean(), targetBean)' or 'return targetRegistration != null && targetBean != null && targetRegistration.getBean().equals(targetBean)'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 19s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/chain/ConstructorInterceptorChain.java:222: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (e == bodyFailure) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (e.equals(bodyFailure)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 19s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/chain/AbstractInterceptorChain.java:171: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (interceptor == from) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(interceptor, from)) {' or 'if (interceptor.equals(from)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 19s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/chain/DefaultInterceptorRegistry.java:137: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (selectMethodInterceptor && (bean instanceof MethodInterceptor || !(bean instanceof ConstructorInterceptor))
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if ((selectMethodInterceptor && (bean instanceof MethodInterceptor || !(bean instanceof ConstructorInterc'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/chain/DefaultInterceptorRegistry.java:138: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":                 || selectConstructorInterceptor && (bean instanceof ConstructorInterceptor || !(bean instanceof MethodInterceptor))) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '|| (selectConstructorInterceptor && (bean instanceof ConstructorInterceptor || !(bean instanceof MethodI'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 20s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/internal/intercepted/KotlinInterceptedMethodImpl.java:120: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (result != KotlinUtils.COROUTINE_SUSPENDED) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!Objects.equals(result, KotlinUtils.COROUTINE_SUSPENDED)) {' or 'if (!result.equals(KotlinUtils.COROUTINE_SUSPENDED)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/internal/intercepted/KotlinInterceptedMethodImpl.java:142: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (result != KotlinUtils.COROUTINE_SUSPENDED) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!Objects.equals(result, KotlinUtils.COROUTINE_SUSPENDED)) {' or 'if (!result.equals(KotlinUtils.COROUTINE_SUSPENDED)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/internal/intercepted/KotlinInterceptedMethodImpl.java:150: warning: [FutureReturnValueIgnored] Returning java.util.concurrent.CompletableFuture<java.lang.Object> from method that returns java.lang.Object. Errors from the returned future may be ignored.
Step #3 - "compile-libfuzzer-coverage-x86_64":         return interceptResultAsCompletionStage();
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/internal/intercepted/KotlinInterceptedMethodImpl.java:155: warning: [FutureReturnValueIgnored] Returning java.util.concurrent.CompletableFuture<java.lang.Object> from method that returns java.lang.Object. Errors from the returned future may be ignored.
Step #3 - "compile-libfuzzer-coverage-x86_64":         return interceptResultAsCompletionStage(from);
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 20s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/internal/intercepted/PublisherInterceptedMethod.java:78: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         return (Publishers.MicronautPublisher<Object>) s -> executorService.submit(() -> actual.subscribe(s));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 20s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/internal/intercepted/CompletionStageInterceptedMethod.java:109: warning: [FutureReturnValueIgnored] Returning java.util.concurrent.CompletableFuture<capture#148 of ?> from method that returns java.lang.Object. Errors from the returned future may be ignored.
Step #3 - "compile-libfuzzer-coverage-x86_64":             return stage.toCompletableFuture();
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 20s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/InterceptorBinding.java:65: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The kind of interceptor.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the kind of interceptor.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/InterceptPhase.java:65: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The position
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the position.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 20s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/beandefinition/InterceptedMethod.java:116: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (annotationMetadata != AnnotationMetadata.EMPTY_METADATA) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!Objects.equals(annotationMetadata, AnnotationMetadata.EMPTY_METADATA)) {' or 'if (!annotationMetadata.equals(AnnotationMetadata.EMPTY_METADATA)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/beandefinition/InterceptedMethod.java:139: warning: [EqualsGetClass] Prefer instanceof to getClass when implementing Object#equals. Note that this may be a behaviour change.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean equals(Object o) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EqualsGetClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof InterceptedMethod)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 20s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE/src/micronaut-core/aop/src/main/java/io/micronaut/aop/beandefinition/SharedInterceptorRegistrations.java:126: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (stack != null && !stack.isEmpty() && stack.peek().definition == definition) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (stack != null && !stack.isEmpty() && Objects.equals(stack.peek().definition, definition)) {' or 'if (stack != null && !stack.isEmpty() && stack.peek().definition.equals(definition)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/beandefinition/SharedInterceptorRegistrations.java:173: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (entry.definition == definition) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(entry.definition, definition)) {' or 'if (entry.definition.equals(definition)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/aop/src/main/java/io/micronaut/aop/InterceptorBindingDefinitions.java:37: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The interceptor binding definitions.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the interceptor binding definitions.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 20s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLENote: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 42 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▏·····│ 61% EXECUTING [5m 21s]> IDLE> :micronaut-core:micronaut-aop:compileJava> IDLE> IDLE│█████████▍·····│ 63% EXECUTING [5m 21s]> :micronaut-core:micronaut-core-processor:compileJava> :micronaut-core:micronaut-core-processor:compileJava > Resolve files of confi> :micronaut-core:micronaut-core-processor:compileJava > Resolve files of confi> IDLE> :micronaut-core:micronaut-core-processor:compileJava> :micronaut-core:micronaut-core-processor:compileJava > Requesting from remote> :micronaut-core:micronaut-core-processor:compileJava│█████████▍·····│ 63% EXECUTING [5m 22s]│█████████▍·····│ 63% EXECUTING [5m 23s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-core-processor:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/expressions/EvaluatedExpressionWriter.java:92: warning: [removal] invokeConstructor(ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                     aThis.superRef().invokeConstructor(methodParameters.get(0)))
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/visitor/TypeElementVisitor.java:170: warning: [removal] resolveInterfaceTypeArguments(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         Class<?>[] classes = GenericTypeUtils.resolveInterfaceTypeArguments(getClass(), TypeElementVisitor.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/visitor/PackageElementVisitor.java:51: warning: [removal] resolveInterfaceTypeArgument(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         Optional<Class<?>> clazz = GenericTypeUtils.resolveInterfaceTypeArgument(getClass(), PackageElementVisitor.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AnnotationBuilderWriter.java:214: warning: [removal] invokeConstructor(ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                 statements.add(aThis.superRef().invokeConstructor());
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AnnotationBuilderWriter.java:528: warning: [removal] invokeConstructor(ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                 .build((aThis, parameters) -> aThis.superRef().invokeConstructor(
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 23s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/visitor/BeanElementVisitor.java:77: warning: [removal] resolveInterfaceTypeArgument(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         final Class<?> t = GenericTypeUtils.resolveInterfaceTypeArgument(getClass(), BeanElementVisitor.class)
Step #3 - "compile-libfuzzer-coverage-x86_64":                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 23s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/BeanDefinitionWriter.java:4752: warning: [removal] invokeConstructor(ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                     -> aThis.superRef().invokeConstructor(
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/BeanDefinitionWriter.java:4828: warning: [removal] invokeConstructor(Constructor<?>,List<? extends ExpressionDef>) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                         return aThis.superRef(TYPE_ABSTRACT_BEAN_DEFINITION_AND_REFERENCE).invokeConstructor(BEAN_DEFINITION_CLASS_CONSTRUCTOR2.get(), values);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/BeanDefinitionWriter.java:4831: warning: [removal] invokeConstructor(Constructor<?>,List<? extends ExpressionDef>) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                         return aThis.superRef(TYPE_ABSTRACT_BEAN_DEFINITION_AND_REFERENCE).invokeConstructor(BEAN_DEFINITION_CLASS_CONSTRUCTOR1.get(), values);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/BeanDefinitionWriter.java:4840: warning: [removal] invokeConstructor(MethodDef,ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                     -> aThis.invokeConstructor(
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 23s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/ExecutableMethodsDefinitionWriter.java:318: warning: [removal] invokeConstructor(Constructor<?>,ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                     .invokeConstructor(SUPER_CONSTRUCTOR, createMethodsArrayExp))
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/ExecutableMethodsDefinitionWriter.java:329: warning: [removal] invokeConstructor(MethodDef,ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                             aThis.invokeConstructor(constructorWithInterceptable, ExpressionDef.falseValue())
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/ExecutableMethodsDefinitionWriter.java:340: warning: [removal] invokeConstructor(Constructor<?>,ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                         .invokeConstructor(SUPER_CONSTRUCTOR, createMethodsArrayExp)
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/BeanConfigurationWriter.java:107: warning: [removal] invokeConstructor(ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                 -> aThis.superRef().invokeConstructor(ExpressionDef.constant(packageName))))
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 23s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/MethodGenUtils.java:266: warning: [removal] invokeConstructor(List<TypeDef>,List<? extends ExpressionDef>) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             return superVar.invokeConstructor(
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/MethodGenUtils.java:271: warning: [removal] invokeConstructor(MethodDef,List<? extends ExpressionDef>) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return superVar.invokeConstructor(MethodDef.of(constructor), constructorValues);
Step #3 - "compile-libfuzzer-coverage-x86_64":                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 23s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/aop/writer/AopProxyWriter.java:1149: warning: [removal] invokeConstructor(ExpressionDef...) in ExpressionDef has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             return aThis.superRef().invokeConstructor();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 23s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE│█████████▍·····│ 63% EXECUTING [5m 24s]/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/OriginatingElements.java:26: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The elements where the bean definition originated from as an array.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 24s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/expressions/context/ExpressionWithContext.java:56: warning: [EqualsGetClass] Prefer instanceof to getClass when implementing Object#equals. Note that this may be a behaviour change.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean equals(Object o) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EqualsGetClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof ExpressionWithContext)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/expressions/context/ExpressionEvaluationContext.java:38: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Find the type that represents this.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns find the type that represents this.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/visitor/VisitorContext.java:61: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The visitor context's language.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/visitor/VisitorContext.java:83: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The expression compilation context factory.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/visitor/VisitorContext.java:224: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The visitor configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the visitor configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 24s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:54: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the element is package private.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:72: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the element is protected.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the element is protected.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:77: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the element is public.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the element is public.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:90: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link ElementModifier} types for this class element
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:107: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the element is abstract.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the element is abstract.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:114: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the element is static.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the element is static.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:121: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The documentation, if any.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the documentation, if any.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:128: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param parseContent True if the content should be parsed to extract documentation
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:137: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the element is private.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the element is private.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/Element.java:144: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the element is final.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the element is final.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 24s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/annotation/MutableAnnotationMetadataDelegate.java:73: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see #removeAnnotation(String)
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this element.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/processing/ProcessingException.java:51: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The element that caused the issue.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the element that caused the issue.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 25s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/expressions/context/ExpressionCompilationContextFactory.java:45: warning: [EmptyBlockTag] A block tag (@param, @return, @throws, @deprecated) has an empty description. Block tags without descriptions don't add much value for future readers of the code; consider removing the tag entirely or adding a description.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param thisElement
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.1.3-javadoc-block-tags)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '*'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 25s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:640: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":             boolean shouldValidate = !(annotationName.equals(AliasFor.class.getName())) &&
Step #3 - "compile-libfuzzer-coverage-x86_64":                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'boolean shouldValidate = ! annotationName.equals(AliasFor.class.getName()) &&'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 25s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:801: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param annotationElement The annotation element
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the annotation value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:810: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param annotationElement The annotation element
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the annotation value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 25s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:1003: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (!defaultValues.containsKey(memberName)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 25s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:1102: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             boolean isDeclared = currentElement == element;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'boolean isDeclared = currentElement.equals(element);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 25s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:1389: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                     if (transformedValue == memberAnnotationValue) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(transformedValue, memberAnnotationValue)) {' or 'if (transformedValue.equals(memberAnnotationValue)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 25s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:1729: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         String when = Objects.toString(stereotypeAnnotationValue.getValues().get("when"));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:1755: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             containerValues.remove(AnnotationMetadata.VALUE_MEMBER);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:1772: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param annotationValue The annotation value
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the annotation is a repeatable container.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:1823: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (defaultValue == null || newValues.containsKey(key)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2043: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (retainedMember != member) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!Objects.equals(retainedMember, member)) {' or 'if (!retainedMember.equals(member)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2071: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (nested != nestedValues[i]) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!Objects.equals(nested, nestedValues[i])) {' or 'if (!nested.equals(nestedValues[i])) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2187: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (RETAINABLE.equals(stereotype.getAnnotationName()) || nested != null && containsRetainable(nested)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (RETAINABLE.equals(stereotype.getAnnotationName()) || (nested != null && containsRetainable(nested))) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2324: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (newAnnotationValue == annotationValue) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(newAnnotationValue, annotationValue)) {' or 'if (newAnnotationValue.equals(annotationValue)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2359: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (newAnnotationValue == annotationValue) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(newAnnotationValue, annotationValue)) {' or 'if (newAnnotationValue.equals(annotationValue)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2388: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                         .filter(newAnnotationValue -> newAnnotationValue != annotationValue)
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '.filter(newAnnotationValue -> !Objects.equals(newAnnotationValue, annotationValue))' or '.filter(newAnnotationValue -> !newAnnotationValue.equals(annotationValue))'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2470: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Additional mapped annotation names
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns additional mapped annotation names.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2478: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Additional mapped annotation names
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns additional mapped annotation names.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2575: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (declaredMetadata == AnnotationMetadata.EMPTY_METADATA) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(declaredMetadata, AnnotationMetadata.EMPTY_METADATA)) {' or 'if (declaredMetadata.equals(AnnotationMetadata.EMPTY_METADATA)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2623: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public ProcessingContext withProcessedVisitor(Class<?> processedVisitor) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'ProcessingContext withProcessedVisitor(Class<?> processedVisitor) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2650: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public ProcessedAnnotation withAnnotationValue(AnnotationValue<?> annotationValue) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'ProcessedAnnotation withAnnotationValue(AnnotationValue<?> annotationValue) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2654: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public ProcessedAnnotation withAnnotationType(@Nullable T annotationType) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'ProcessedAnnotation withAnnotationType(@Nullable T annotationType) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2658: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public ProcessedAnnotation mutateAnnotationValue(Function<AnnotationValueBuilder<?>, AnnotationValueBuilder<?>> fn) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'ProcessedAnnotation mutateAnnotationValue(Function<AnnotationValueBuilder<?>, AnnotationValueBuilder'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2663: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public T getAnnotationType() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'T getAnnotationType() {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2667: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public AnnotationValue<?> getAnnotationValue() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'AnnotationValue<?> getAnnotationValue() {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2687: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public ProcessedAnnotation getAnnotation() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'ProcessedAnnotation getAnnotation() {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2691: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public int getIndex() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'int getIndex() {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2711: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Is mutated?
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is mutated?.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2723: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Was the metadata cleared by a previous processor.
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns was the metadata cleared by a previous processor.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AbstractAnnotationMetadataBuilder.java:2863: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public DefaultCachedAnnotationMetadata(AnnotationMetadata annotationMetadata) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'DefaultCachedAnnotationMetadata(AnnotationMetadata annotationMetadata) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:106: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param kind The kind of error
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:116: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether this is a generic placeholder.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:126: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether this is a wildcard.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link WildcardElement}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:201: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether this element is a record
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:209: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether this element is sealed.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:217: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The permitted subclasses for this sealed element.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:276: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the class represents a proxy
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the class represents a proxy.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:447: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The interfaces implemented by this class element
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the interfaces implemented by this class element.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:600: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the class element is an interface
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the class element is an interface.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:607: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the type is iterable (either an array or an {@link Iterable})
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the type is iterable (either an array or an {@link Iterable}).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:726: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type arguments for this class element
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type arguments for this class element.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ClassElement.java:795: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The first type argument
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the first type argument.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/TypedElement.java:28: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type of the element
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type of the element.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/TypedElement.java:59: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         return this == PrimitiveElement.VOID;
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return this.equals(PrimitiveElement.VOID);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/annotation/AnnotationBuilderRegistrations.java:143: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                     + (current == type ? "the type " : "the type that encloses ") + current.getName() + " is not public");
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '+ (current.equals(type) ? "the type " : "the type that encloses ") + current.getName() + " is not public");'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/writer/GeneratedFile.java:41: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the file
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the file.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/beans/BeanElementBuilder.java:59: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The originating element
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the originating element.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/beans/BeanElementBuilder.java:64: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The bean type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the bean type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/beans/BeanElementBuilder.java:69: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The element that produces the bean.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the element that produces the bean.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/visitor/TypeHierarchyRecord.java:37: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the generated class of the record
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the generated class of the record.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/visitor/TypeHierarchyRecord.java:50: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the record names every super type of the type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the record names every super type of the type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/MethodElement.java:93: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The return type of the method
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the return type of the method.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/MethodElement.java:98: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type arguments declared on this method.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type arguments declared on this method.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/MethodElement.java:157: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The method parameters
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the method parameters.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 26s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE│█████████▍·····│ 63% EXECUTING [5m 27s]/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/MemberElement.java:35: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The declaring type of the element.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the declaring type of the element.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 27s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:240: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to return only abstract methods
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to return only abstract methods.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:245: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to return only injection points
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to return only injection points.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:250: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to return only concrete methods
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to return only concrete methods.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:255: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The element type
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the element type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:260: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to return only accessible members
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to return only accessible members.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:265: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Get the type this element is only accessible from.
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns get the type this element is only accessible from.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:270: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to declare only declared members
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to declare only declared members.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:275: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to return only instance methods
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to return only instance methods.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/core-processor/src/main/java/io/micronaut/inject/ast/ElementQuery.java:280: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to return only static methods / fields
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 27s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE│█████████▍·····│ 63% EXECUTING [5m 28s]│█████████▍·····│ 63% EXECUTING [5m 29s]│█████████▍·····│ 63% EXECUTING [5m 30s]│█████████▍·····│ 63% EXECUTING [5m 31s]│█████████▍·····│ 63% EXECUTING [5m 32s]│█████████▍·····│ 63% EXECUTING [5m 33s]│█████████▍·····│ 63% EXECUTING [5m 34s]│█████████▍·····│ 63% EXECUTING [5m 35s]│█████████▍·····│ 63% EXECUTING [5m 36s]│█████████▍·····│ 63% EXECUTING [5m 37s]Note: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████▍·····│ 63% EXECUTING [5m 37s]> :micronaut-core:micronaut-core-processor:compileJava> IDLE> IDLE> IDLE> :micronaut-core:micronaut-core-processor:compileJava > Packing build cache en│█████████▋·····│ 64% EXECUTING [5m 38s]> :micronaut-core:micronaut-core-processor:jar> :micronaut-core:micronaut-inject-java:compileJava> :micronaut-fuzzing-annotation-processor:compileJava│█████████▋·····│ 64% EXECUTING [5m 39s]│█████████▉·····│ 66% EXECUTING [5m 39s]> :micronaut-fuzzing-annotation-processor:jar│██████████·····│ 66% EXECUTING [5m 39s]> IDLE│██████████·····│ 66% EXECUTING [5m 40s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-inject-java:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaAnnotationMetadataBuilder.java:93: warning: [removal] AnnotationUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         AnnotationUtils annotationUtils,
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:643: warning: [removal] addGeneratedResource(String) in VisitorContext has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public void addGeneratedResource(String resource) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:638: warning: [removal] getGeneratedResources() in VisitorContext has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Collection<String> getGeneratedResources() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:130: warning: [removal] AnnotationUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         AnnotationUtils annotationUtils,
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:133: warning: [removal] GenericUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         GenericUtils genericUtils,
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:508: warning: [removal] AnnotationUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public AnnotationUtils getAnnotationUtils() {
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:509: warning: [removal] AnnotationUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return new AnnotationUtils(processingEnv, elements, messager, types, modelUtils, getGenericUtils(), filer);
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:528: warning: [removal] GenericUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public GenericUtils getGenericUtils() {
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:529: warning: [removal] GenericUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return new GenericUtils(elements, types, modelUtils);
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AnnotationUtils.java:73: warning: [removal] GenericUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         GenericUtils genericUtils,
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AnnotationUtils.java:103: warning: [removal] GenericUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         GenericUtils genericUtils,
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AnnotationUtils.java:125: warning: [removal] JavaAnnotationMetadataBuilder(Elements,Messager,AnnotationUtils,ModelUtils) in JavaAnnotationMetadataBuilder has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return new JavaAnnotationMetadataBuilder(
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaPropertyElement.java:121: warning: [removal] getWriteTypeAnnotationMetadata() in PropertyElement has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Optional<AnnotationMetadata> getWriteTypeAnnotationMetadata() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaPropertyElement.java:113: warning: [removal] getReadTypeAnnotationMetadata() in PropertyElement has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Optional<AnnotationMetadata> getReadTypeAnnotationMetadata() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/LoadedVisitor.java:75: warning: [removal] resolveInterfaceTypeArguments(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Class<?>[] classes = GenericTypeUtils.resolveInterfaceTypeArguments(aClass, TypeElementVisitor.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/LoadedVisitor.java:95: warning: [removal] resolveInterfaceTypeArguments(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             Class<?>[] classes = GenericTypeUtils.resolveInterfaceTypeArguments(aClass, TypeElementVisitor.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PackageLoadedVisitor.java:66: warning: [removal] resolveInterfaceTypeArguments(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Class<?>[] classes = GenericTypeUtils.resolveInterfaceTypeArguments(aClass, PackageElementVisitor.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PackageLoadedVisitor.java:79: warning: [removal] resolveInterfaceTypeArguments(Class<?>,Class<?>) in GenericTypeUtils has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             Class<?>[] classes = GenericTypeUtils.resolveInterfaceTypeArguments(aClass, PackageElementVisitor.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/SuperclassAwareTypeVisitor.java:61: warning: [removal] GenericUtils in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     private final GenericUtils genericUtils;
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/SuperclassAwareTypeVisitor.java:71: warning: [removal] getGenericUtils() in JavaVisitorContext has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         this.genericUtils = visitorContext.getGenericUtils();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PublicMethodVisitor.java:37: warning: [removal] SuperclassAwareTypeVisitor in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public abstract class PublicMethodVisitor<R, P> extends SuperclassAwareTypeVisitor<R, P> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PublicMethodVisitor.java:37: warning: [removal] SuperclassAwareTypeVisitor in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public abstract class PublicMethodVisitor<R, P> extends SuperclassAwareTypeVisitor<R, P> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PublicAbstractMethodVisitor.java:45: warning: [removal] PublicMethodVisitor in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public abstract class PublicAbstractMethodVisitor<R, P> extends PublicMethodVisitor<R, P> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PublicAbstractMethodVisitor.java:45: warning: [removal] PublicMethodVisitor in io.micronaut.annotation.processing has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public abstract class PublicAbstractMethodVisitor<R, P> extends PublicMethodVisitor<R, P> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaElementAnnotationMetadataFactory.java:133: warning: [TypeEquals] TypeMirror should be compared using Types#isSameType, not equality operators or equals().
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (isApplicableToTypeUse(annotation) && typeAnnotations.stream().noneMatch(a -> a.getAnnotationType().equals(annotation.getAnnotationType()))) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeEquals)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaAnnotationMetadataBuilder.java:617: warning: [NotJavadoc] This element has multiple Javadoc comments; only the last one will be used.
Step #3 - "compile-libfuzzer-coverage-x86_64":     /**
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NotJavadoc)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaAnnotationMetadataBuilder.java:398: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (memberName != null && annotationValue instanceof javax.lang.model.element.AnnotationValue value && !annotationValues.containsKey(memberName)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 40s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaAnnotationMetadataBuilder.java:677: warning: [EmptyBlockTag] A block tag (@param, @return, @throws, @deprecated) has an empty description. Block tags without descriptions don't add much value for future readers of the code; consider removing the tag entirely or adding a description.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param originatingElement
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.1.3-javadoc-block-tags)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '*'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaAnnotationMetadataBuilder.java:678: warning: [EmptyBlockTag] A block tag (@param, @return, @throws, @deprecated) has an empty description. Block tags without descriptions don't add much value for future readers of the code; consider removing the tag entirely or adding a description.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param member
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.1.3-javadoc-block-tags)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '*'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaAnnotationMetadataBuilder.java:679: warning: [EmptyBlockTag] A block tag (@param, @return, @throws, @deprecated) has an empty description. Block tags without descriptions don't add much value for future readers of the code; consider removing the tag entirely or adding a description.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param resolvedDefaults
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.1.3-javadoc-block-tags)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '*'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 40s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaAnnotationMetadataBuilder.java:923: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             return o instanceof TypeMirrorKey that && typeMirror == that.typeMirror;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return o instanceof TypeMirrorKey that && Objects.equals(typeMirror, that.typeMirror);' or 'return o instanceof TypeMirrorKey that && typeMirror.equals(that.typeMirror);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/JavaAnnotationMetadataBuilder.java:923: warning: [TypeEquals] TypeMirror should be compared using Types#isSameType, not equality operators or equals().
Step #3 - "compile-libfuzzer-coverage-x86_64":             return o instanceof TypeMirrorKey that && typeMirror == that.typeMirror;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeEquals)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/AbstractJavaElement.java:503: warning: [MixedMutabilityReturnType] This method returns both mutable and immutable collections or maps from different paths. This may be confusing for users of the method.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private Map<String, ClassElement> resolveTypeArguments(List<? extends TypeParameterElement> typeParameters,
Step #3 - "compile-libfuzzer-coverage-x86_64":                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/MixedMutabilityReturnType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'private ImmutableMap<String, ClassElement> resolveTypeArguments(List<? extends TypeParameterElement> typeParameters,'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 40s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/AbstractJavaElement.java:102: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return copy of this element
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns copy of this element.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/AbstractJavaElement.java:107: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param element the values to be copied to
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 40s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/AbstractJavaElement.java:599: warning: [PatternMatchingInstanceof] This code can be simplified to use a pattern-matching instanceof.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (!(o instanceof io.micronaut.inject.ast.Element)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/PatternMatchingInstanceof)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof io.micronaut.inject.ast.Element that)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/ElementProvider.java:27: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The native element.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the native element.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 40s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:126: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public JavaVisitorContext(
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "this(processingEnv, messager, elements, types, modelUtils, filer, visitorAttributes, visitorKind, new HashSet<>())", imports = "java.util.HashSet")'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:154: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public JavaVisitorContext(
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "this(processingEnv, messager, elements, types, modelUtils, filer, visitorAttributes, visitorKind, Set.of())", imports = "java.util.Set")'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:212: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The visitor kind
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the visitor kind.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:219: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The processing environment
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the processing environment.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:226: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the unresolved interfaces should be visited
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:234: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param visitUnresolvedInterfaces True to visit unresolved interfaces
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 40s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:533: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The elements helper
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the elements helper.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaVisitorContext.java:648: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Gets the produced bean definition builders.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns gets the produced bean definition builders.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 41s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaNativeElement.java:52: warning: [AvoidCommonTypeNames] io.micronaut.annotation.processing.visitor.JavaNativeElement.Class clashes with java.lang.Class
Step #3 - "compile-libfuzzer-coverage-x86_64":     record Class(TypeElement element, @Nullable TypeMirror typeMirror,
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AvoidCommonTypeNames)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaNativeElement.java:103: warning: [AvoidCommonTypeNames] io.micronaut.annotation.processing.visitor.JavaNativeElement.Package clashes with java.lang.Package
Step #3 - "compile-libfuzzer-coverage-x86_64":     record Package(PackageElement element) implements JavaNativeElement {
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AvoidCommonTypeNames)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/ModelUtils.java:64: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type utilities
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type utilities.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 41s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaElementFactory.java:181: warning: [PatternMatchingInstanceof] This code can be simplified to use a pattern-matching instanceof.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (!(owningType instanceof JavaEnumElement)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/PatternMatchingInstanceof)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(owningType instanceof JavaEnumElement javaEnumElement)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/GenericUtils.java:241: warning: [MixedMutabilityReturnType] This method returns both mutable and immutable collections or maps from different paths. This may be confusing for users of the method.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected Map<String, TypeMirror> resolveBoundTypes(DeclaredType type) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/MixedMutabilityReturnType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return ImmutableMap.copyOf(boundTypes);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 41s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/GenericUtils.java:140: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":                 switch (kind) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (kind) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/GenericUtils.java:179: warning: [TypeEquals] TypeMirror should be compared using Types#isSameType, not equality operators or equals().
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 if (upperBound != null && !type.equals(upperBound)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeEquals)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (upperBound != null && !typeUtils.isSameType(type, upperBound)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/GenericUtils.java:206: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (kind) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (kind) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 41s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaClassElement.java:885: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":         return typeArguments != null && typeArguments.isEmpty()
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return (typeArguments != null && typeArguments.isEmpty())'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaClassElement.java:886: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             || resolvedTypeArguments != null && resolvedTypeArguments.isEmpty();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '|| (resolvedTypeArguments != null && resolvedTypeArguments.isEmpty());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 41s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/JavaClassElement.java:1022: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (classNode == classElement) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(classNode, classElement)) {' or 'if (classNode.equals(classElement)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 42s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/visitor/AbstractTypeAwareJavaElement.java:91: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             || hasNullMarked() && !isNullable();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '|| (hasNullMarked() && !isNullable());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 42s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/BeanDefinitionInjectProcessor.java:125: warning: [DoNotClaimAnnotations] Don't 'claim' annotations in annotation processors; Processor#process should unconditionally return `false`
Step #3 - "compile-libfuzzer-coverage-x86_64":         return ProcessorOptionsSystemProperties.process(processingEnv.getElementUtils(), this, roundEnv.processingOver(), () -> processRound(annotations, roundEnv));
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DoNotClaimAnnotations)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 42s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AbstractInjectAnnotationProcessor.java:102: warning: [EnumOrdinal] You should almost never invoke the Enum.ordinal() method or depend on the enum values by index.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (latestVersion.ordinal() >= 17) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EnumOrdinal)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AbstractInjectAnnotationProcessor.java:121: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The incremental processor type.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link #GRADLE_PROCESSING_ISOLATING}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AbstractInjectAnnotationProcessor.java:256: warning: [AnnotateFormatMethod] This method uses a pair of parameters as a format string and its arguments, but the enclosing method wasn't annotated. Doing so gives compile-time rather than run-time protection against malformed format strings.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected final void error(@Nullable Element e, String msg, Object... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AnnotateFormatMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AbstractInjectAnnotationProcessor.java:270: warning: [AnnotateFormatMethod] This method uses a pair of parameters as a format string and its arguments, but the enclosing method wasn't annotated. Doing so gives compile-time rather than run-time protection against malformed format strings.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected final void error(String msg, Object... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AnnotateFormatMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AbstractInjectAnnotationProcessor.java:284: warning: [AnnotateFormatMethod] This method uses a pair of parameters as a format string and its arguments, but the enclosing method wasn't annotated. Doing so gives compile-time rather than run-time protection against malformed format strings.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected final void warning(Element e, String msg, Object... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AnnotateFormatMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AbstractInjectAnnotationProcessor.java:298: warning: [AnnotateFormatMethod] This method uses a pair of parameters as a format string and its arguments, but the enclosing method wasn't annotated. Doing so gives compile-time rather than run-time protection against malformed format strings.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected final void warning(String msg, Object... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AnnotateFormatMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AbstractInjectAnnotationProcessor.java:312: warning: [AnnotateFormatMethod] This method uses a pair of parameters as a format string and its arguments, but the enclosing method wasn't annotated. Doing so gives compile-time rather than run-time protection against malformed format strings.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected final void note(Element e, String msg, Object... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AnnotateFormatMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AbstractInjectAnnotationProcessor.java:325: warning: [AnnotateFormatMethod] This method uses a pair of parameters as a format string and its arguments, but the enclosing method wasn't annotated. Doing so gives compile-time rather than run-time protection against malformed format strings.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected final void note(String msg, Object... args) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AnnotateFormatMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 42s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/TypeElementVisitorProcessor.java:193: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The loaded visitors.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the loaded visitors.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/TypeElementVisitorProcessor.java:200: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The incremental processor type.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link #GRADLE_PROCESSING_ISOLATING}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/TypeElementVisitorProcessor.java:252: warning: [DoNotClaimAnnotations] Don't 'claim' annotations in annotation processors; Processor#process should unconditionally return `false`
Step #3 - "compile-libfuzzer-coverage-x86_64":         return ProcessorOptionsSystemProperties.process(processingEnv.getElementUtils(), this, roundEnv.processingOver(), () -> processRound(annotations, roundEnv));
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DoNotClaimAnnotations)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 42s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/LoadedVisitor.java:142: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The visitor
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the visitor.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/LoadedVisitor.java:149: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param annotationMetadata The annotation data
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the class element should be visited.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/LoadedVisitor.java:169: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param annotationMetadata The annotation data
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the element should be visited.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PackageLoadedVisitor.java:48: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param visitor               The {@link PackageElementVisitor}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PackageLoadedVisitor.java:120: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param annotationMetadata The annotation data
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the package element should be visited.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 43s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/SuperclassAwareTypeVisitor.java:158: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param element The {@link Element}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the element is public and final.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/SuperclassAwareTypeVisitor.java:164: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param type The {@link DeclaredType}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 43s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/AnnotationsElement.java:123: warning: [TypeEquals] TypeMirror should be compared using Types#isSameType, not equality operators or equals().
Step #3 - "compile-libfuzzer-coverage-x86_64":         return Objects.equals(typeMirror, that.typeMirror) && Objects.equals(annotationMirrors, that.annotationMirrors);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeEquals)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 43s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PackageElementVisitorProcessor.java:130: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The loaded visitors.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the loaded visitors.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PackageElementVisitorProcessor.java:137: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The incremental processor type.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link #GRADLE_PROCESSING_ISOLATING}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/inject-java/src/main/java/io/micronaut/annotation/processing/PackageElementVisitorProcessor.java:160: warning: [DoNotClaimAnnotations] Don't 'claim' annotations in annotation processors; Processor#process should unconditionally return `false`
Step #3 - "compile-libfuzzer-coverage-x86_64":         return ProcessorOptionsSystemProperties.process(processingEnv.getElementUtils(), this, roundEnv.processingOver(), () -> processRound(annotations, roundEnv));
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DoNotClaimAnnotations)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 43s]> :micronaut-core:micronaut-inject-java:compileJava> IDLE> IDLE> IDLENote: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 80 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████·····│ 66% EXECUTING [5m 43s]> :micronaut-core:micronaut-inject-java:compileJava > Packing build cache entry> IDLE> IDLE> IDLE│██████████▎····│ 68% EXECUTING [5m 43s]> :micronaut-core:micronaut-graal:compileJava > Resolve files of configuration > :micronaut-core:micronaut-graal:compileJava > Resolve files of configuration > IDLE> :micronaut-core:micronaut-graal:compileJava> :micronaut-core:micronaut-graal:compileJava > Requesting from remote build ca│██████████▎····│ 68% EXECUTING [5m 44s]> :micronaut-core:micronaut-graal:compileJava│██████████▎····│ 68% EXECUTING [5m 45s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-graal:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/graal/src/main/java/io/micronaut/graal/reflect/GraalTypeElementVisitor.java:245: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":                 .getEnclosedElements(reflectiveFieldQuery.modifiers((elementModifiers -> !elementModifiers.contains(ElementModifier.PUBLIC))))
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '.getEnclosedElements(reflectiveFieldQuery.modifiers( elementModifiers -> !elementModifiers.contains(ElementModifier.PUBLIC)))'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 1 warning
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 45s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE> :micronaut-core:micronaut-context:compileJava > Resolve files of configuratio> :micronaut-core:micronaut-context:compileJava > Resolve files of configuratio│██████████▌····│ 70% EXECUTING [5m 46s]> IDLE> :micronaut-core:micronaut-context:compileJava> :micronaut-core:micronaut-context:compileJava > Requesting from remote build > :micronaut-core:micronaut-context:compileJava│██████████▌····│ 70% EXECUTING [5m 47s]│██████████▌····│ 70% EXECUTING [5m 48s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-context:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/executor/NamedThreadFactory.java:43: warning: [removal] SecurityManager in java.lang has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         SecurityManager s = System.getSecurityManager();
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/executor/NamedThreadFactory.java:43: warning: [removal] getSecurityManager() in System has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         SecurityManager s = System.getSecurityManager();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 48s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE│██████████▌····│ 70% EXECUTING [5m 49s]/src/micronaut-core/context/src/main/java/io/micronaut/runtime/TrainingTestResources.java:105: warning: [BooleanLiteral] This expression can be written more clearly with a boolean literal.
Step #3 - "compile-libfuzzer-coverage-x86_64":         System.setProperty(CLIENT_ENABLED, Boolean.FALSE.toString());
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/BooleanLiteral)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'System.setProperty(CLIENT_ENABLED, "false");'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 49s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:611: warning: [BadImport] Importing nested classes/static methods/static fields with commonly-used names can make code harder to read, because it may not be clear from the context exactly which type is being referred to. Qualifying the name with that of the containing class can make the code clearer. Here we recommend using qualified class: BeanIntrospection.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private record DefaultMappingBuilder<B>(Builder<B> builder) implements MappingBuilder<B> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/BadImport)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'private record DefaultMappingBuilder<B>(BeanIntrospection.Builder<B> builder) implements MappingBuilder<B> {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 49s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:155: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Object from = values.get(Mapper.Mapping.MEMBER_FROM);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:156: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Object condition = values.get(Mapper.Mapping.MEMBER_CONDITION);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:173: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":                         rootMappers.add((expressionEvaluationContext ->
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'rootMappers.add( expressionEvaluationContext ->'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:187: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":                         rootMappers.add((expressionEvaluationContext -> (object, builder) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'rootMappers.add( expressionEvaluationContext -> (object, builder) -> {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:194: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":                         rootMappers.add((expressionEvaluationContext -> (object, builder) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'rootMappers.add( expressionEvaluationContext -> (object, builder) -> {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:248: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         .orElseThrow(() -> new IllegalStateException("Invalid defaultValue [" + values.get(Mapper.Mapping.MEMBER_DEFAULT_VALUE) + "] specified to @Mapping annotation for type " + argument));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:253: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Object from = values.get(Mapper.Mapping.MEMBER_FROM);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:254: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Object condition = values.get(Mapper.Mapping.MEMBER_CONDITION);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:259: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":                         customMappers.put(to, (expressionEvaluationContext ->
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'customMappers.put(to,  expressionEvaluationContext ->'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:271: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":                         customMappers.put(to, (expressionEvaluationContext ->
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'customMappers.put(to,  expressionEvaluationContext ->'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:291: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":                             customMappers.put(to, (expressionEvaluationContext -> (object, builder) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'customMappers.put(to,  expressionEvaluationContext -> (object, builder) -> {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:296: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":                             customMappers.put(to, (expressionEvaluationContext -> (object, builder) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'customMappers.put(to,  expressionEvaluationContext -> (object, builder) -> {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 49s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:425: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public DefaultMapInvocation(
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'DefaultMapInvocation('?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:449: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public void map(MethodInvocationContext<Object, Object> callContext, MappingBuilder<Object> builder) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'void map(MethodInvocationContext<Object, Object> callContext, MappingBuilder<Object> builder) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 49s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:480: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             boolean isDefault = mapStrategy == MapStrategy.DEFAULT;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'boolean isDefault = Objects.equals(mapStrategy, MapStrategy.DEFAULT);' or 'boolean isDefault = mapStrategy.equals(MapStrategy.DEFAULT);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 49s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:513: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             boolean isDefault = mapStrategy == MapStrategy.DEFAULT;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'boolean isDefault = mapStrategy.equals(MapStrategy.DEFAULT);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:554: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public MapStrategy(Mapper.ConflictStrategy conflictStrategy) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'MapStrategy(Mapper.ConflictStrategy conflictStrategy) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:649: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public MergeMappingBuilder(
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'MergeMappingBuilder('?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/beans/MapperIntroduction.java:659: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public MergeMappingBuilder<B> setArgIndex(int argIndex) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'MergeMappingBuilder<B> setArgIndex(int argIndex) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 49s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE│██████████▌····│ 70% EXECUTING [5m 50s]/src/micronaut-core/context/src/main/java/io/micronaut/runtime/EmbeddedApplication.java:45: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link ApplicationConfiguration} instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link ApplicationConfiguration} instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/EmbeddedApplication.java:50: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link Environment} for the server
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link Environment} for the server.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:113: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default charset to use.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default charset to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:138: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name Set the application name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:147: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Configuration for the application instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns configuration for the application instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:154: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param instance The instance configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:187: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return An optional instance identifier
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns an optional instance identifier.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:194: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param id The instance identifier
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:201: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Any metadata to associate with the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns any metadata to associate with the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:208: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param metadata The metadata to associate with the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:215: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The instance auto-scaling group
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the instance auto-scaling group.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:222: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param group The instance auto-scaling group
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:229: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The instance availability zone. For example, it's possible to configure Netflix Ribbon to load balance between servers only in a particular zone
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the instance availability zone. For example, it's possible to configure Netflix Ribbon to load balance between servers only in a particular zone.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 50s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/ApplicationConfiguration.java:239: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param zone The instance availability zone
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/ScopedProxy.java:39: warning: [InjectInvalidTargetingOnScopingAnnotation] A scoping annotation's Target should include TYPE and METHOD.
Step #3 - "compile-libfuzzer-coverage-x86_64": @Target({ElementType.ANNOTATION_TYPE})
Step #3 - "compile-libfuzzer-coverage-x86_64": ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InjectInvalidTargetingOnScopingAnnotation)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@Target({TYPE, METHOD, ANNOTATION_TYPE})'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/Refreshable.java:36: warning: [InjectScopeAnnotationOnInterfaceOrAbstractClass] Scope annotation on an interface or abstract class is not allowed
Step #3 - "compile-libfuzzer-coverage-x86_64": @ScopedProxy
Step #3 - "compile-libfuzzer-coverage-x86_64": ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InjectScopeAnnotationOnInterfaceOrAbstractClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/Refreshable.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The key prefixes that should cause this bean to be refreshed
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the key prefixes that should cause this bean to be refreshed.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/ThreadLocal.java:38: warning: [AvoidCommonTypeNames] io.micronaut.runtime.context.scope.ThreadLocal clashes with java.lang.ThreadLocal
Step #3 - "compile-libfuzzer-coverage-x86_64": public @interface ThreadLocal {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AvoidCommonTypeNames)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/ThreadLocal.java:33: warning: [InjectScopeAnnotationOnInterfaceOrAbstractClass] Scope annotation on an interface or abstract class is not allowed
Step #3 - "compile-libfuzzer-coverage-x86_64": @ScopedProxy
Step #3 - "compile-libfuzzer-coverage-x86_64": ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InjectScopeAnnotationOnInterfaceOrAbstractClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 50s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/RefreshScope.java:168: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         return source == RefreshEvent.ALL_KEYS ? ConfigurationChange.ofAll() : ConfigurationChange.ofKeys(source.keySet());
Step #3 - "compile-libfuzzer-coverage-x86_64":                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return Objects.equals(source, RefreshEvent.ALL_KEYS) ? ConfigurationChange.ofAll() : ConfigurationChange.ofKeys(source.keySet());' or 'return source.equals(RefreshEvent.ALL_KEYS) ? ConfigurationChange.ofAll() : ConfigurationChange.ofKeys(source.keySet());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/RefreshScope.java:217: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (created.bean() == bean) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(created.bean(), bean)) {' or 'if (created.bean().equals(bean)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/RefreshScope.java:236: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param object The bean
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the lock on the object.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/RefreshScope.java:273: warning: [LockNotBeforeTry] Prefer obtaining the lock for lock outside the try block. That way, if #lock throws, the lock is not erroneously released.
Step #3 - "compile-libfuzzer-coverage-x86_64":             lock.lock();
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/LockNotBeforeTry)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'lock.lock();try {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 50s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/DefaultConfigurationRefresher.java:170: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         ConfigurationChange change = source == RefreshEvent.ALL_KEYS ? ConfigurationChange.ofAll() : toChange(source);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'ConfigurationChange change = Objects.equals(source, RefreshEvent.ALL_KEYS) ? ConfigurationChange.ofAll() : toChange(source);' or 'ConfigurationChange change = source.equals(RefreshEvent.ALL_KEYS) ? ConfigurationChange.ofAll() : toChange(source);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/DefaultConfigurationRefresher.java:178: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether a refresh is running on the current thread, which the scope uses to leave the
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether a refresh is running on the current thread, which the scope uses to leave the'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 50s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/DefaultConfigurationRefresher.java:359: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (candidate == definition || toDestroy.contains(registration) || !candidate.isSingleton()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(candidate, definition) || toDestroy.contains(registration) || !candidate.isSingleton()) {' or 'if (candidate.equals(definition) || toDestroy.contains(registration) || !candidate.isSingleton()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 50s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/RefreshResult.java:61: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether a watch answered that the change needs a restart of the application
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether a watch answered that the change needs a restart of the application.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/ConfigurationRefreshedEvent.java:52: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The change applied
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the change applied.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/ConfigurationRefreshedEvent.java:59: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The result
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the result.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 50s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/refresh/RefreshEventListener.java:43: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (source == RefreshEvent.ALL_KEYS) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (source.equals(RefreshEvent.ALL_KEYS)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/scope/ThreadLocalCustomScope.java:106: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (createdBean.bean() == bean) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(createdBean.bean(), bean)) {' or 'if (createdBean.bean().equals(bean)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 50s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/env/ConfigurationAdvice.java:36: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the method call a bean lookup
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is the method call a bean lookup.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/env/ConfigurationAdvice.java:41: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is it annotated with {@link io.micronaut.context.annotation.EachProperty}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is it annotated with {@link io.micronaut.context.annotation.EachProperty}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/context/env/ConfigurationAdvice.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The property to lookup
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the property to lookup.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 50s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/server/EmbeddedServer.java:33: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The port exposed by the server
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the port exposed by the server.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/server/EmbeddedServer.java:38: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The host of the server
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the host of the server.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/server/EmbeddedServer.java:43: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The scheme of the server (http/https)
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the scheme of the server (http/https).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/server/EmbeddedServer.java:48: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The full URL to the server
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the full URL to the server.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/server/EmbeddedServer.java:53: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The full URI to the server
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the full URI to the server.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/server/EmbeddedServer.java:58: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The full URI to the server with the context path
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/event/WatchEventType.java:49: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (kind == StandardWatchEventKinds.ENTRY_CREATE) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(kind, StandardWatchEventKinds.ENTRY_CREATE)) {' or 'if (kind.equals(StandardWatchEventKinds.ENTRY_CREATE)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/event/WatchEventType.java:51: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         } else if (kind == StandardWatchEventKinds.ENTRY_MODIFY) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '} else if (Objects.equals(kind, StandardWatchEventKinds.ENTRY_MODIFY)) {' or '} else if (kind.equals(StandardWatchEventKinds.ENTRY_MODIFY)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/event/WatchEventType.java:53: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         } else if (kind == StandardWatchEventKinds.ENTRY_DELETE) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '} else if (Objects.equals(kind, StandardWatchEventKinds.ENTRY_DELETE)) {' or '} else if (kind.equals(StandardWatchEventKinds.ENTRY_DELETE)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 51s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/converters/time/TimeConverterRegistrar.java:242: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":                 } catch (DateTimeParseException ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/converters/time/TimeConverterRegistrar.java:274: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":                 } catch (DateTimeException ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/converters/time/TimeConverterRegistrar.java:308: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":                 } catch (DateTimeParseException ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 51s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/runtime/converters/time/TimeConverterRegistrar.java:322: warning: [UnnecessaryLambda] Returning a lambda from a helper method or saving it in a constant is unnecessary; prefer to implement the functional interface method directly and use a method reference instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private BiFunction<CharSequence, ConversionContext, Optional<Duration>> durationConverter() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryLambda)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'final BiFunction<CharSequence, ConversionContext, Optional<Duration>> durationConverter = this::durationConverter;'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/converters/time/TimeConverterRegistrar.java:385: warning: [UnnecessaryLambda] Returning a lambda from a helper method or saving it in a constant is unnecessary; prefer to implement the functional interface method directly and use a method reference instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private BiFunction<CharSequence, ConversionContext, Optional<Period>> periodConverter() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryLambda)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'final BiFunction<CharSequence, ConversionContext, Optional<Period>> periodConverter = this::periodConverter;'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/runtime/converters/time/TimeConverterRegistrar.java:402: warning: [RefactorSwitch] This switch can be refactored to be more readable
Step #3 - "compile-libfuzzer-coverage-x86_64":                         switch (type) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/RefactorSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return switch (type) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 51s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/FileWatcherRegistration.java:33: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The absolute root the registration watches
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the absolute root the registration watches.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/FileWatcherRegistration.java:38: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the registration is still active
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the registration is still active.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 51s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:191: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the watch thread is running
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the watch thread is running.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 51s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:198: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The watch service the watcher polls
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the watch service the watcher polls.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:290: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (watchThread != null && watchThread != Thread.currentThread()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (watchThread != null && !watchThread.equals(Thread.currentThread())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:358: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (kind == StandardWatchEventKinds.OVERFLOW) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(kind, StandardWatchEventKinds.OVERFLOW)) {' or 'if (kind.equals(StandardWatchEventKinds.OVERFLOW)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 52s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:671: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param checkInterval How long a poll of the service waits while no change is pending
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:680: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param quietPeriod How long the watcher waits for further events before delivering a batch
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:689: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param threadName The name of the watch thread
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:710: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The watcher, not yet started
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 52s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/DirectoryWatcher.java:836: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 while (delivering != null && delivering != Thread.currentThread()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'while (delivering != null && !delivering.equals(Thread.currentThread())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 52s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/io/watch/WatchServiceFactory.java:57: warning: [StringCaseLocaleUsage] Specify a `Locale` when calling `String#to{Lower,Upper}Case`. (Note: there are multiple suggested fixes; the third may be most appropriate if you're dealing with ASCII Strings.)
Step #3 - "compile-libfuzzer-coverage-x86_64":         String name = Objects.requireNonNullElse(CachedEnvironment.getProperty("os.name"), "unknown").toLowerCase();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringCaseLocaleUsage)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'name = Objects.requireNonNullElse(CachedEnvironment.getProperty("os.name"), "unknown").toLowerCase(Locale.ROOT);' or 'name = Objects.requireNonNullElse(CachedEnvironment.getProperty("os.name"), "unknown").toLowerCase(Locale.getDefault());' or 'String name = Ascii.toLowerCase(Objects.requireNonNullElse(CachedEnvironment.getProperty("os.name"), "unknown"));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 52s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/cron/CronExpression.java:162: warning: [ImmutableEnumChecker] enums should be immutable: 'CronFieldType' has field 'names' of type 'java.util.List<java.lang.String>', 'List' is mutable
Step #3 - "compile-libfuzzer-coverage-x86_64":         final List<String> names;
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ImmutableEnumChecker)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 52s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/cron/CronExpression.java:197: warning: [StringSplitter] String.split(String) has surprising behavior
Step #3 - "compile-libfuzzer-coverage-x86_64":         final String[] parts = expr.split("\\s+"); //$NON-NLS-1$
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringSplitter)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'final List<String> parts = Splitter.on(Pattern.compile("\\s+")).splitToList(expr);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/cron/CronExpression.java:307: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @since 3.1.0
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the underlying cron expression as string.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/cron/CronExpression.java:371: warning: [StringSplitter] String.split(String) has surprising behavior
Step #3 - "compile-libfuzzer-coverage-x86_64":             String[] rangeParts = fieldExpr.split(",");
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringSplitter)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Iterable<String> rangeParts = Splitter.on(',').split(fieldExpr);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/cron/CronExpression.java:468: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param val  The value
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true/False if the value matches the field part.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 52s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/annotation/Schedules.java:36: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link Scheduled} instances
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link Scheduled} instances.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/annotation/Scheduled.java:45: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The CRON expression
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the CRON expression.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/annotation/Scheduled.java:81: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of a {@link jakarta.inject.Named} bean that is a
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of a {@link jakarta.inject.Named} bean that is a'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/annotation/ExecuteOn.java:42: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of a configured executor service.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.micronaut.scheduling.TaskExecutors#IO}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 52s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE/src/micronaut-core/context/src/main/java/io/micronaut/scheduling/async/AsyncInterceptor.java:95: warning: [RefactorSwitch] This switch can be refactored to be more readable
Step #3 - "compile-libfuzzer-coverage-x86_64":             switch (interceptedMethod.resultType()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/RefactorSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return switch (interceptedMethod.resultType()) {' or 'return switch (interceptedMethod.resultType()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/async/AsyncInterceptor.java:110: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         executorService.submit(() -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = executorService.submit(() -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/LoomSupport.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Always true
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns always true.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/LoomSupport.java:60: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param namePrefix      The thread name prefix, followed by a counter starting at 1
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a factory of virtual threads.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/LoomSupport.java:74: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name            The thread name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns an unstarted virtual thread.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/LoomSupport.java:89: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param threadFactory The thread factory
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns an executor starting a thread per task.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/context/src/main/java/io/micronaut/scheduling/LoomSupport.java:97: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param namePrefix The thread name prefix, followed by a counter starting at 1
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a factory of virtual threads.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 52s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE│██████████▌····│ 70% EXECUTING [5m 53s]Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▌····│ 70% EXECUTING [5m 53s]> IDLE> :micronaut-core:micronaut-context:compileJava> IDLE> IDLE> :micronaut-core:micronaut-context:compileJava > Packing build cache entry│██████████▊····│ 71% EXECUTING [5m 54s]> :micronaut-core:micronaut-context-propagation:kaptGenerateStubsKotlin > Resol> :micronaut-core:micronaut-context-propagation:kaptGenerateStubsKotlin > Resol> IDLE> :micronaut-core:micronaut-context-propagation:kaptGenerateStubsKotlin > Resol> :micronaut-core:micronaut-context-propagation:kaptGenerateStubsKotlin > Resol> IDLE> IDLE> :micronaut-core:micronaut-context-propagation:kaptGenerateStubsKotlin│██████████▊····│ 71% EXECUTING [5m 55s]> :micronaut-core:micronaut-buffer-netty:compileJava│██████████▊····│ 72% EXECUTING [5m 55s]> IDLE│██████████▊····│ 72% EXECUTING [5m 56s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-buffer-netty:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:30: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param numHeapArenas The number of heap arenas
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:35: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param numDirectArenas The number of direct arenas
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:40: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param pageSize The page size
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:45: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param maxOrder The max order
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:50: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param chunkSize The chunk size
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:55: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param smallCacheSize The small cache size
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:60: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param normalCacheSize The normal cache size
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:65: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param useCacheForAllThreads Whether to use the cache for all threads
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:70: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param maxCachedBufferCapacity The max cached buffer capacity
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:75: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param cacheTrimInterval The cache trim interval
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/ByteBufAllocatorConfiguration.java:80: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param maxCachedByteBuffersPerChunk The max cached byte buffers per chunk
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/NettyByteBuffer.java:184: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param byteBufs The {@link ByteBuf}s
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link ByteBuffer}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▊····│ 72% EXECUTING [5m 57s]> IDLE> IDLE> :micronaut-core:micronaut-buffer-netty:compileJava> IDLE/src/micronaut-core/buffer-netty/src/main/java/io/micronaut/buffer/netty/NettyReadBufferFactory.java:83: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         ByteBuf byteBuf = charset == StandardCharsets.UTF_8 ?
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'ByteBuf byteBuf = Objects.equals(charset, StandardCharsets.UTF_8) ?' or 'ByteBuf byteBuf = charset.equals(StandardCharsets.UTF_8) ?'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▊····│ 72% EXECUTING [5m 57s]> IDLE> IDLE> :micronaut-core:micronaut-buffer-netty:compileJava> IDLE13 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████▊····│ 72% EXECUTING [5m 57s]> IDLE> IDLE> :micronaut-core:micronaut-buffer-netty:compileJava> IDLE│██████████▉····│ 72% EXECUTING [5m 57s]> :micronaut-core:micronaut-context-propagation:kaptKotlin > Resolve files of c> :micronaut-core:micronaut-context-propagation:kaptKotlin > Resolve files of c> :micronaut-core:micronaut-context-propagation:kaptKotlin > Resolve files of c> IDLE> :micronaut-core:micronaut-context-propagation:kaptKotlin > Resolve files of c> IDLE> :micronaut-core:micronaut-context-propagation:kaptKotlin > Resolve files of c│██████████▉····│ 72% EXECUTING [5m 58s]> IDLE> IDLE> :micronaut-core:micronaut-context-propagation:kaptKotlin> :micronaut-core:micronaut-context-propagation:kaptKotlin > Requesting from re│███████████····│ 74% EXECUTING [5m 58s]> :micronaut-core:micronaut-context-propagation:kaptKotlin> :micronaut-core:micronaut-retry:compileJava│███████████····│ 74% EXECUTING [5m 59s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-context-propagation:kaptKotlin
Step #3 - "compile-libfuzzer-coverage-x86_64": [WARN] Incremental annotation processing requested, but support is disabled because the following processors are not incremental: io.micronaut.annotation.processing.MixinVisitorProcessor (DYNAMIC), io.micronaut.annotation.processing.PackageElementVisitorProcessor (DYNAMIC), io.micronaut.annotation.processing.TypeElementVisitorProcessor (DYNAMIC), io.micronaut.annotation.processing.AggregatingTypeElementVisitorProcessor (DYNAMIC), io.micronaut.annotation.processing.BeanDefinitionInjectProcessor (DYNAMIC).
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [5m 59s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE│███████████▏···│ 74% EXECUTING [6m]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-retry:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:79: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the circuit breaker
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the circuit breaker.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:86: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The maximum number of attempts of an operation of {@link CircuitBreakerRegistry#circuitBreaker(String)}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the maximum number of attempts of an operation of {@link CircuitBreakerRegistry#circuitBreaker(String)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:93: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param attempts The maximum number of attempts, default 3
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:100: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The delay between attempts
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the delay between attempts.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:107: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param delay The delay between attempts, default 500ms
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:114: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The maximum overall delay
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the maximum overall delay.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:121: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param maxDelay The maximum overall delay, default 5s
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:128: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The multiplier of the delay
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the multiplier of the delay.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:135: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param multiplier The multiplier of the delay, default 0
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:142: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The jitter factor of the delay
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the jitter factor of the delay.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:149: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param jitter The jitter factor of the delay, default 0
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:156: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The time the circuit stays open before it half-opens
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the time the circuit stays open before it half-opens.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:163: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param reset The time the circuit stays open before it half-opens, default 20s
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:170: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the error of an open circuit is wrapped in a {@link io.micronaut.retry.exception.CircuitOpenException}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the error of an open circuit is wrapped in a {@link io.micronaut.retry.exception.CircuitOpenException}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:177: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param throwWrappedException Whether the error of an open circuit is wrapped, default false
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:184: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The size of the rolling window, if the circuit has one
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:192: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param requestVolumeThreshold The number of calls of the rolling window, see
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:202: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The ratio of failures that opens the circuit
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:210: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param failureRatio The ratio of failures of a full window that opens the circuit, default 0.5
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:218: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The number of trial calls of a half-open circuit
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:226: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param successThreshold The number of trial calls of a half-open circuit, which all succeed
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:235: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The class names of the exceptions that count as a failure
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:243: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param failOn The class names of the exceptions that count as a failure, default every
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:252: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The class names of the exceptions that count as a success
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:260: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param skipOn The class names of the exceptions that count as a success, whatever failOn
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:269: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The policy of the configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedCircuitBreakerConfiguration.java:281: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The rolling window of the configuration, or {@code null} if none of its settings is set
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerWindow.java:102: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param failure An exception of a call
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether it counts as a failure.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerWindow.java:123: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The number of failures of a full window that opens the circuit, at least 1
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the number of failures of a full window that opens the circuit, at least 1.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerWindow.java:144: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param requestVolumeThreshold The number of calls of the window, at least 1, default 20,
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerWindow.java:154: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param failureRatio The ratio of failures of a full window that opens the circuit,
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerWindow.java:164: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param successThreshold The number of trial calls of a half-open circuit, which all
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerWindow.java:175: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param failOn The exceptions that count as a failure, default every one, see
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerWindow.java:186: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param skipOn The exceptions that count as a success, see {@link CircuitBreakerWindow#skipOn()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerWindow.java:196: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The window
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 1s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerGuard.java:48: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the circuit breaker
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the circuit breaker.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerGuard.java:53: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The state of the circuit: an open circuit whose reset timeout elapsed is
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the state of the circuit: an open circuit whose reset timeout elapsed is'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 1s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/annotation/CircuitBreaker.java:158: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The ratio of failures of a full window that opens the circuit, between 0 and 1,
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/annotation/CircuitBreaker.java:166: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The number of trial calls of a half-open circuit with a rolling window, which all
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/annotation/CircuitBreaker.java:174: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The exceptions that count as a failure of a circuit with a rolling window, default
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/annotation/CircuitBreaker.java:182: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The exceptions that count as a success of a circuit with a rolling window, whatever
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 1s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/RecoveryInterceptor.java:161: warning: [BooleanLiteral] This expression can be written more clearly with a boolean literal.
Step #3 - "compile-libfuzzer-coverage-x86_64":         context.setAttribute(FALLBACK_NOT_FOUND, Boolean.TRUE);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/BooleanLiteral)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'context.setAttribute(FALLBACK_NOT_FOUND, true);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/RecoveryInterceptor.java:184: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                             resultingFuture.whenComplete((o1, throwable1) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'resultingFuture = resultingFuture.whenComplete((o1, throwable1) -> {' or 'var unused = resultingFuture.whenComplete((o1, throwable1) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 1s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/DefaultRetryInterceptor.java:161: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return How many circuit breaker methods hold a circuit
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns how many circuit breaker methods hold a circuit.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/DefaultRetryInterceptor.java:233: warning: [RefactorSwitch] This switch can be refactored to be more readable
Step #3 - "compile-libfuzzer-coverage-x86_64":             switch (interceptedMethod.resultType()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/RefactorSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return switch (interceptedMethod.resultType()) {' or 'return switch (interceptedMethod.resultType()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 1s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:253: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The circuit of this state
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:261: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the error of an open circuit is wrapped in a {@link CircuitOpenException}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:533: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The time the circuit stays open before it half-opens, in millis
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the time the circuit stays open before it half-opens, in millis.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:540: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The rolling window of the circuit, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the rolling window of the circuit, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 1s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:547: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The state of the circuit, as it was last changed: an open circuit whose timeout
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the state of the circuit, as it was last changed: an open circuit whose timeout'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:556: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether the circuit has been open for longer than its timeout
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the circuit has been open for longer than its timeout.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:563: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param name The name of the circuit
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the state and the counters of the circuit: an open circuit whose timeout'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:589: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The state of a circuit with a window: half-open once the timeout of an open
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the state of a circuit with a window: half-open once the timeout of an open'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/CircuitBreakerRetry.java:596: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":                 || current == CircuitState.HALF_OPEN && trials >= Objects.requireNonNull(window).successThreshold();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '|| (current == CircuitState.HALF_OPEN && trials >= Objects.requireNonNull(window).successThreshold());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 1s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/DefaultRetryRunner.java:155: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":                     if (signalType == SignalType.ON_COMPLETE || signalType == SignalType.CANCEL && emitted.get()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (signalType == SignalType.ON_COMPLETE || (signalType == SignalType.CANCEL && emitted.get())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/DefaultRetryRunner.java:246: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             future.whenComplete((value, exception) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'future = future.whenComplete((value, exception) -> {' or 'var unused = future.whenComplete((value, exception) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 1s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/RetryRegistry.java:36: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/RetryRegistry.java:43: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/RetryRegistry.java:66: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The names of the configured policies
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the names of the configured policies.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/NamedCircuits.java:74: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the configuration of the name, if any.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/NamedCircuits.java:82: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the policy of the configuration of the name, or of the defaults of a configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/NamedCircuits.java:90: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the rolling window of the configuration of the name, if it has one.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/NamedCircuits.java:103: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the circuit of the name, if it exists.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/NamedCircuits.java:112: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The names of the configured circuits and of the circuits in use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the names of the configured circuits and of the circuits in use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/NamedCircuits.java:142: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             boolean conflict = declaresReset && !configured.getResetTimeout().equals(policy.getResetTimeout())
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'boolean conflict = (declaresReset && !configured.getResetTimeout().equals(policy.getResetTimeout()))'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/NamedCircuits.java:143: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":                 || window != null && !window.equals(configuredWindow);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '|| (window != null && !window.equals(configuredWindow));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 2s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java:116: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             .maxAttempts(explicit.containsKey(ATTEMPTS) ? retry.intValue(ATTEMPTS).orElse(DEFAULT_RETRY_ATTEMPTS) : namedPolicy.maxAttempts())
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java:117: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             .delay(explicit.containsKey(DELAY) ? retry.get(DELAY, Duration.class).orElse(namedPolicy.delay()) : namedPolicy.delay())
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java:118: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             .maxDelay(explicit.containsKey(MAX_DELAY) ? retry.get(MAX_DELAY, Duration.class).orElse(null) : namedPolicy.maxDelay())
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java:119: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             .multiplier(explicit.containsKey(MULTIPLIER) ? retry.get(MULTIPLIER, Double.class).orElse(namedPolicy.multiplier()) : namedPolicy.multiplier())
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java:120: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             .jitter(explicit.containsKey(JITTER) ? retry.get(JITTER, Double.class).orElse(namedPolicy.jitter()) : namedPolicy.jitter())
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java:122: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (explicit.containsKey(INCLUDES) || explicit.containsKey(VALUE)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java:122: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (explicit.containsKey(INCLUDES) || explicit.containsKey(VALUE)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/AnnotationRetryStateBuilder.java:127: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (explicit.containsKey(EXCLUDES)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 2s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/intercept/SimpleRetry.java:195: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":         long delay = (long) ((getDelay().toMillis()) * pow(multiplier, attemptNumber.get() - 1));
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'long delay = (long) ( getDelay().toMillis() * pow(multiplier, attemptNumber.get() - 1));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 2s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerRegistry.java:97: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the state of the circuit of the name, if it exists.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerRegistry.java:103: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the state and the counters of the circuit of the name, if it exists, e.g. for an'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/CircuitBreakerRegistry.java:110: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The names of the circuits that exist: the configured ones and the ones in use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the names of the circuits that exist: the configured ones and the ones in use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:75: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the retry policy
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the retry policy.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:82: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The maximum number of retries, after the first call
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the maximum number of retries, after the first call.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:89: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param attempts The maximum number of retries, after the first call, default 3; e.g. 1
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:97: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The delay between attempts
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the delay between attempts.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:104: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param delay The delay between attempts, default 1s
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:111: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The maximum overall delay
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the maximum overall delay.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:118: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param maxDelay The maximum overall delay, default none
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:125: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The multiplier of the delay
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the multiplier of the delay.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:132: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param multiplier The multiplier of the delay, default 1.0
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:139: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The jitter factor of the delay
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the jitter factor of the delay.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:146: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param jitter The jitter factor of the delay, between 0 and 1, default 0
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:153: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The fully qualified names of the exception types to retry, all if empty
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the fully qualified names of the exception types to retry, all if empty.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 2s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:170: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The fully qualified names of the exception types not to retry
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the fully qualified names of the exception types not to retry.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/retry/src/main/java/io/micronaut/retry/NamedRetryPolicyConfiguration.java:187: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The policy of the configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▏···│ 74% EXECUTING [6m 2s]> :micronaut-core:micronaut-retry:compileJava> IDLE> IDLE> IDLENote: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 92 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▎···│ 75% EXECUTING [6m 2s]> IDLE> IDLE> IDLE> IDLE> :micronaut-core:micronaut-context-propagation:compileJava│███████████▎···│ 75% EXECUTING [6m 3s]│███████████▎···│ 75% EXECUTING [6m 4s]│███████████▌···│ 77% EXECUTING [6m 4s]> :micronaut-core:micronaut-http:compileKotlin > Resolve files of configuration> :micronaut-core:micronaut-http:compileKotlin > Resolve files of configuration> IDLE> :micronaut-core:micronaut-http:compileKotlin> :micronaut-core:micronaut-http:compileKotlin > Requesting from remote build c│███████████▊···│ 78% EXECUTING [6m 4s]> :micronaut-core:micronaut-http:compileKotlin│███████████▊···│ 78% EXECUTING [6m 5s]│███████████▊···│ 78% EXECUTING [6m 6s]│███████████▊···│ 78% EXECUTING [6m 7s]> :micronaut-core:micronaut-http:compileJava > Requesting from remote build cac> :micronaut-core:micronaut-http:compileJava│███████████▊···│ 78% EXECUTING [6m 8s]│███████████▊···│ 78% EXECUTING [6m 9s]│███████████▊···│ 78% EXECUTING [6m 10s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-http:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:113: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return getAttribute(HttpAttributes.PRINCIPAL, Principal.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:113: warning: [removal] PRINCIPAL in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return getAttribute(HttpAttributes.PRINCIPAL, Principal.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:125: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return getAttribute(HttpAttributes.PRINCIPAL, principalType);
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:125: warning: [removal] PRINCIPAL in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return getAttribute(HttpAttributes.PRINCIPAL, principalType);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:136: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             setAttribute(HttpAttributes.PRINCIPAL, principal);
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:136: warning: [removal] PRINCIPAL in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             setAttribute(HttpAttributes.PRINCIPAL, principal);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:138: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             removeAttribute(HttpAttributes.PRINCIPAL, Principal.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:138: warning: [removal] PRINCIPAL in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             removeAttribute(HttpAttributes.PRINCIPAL, Principal.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:198: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         Optional<Certificate> attribute = this.getAttribute(HttpAttributes.X509_CERTIFICATE, Certificate.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:198: warning: [removal] X509_CERTIFICATE in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         Optional<Certificate> attribute = this.getAttribute(HttpAttributes.X509_CERTIFICATE, Certificate.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMessage.java:71: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return (Optional) getAttribute(HttpAttributes.MESSAGE_BODY_WRITER, MessageBodyWriter.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMessage.java:71: warning: [removal] MESSAGE_BODY_WRITER in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return (Optional) getAttribute(HttpAttributes.MESSAGE_BODY_WRITER, MessageBodyWriter.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MutableHttpMessage.java:40: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         setAttribute(HttpAttributes.MESSAGE_BODY_WRITER, messageBodyWriter);
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MutableHttpMessage.java:40: warning: [removal] MESSAGE_BODY_WRITER in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         setAttribute(HttpAttributes.MESSAGE_BODY_WRITER, messageBodyWriter);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 10s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/codec/MediaTypeCodecRegistry.java:63: warning: [removal] DefaultMediaTypeCodecRegistry in io.micronaut.http.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return new DefaultMediaTypeCodecRegistry(codecs);
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/codec/MediaTypeCodecRegistry.java:73: warning: [removal] DefaultMediaTypeCodecRegistry in io.micronaut.http.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return new DefaultMediaTypeCodecRegistry(codecs);
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 10s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/body/stream/InputStreamByteBody.java:68: warning: [dep-ann] deprecated item is not annotated with @Deprecated
Step #3 - "compile-libfuzzer-coverage-x86_64":     public static CloseableByteBody create(InputStream stream, OptionalLong length, Executor ioExecutor, ByteBufferFactory<?, ?> bufferFactory) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 10s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE│███████████▊···│ 78% EXECUTING [6m 11s]/src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:53: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link Cookies} instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link Cookies} instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:58: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The HTTP parameters contained with the URI query string
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the HTTP parameters contained with the URI query string.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:63: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The request method
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the request method.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 11s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:68: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The full request URI
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the full request URI.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:83: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The http version of the request.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the http version of the request.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:100: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the method (same as {@link HttpMethod} value for standard http methods).
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Returns the name of the method (same as {@link HttpMethod} value for standard http methods).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 11s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:143: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Get the raw, percent-encoded path without any parameters
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns get the raw, percent-encoded path without any parameters.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:150: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Obtain the remote address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns obtain the remote address.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:157: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Obtain the server address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns obtain the server address.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:166: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The server host name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the server host name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpRequest.java:174: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the request an HTTPS request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is the request an HTTPS request.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 11s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMessage.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link HttpHeaders} object
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link HttpHeaders} object.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMessage.java:61: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The request body
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the request body.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMessage.java:66: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The body writer.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMessage.java:75: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The request character encoding. Defaults to {@link StandardCharsets#UTF_8}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the request character encoding. Defaults to {@link StandardCharsets#UTF_8}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMessage.java:123: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The locale of the message
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the locale of the message.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMessage.java:131: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of the Content-Length header or -1L if none specified
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the value of the Content-Length header or -1L if none specified.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookies.java:34: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A set of the cookies
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a set of the cookies.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookies.java:60: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":             .map((Cookie::getName))
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '.map( Cookie::getName)'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 11s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:41: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see <a href="https://tools.ietf.org/html/rfc6265#section-4.1.1">The Secure Attribute</a>.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link <a href="https:'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see <a href="https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.6">The HttpOnly Attribute</a>.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link <a href="https:'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:56: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see <a href="https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.3">The Domain Attribute</a>
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link <a href="https:'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:61: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see <a href="https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.4">The Path Attribute</a>.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link <a href="https:'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:66: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see <a href="https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.1">The Expires Attribute</a>.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link <a href="https:'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:71: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see <a href="https://datatracker.ietf.org/doc/html/rfc6265#section-5.2.2">The Max-Age Attribute</a>
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link <a href="https:'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:76: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the cookie
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the cookie.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:81: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of the cookie
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the value of the cookie.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/Cookie.java:113: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the cookie is secure
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the cookie is secure.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMethod.java:115: warning: [AmbiguousMethodReference] This method's reference is ambiguous, its name and functional interface type are the same as: requiresRequestBody(HttpMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean requiresRequestBody() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AmbiguousMethodReference)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMethod.java:125: warning: [AmbiguousMethodReference] This method's reference is ambiguous, its name and functional interface type are the same as: permitsRequestBody(HttpMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean permitsRequestBody() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AmbiguousMethodReference)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 11s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMethod.java:178: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param httpMethodName Name of the http method (maybe nonstandard)
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Returns the value of enum (CUSTOM by default).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMethod.java:186: warning: [StringCaseLocaleUsage] Specify a `Locale` when calling `String#to{Lower,Upper}Case`. (Note: there are multiple suggested fixes; the third may be most appropriate if you're dealing with ASCII Strings.)
Step #3 - "compile-libfuzzer-coverage-x86_64":         httpMethodName = httpMethodName.toUpperCase();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringCaseLocaleUsage)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'httpMethodName = httpMethodName.toUpperCase(Locale.ROOT);' or 'httpMethodName = httpMethodName.toUpperCase(Locale.getDefault());' or 'httpMethodName = Ascii.toUpperCase(httpMethodName);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpMethod.java:195: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (httpMethodName) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return switch (httpMethodName) {' or 'switch (httpMethodName) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 11s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/MutableHttpMessage.java:100: warning: [DefaultCharset] Implicit use of the platform default charset, which can result in differing behaviour between JVM executions or incorrect behavior if the encoding of the data source doesn't match expectations.
Step #3 - "compile-libfuzzer-coverage-x86_64":         value.append(new String(Base64.getEncoder().encode(sb.toString().getBytes())));
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DefaultCharset)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'value.append(new String(Base64.getEncoder().encode(sb.toString().getBytes()), UTF_8));' or 'value.append(new String(Base64.getEncoder().encode(sb.toString().getBytes()), Charset.defaultCharset()));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MutableHttpMessage.java:100: warning: [DefaultCharset] Implicit use of the platform default charset, which can result in differing behaviour between JVM executions or incorrect behavior if the encoding of the data source doesn't match expectations.
Step #3 - "compile-libfuzzer-coverage-x86_64":         value.append(new String(Base64.getEncoder().encode(sb.toString().getBytes())));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DefaultCharset)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'value.append(new String(Base64.getEncoder().encode(sb.toString().getBytes(UTF_8))));' or 'value.append(new String(Base64.getEncoder().encode(sb.toString().getBytes(Charset.defaultCharset()))));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 12s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:215: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see <a href="https://datatracker.ietf.org/doc/html/rfc6902/">JSON Patch</a>
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link <a href="https:'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:226: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see <a href="https://datatracker.ietf.org/doc/html/rfc7386">JSON Merge Patch</a>
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link <a href="https:'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 12s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1086: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (expectedContentType == this) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (expectedContentType.equals(this)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1134: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the mime type without any parameters
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the mime type without any parameters.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1141: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type of the media type. For example for application/hal+json this would return "application"
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type of the media type. For example for application/hal+json this would return "application".'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1148: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The subtype. For example for application/hal+json this would return "hal+json"
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the subtype. For example for application/hal+json this would return "hal+json".'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1155: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The extension. For example for application/hal+json this would return "json"
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the extension. For example for application/hal+json this would return "json".'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1162: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The parameters of the media type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the parameters of the media type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1169: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The parameters map of the media type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 12s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1180: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The quality of the Mime type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the quality of the Mime type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1187: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The quality in BigDecimal form
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the quality in BigDecimal form.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1195: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The version of the Mime type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the version of the Mime type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1198: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         return parameters.getOrDefault(V_PARAMETER, null);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1202: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The charset of the media type if specified
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the charset of the media type if specified.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1205: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         String charset = parameters.get(CHARSET_PARAMETER);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1252: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the media type is text based
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the media type is text based.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1280: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param contentType The content type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the content type is text based.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1335: warning: [EqualsGetClass] Prefer instanceof to getClass when implementing Object#equals. Note that this may be a behaviour change.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean equals(Object o) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EqualsGetClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof MediaType)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1383: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":                 } catch (IllegalArgumentException ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 12s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/MediaType.java:1703: warning: [StringSplitter] String.split(String) has surprising behavior
Step #3 - "compile-libfuzzer-coverage-x86_64":                 String[] tokens = formattedLine.split("\\|");
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringSplitter)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'List<String> tokens = Splitter.on('|').splitToList(formattedLine);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 12s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/HttpHeaders.java:832: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the {@link HttpHeaders#CONNECTION} header is set to Keep-Alive
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the {@link HttpHeaders#CONNECTION} header is set to Keep-Alive.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 12s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/HttpHeaders.java:840: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link #ORIGIN} header
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link #ORIGIN} header.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpHeaders.java:847: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link #AUTHORIZATION} header
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link #AUTHORIZATION} header.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpHeaders.java:854: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link #CONTENT_TYPE} header
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link #CONTENT_TYPE} header.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/MutableHttpHeaders.java:199: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":         sb.append(Base64.getEncoder().encodeToString((userInfo).getBytes(StandardCharsets.ISO_8859_1)));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'sb.append(Base64.getEncoder().encodeToString( userInfo.getBytes(StandardCharsets.ISO_8859_1)));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 12s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/CookieConfiguration.java:29: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the cookie
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the cookie.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/CookieConfiguration.java:55: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the cookie is secure
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the cookie is secure.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/CookieConfiguration.java:60: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The max age to use for the cookie
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the max age to use for the cookie.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/cookie/CookieConfiguration.java:65: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return return the SameSite to use for the cookie.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns return the SameSite to use for the cookie.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 12s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/runtime/http/scope/RequestScope.java:34: warning: [InjectScopeAnnotationOnInterfaceOrAbstractClass] Scope annotation on an interface or abstract class is not allowed
Step #3 - "compile-libfuzzer-coverage-x86_64": @ScopedProxy
Step #3 - "compile-libfuzzer-coverage-x86_64": ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InjectScopeAnnotationOnInterfaceOrAbstractClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/codec/MediaTypeCodec.java:42: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The media type of the codec
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the media type of the codec.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 13s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/codec/CodecConfiguration.java:45: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Media types in addition to the default that the codec should process
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns media types in addition to the default that the codec should process.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/runtime/http/codec/MediaTypeCodecRegistryFactory.java:38: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param codecs List of codecs for media types
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a bean for default codecs registry.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/codec/MediaTypeCodecRegistry.java:52: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The available codecs
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the available codecs.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 13s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/uri/UriMatchInfo.java:30: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The matched URI
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the matched URI.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/uri/UriMatchInfo.java:35: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The variable values following a successful match
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the variable values following a successful match.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/uri/UriMatchInfo.java:40: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The list of template variables
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the list of template variables.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/uri/UriMatchInfo.java:45: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A map of the variables.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a map of the variables.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/uri/UriMatchVariable.java:48: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The variable name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the variable name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/uri/UriMatchVariable.java:55: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the variable is exploded
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the variable is exploded.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/uri/UriMatchVariable.java:62: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return true if the variable part of a query.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the variable part of a query.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/uri/UriMatchVariable.java:83: warning: [PatternMatchingInstanceof] This code can be simplified to use a pattern-matching instanceof.
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (!(o instanceof UriMatchVariable)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/PatternMatchingInstanceof)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof UriMatchVariable that)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 13s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/HttpResponse.java:38: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The current status
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the current status'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpResponse.java:64: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The body or null
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the body or null.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpResponse.java:71: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The HTTP status
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the HTTP status'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpResponse.java:79: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The response status code
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the response status code.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http/src/main/java/io/micronaut/http/HttpResponse.java:84: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The HTTP status reason phrase
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the HTTP status reason phrase.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 13s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE/src/micronaut-core/http/src/main/java/io/micronaut/http/body/ByteBody.java:227: warning: [NotJavadoc] This element has multiple Javadoc comments; only the last one will be used.
Step #3 - "compile-libfuzzer-coverage-x86_64":     /**
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NotJavadoc)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 13s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE│███████████▊···│ 78% EXECUTING [6m 14s]│███████████▊···│ 78% EXECUTING [6m 15s]│███████████▊···│ 78% EXECUTING [6m 16s]│███████████▊···│ 78% EXECUTING [6m 17s]│███████████▊···│ 78% EXECUTING [6m 18s]│███████████▊···│ 78% EXECUTING [6m 19s]│███████████▊···│ 78% EXECUTING [6m 20s]│███████████▊···│ 78% EXECUTING [6m 21s]│███████████▊···│ 78% EXECUTING [6m 22s]Note: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files additionally use or override a deprecated API that is marked for removal.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████▊···│ 78% EXECUTING [6m 22s]> IDLE> :micronaut-core:micronaut-http:compileJava> IDLE> IDLE> :micronaut-core:micronaut-http:compileJava > Packing build cache entry│████████████···│ 80% EXECUTING [6m 22s]> :micronaut-core:micronaut-http:jar> :micronaut-core:micronaut-json-core:compileJava > Requesting from remote buil> :micronaut-core:micronaut-json-core:compileJava│████████████···│ 80% EXECUTING [6m 23s]│████████████···│ 80% EXECUTING [6m 24s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-json-core:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/codec/JsonStreamMediaTypeCodec.java:46: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonStreamMediaTypeCodec extends JsonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/codec/JsonStreamMediaTypeCodec.java:46: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonStreamMediaTypeCodec extends JsonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/codec/JsonStreamMediaTypeCodec.java:46: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonStreamMediaTypeCodec extends JsonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/codec/JsonStreamMediaTypeCodec.java:46: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonStreamMediaTypeCodec extends JsonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:81: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The singleton node representing {@code null}.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the singleton node representing {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:88: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param nodes The nodes in this array. Must not be modified after this method is called.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the immutable array node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:97: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param nodes The nodes in this object. Must not be modified after this method is called.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the immutable array node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:106: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param value The value of the node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a json node representing the given boolean value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:114: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param value The value of the node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a json node representing the given string value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:135: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param value The value of the node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a json node representing the given numeric value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:143: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param value The value of the node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a json node representing the given numeric value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:151: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param value The value of the node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a json node representing the given numeric value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:159: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param value The value of the node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a json node representing the given numeric value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:167: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param value The value of the node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a json node representing the given numeric value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:175: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param value The value of the node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a json node representing the given numeric value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:192: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} iff this is a number node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} iff this is a number node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:199: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The raw numeric value of this node. Always full precision.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:207: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of this number node, converted to {@code int}. May lose precision.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:215: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of this number node, converted to {@code long}. May lose precision.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:223: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of this number node, converted to {@code float}. May lose precision.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:231: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of this number node, converted to {@code double}. May lose precision.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:239: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of this number node, converted to {@link BigInteger}. May lose the decimal part.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:254: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of this number node, converted to {@link BigDecimal}.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:272: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} iff this is a string node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} iff this is a string node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:279: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of this string node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:297: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} iff this is a boolean node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} iff this is a boolean node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:304: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The value of this boolean node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:312: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} iff this is the null node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} iff this is the null node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:319: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The number of immediate children of this node, or {@code 0} if this is not a container node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the number of immediate children of this node, or {@code 0} if this is not a container node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:324: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return An {@link Iterable} of all values of this array or object node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:330: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return An {@link Iterable} of all entries of this object node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:336: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} iff this node is a value node (string, number, boolean, null).
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} iff this node is a value node (string, number, boolean, null).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:343: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} iff this node is a container node (array or object).
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} iff this node is a container node (array or object).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:350: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} iff this node is an array node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} iff this node is an array node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:357: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} iff this node is an object node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} iff this node is an object node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:364: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param fieldName The field name.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the field with the given name, or {@code null} if there is no such field or this is not an object.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/tree/JsonNode.java:371: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param index The index into this array.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the field at the given index, or {@code null} if there is no such field or this is not an array.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 24s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE/src/micronaut-core/json-core/src/main/java/io/micronaut/json/JsonMapper.java:407: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The configured stream config.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the configured stream config.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 24s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE/src/micronaut-core/json-core/src/main/java/io/micronaut/json/JsonStreamConfig.java:42: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether {@link java.math.BigDecimal}s should be used for parsing floating-point json numbers.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether {@link java.math.BigDecimal}s should be used for parsing floating-point json numbers.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/JsonStreamConfig.java:61: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether {@link java.math.BigInteger}s should be used for parsing integer json numbers.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether {@link java.math.BigInteger}s should be used for parsing integer json numbers.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/JsonStreamConfig.java:68: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param useBigIntegerForInts The new value for {@link #useBigIntegerForInts}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a copy of this config instance, with {@link #useBigIntegerForInts} set to the new value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 25s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE/src/micronaut-core/json-core/src/main/java/io/micronaut/json/JsonConfiguration.java:37: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The array size threshold to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the array size threshold to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/body/JsonCounter.java:357: warning: [UnusedVariable] The parameter 'b' is never read.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private void handleEscape(byte b) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedVariable)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'handleEscape();'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 25s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE/src/micronaut-core/json-core/src/main/java/io/micronaut/json/body/JsonCounter.java:390: warning: [ShortCircuitBoolean] Prefer the short-circuiting boolean operators && and || to & and |.
Step #3 - "compile-libfuzzer-coverage-x86_64":         return (b != '"') & (b != '{') & (b != '[') & (b != ']') & (b != '}');
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ShortCircuitBoolean)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return (b != '"') && (b != '{') && (b != '[') && (b != ']') && (b != '}');'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 25s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE/src/micronaut-core/json-core/src/main/java/io/micronaut/json/body/JsonMessageHandler.java:137: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The releaser of the buffers of the runtime, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the releaser of the buffers of the runtime, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 25s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE/src/micronaut-core/json-core/src/main/java/io/micronaut/json/body/JsonMessageHandler.java:190: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         return type == specificType ? specificMapper : jsonMapper;
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return Objects.equals(type, specificType) ? specificMapper : jsonMapper;' or 'return type.equals(specificType) ? specificMapper : jsonMapper;'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 25s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE/src/micronaut-core/json-core/src/main/java/io/micronaut/json/body/JsonPieceWriter.java:86: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (bytes == null || separator != lastSeparator) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (bytes == null || !Objects.equals(separator, lastSeparator)) {' or 'if (bytes == null || !separator.equals(lastSeparator)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 25s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE/src/micronaut-core/json-core/src/main/java/io/micronaut/json/body/JsonChunkedProcessor.java:259: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (bytes == scratch) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(bytes, scratch)) {' or 'if (bytes.equals(scratch)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 25s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE│████████████···│ 80% EXECUTING [6m 26s]/src/micronaut-core/json-core/src/main/java/io/micronaut/json/codec/MapperMediaTypeCodec.java:126: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The object mapper
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the object mapper.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/json-core/src/main/java/io/micronaut/json/codec/MapperMediaTypeCodec.java:169: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":         return !(CharSequence.class.isAssignableFrom(type));
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return ! CharSequence.class.isAssignableFrom(type);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 26s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLENote: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 50 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████···│ 80% EXECUTING [6m 26s]> IDLE> :micronaut-core:micronaut-json-core:compileJava> IDLE> IDLE│████████████▎··│ 82% EXECUTING [6m 26s]> :micronaut-core:micronaut-jackson-core:compileJava > Requesting from remote b> :micronaut-core:micronaut-jackson-core:compileJava│████████████▎··│ 82% EXECUTING [6m 27s]│████████████▎··│ 82% EXECUTING [6m 28s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-jackson-core:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/env/JsonPropertySourceLoader.java:68: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param input The input stream
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/env/EnvJsonPropertySourceLoader.java:68: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The JSON as input stream stored in the environment variables
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the JSON as input stream stored in the environment variables'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/env/EnvJsonPropertySourceLoader.java:82: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The JSON stored in the environment variables
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the JSON stored in the environment variables'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/JsonNodeTreeCodec.java:50: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default instance, using {@link JsonStreamConfig#DEFAULT}.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default instance, using {@link JsonStreamConfig#DEFAULT}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/JsonNodeTreeCodec.java:57: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param config The stream config to use.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a new codec that will use the given stream config.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/JsonNodeTreeCodec.java:72: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (p.hasCurrentToken() ? p.currentToken() : p.nextToken()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (p.hasCurrentToken() ? p.currentToken() : p.nextToken()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/TreeGenerator.java:249: warning: [UnusedVariable] The parameter 'token' is never read.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private JsonGenerator writeScalar(JsonToken token, JsonNode value) throws StreamWriteException {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedVariable)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'private JsonGenerator writeScalar(JsonNode value) throws StreamWriteException {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/TreeGenerator.java:159: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether this generator has visited a complete node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether this generator has visited a complete node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/TreeGenerator.java:166: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The completed node.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▎··│ 82% EXECUTING [6m 28s]> IDLE> :micronaut-core:micronaut-jackson-core:compileJava> IDLE> IDLE/src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/JsonNodeTraversingParser.java:401: warning: [UnusedMethod] Method 'setCurrentName' is never used.
Step #3 - "compile-libfuzzer-coverage-x86_64":         abstract void setCurrentName(String currentName);
Step #3 - "compile-libfuzzer-coverage-x86_64":                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▎··│ 82% EXECUTING [6m 28s]> IDLE> :micronaut-core:micronaut-jackson-core:compileJava> IDLE> IDLE/src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/JsonNodeTraversingParser.java:375: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         protected Context createSubContextIfContainer(JsonNode node) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Context createSubContextIfContainer(JsonNode node) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▎··│ 82% EXECUTING [6m 28s]> IDLE> :micronaut-core:micronaut-jackson-core:compileJava> IDLE> IDLE/src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/tree/JsonStreamTransfer.java:80: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (from.currentToken()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (from.currentToken()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/util/EventLoopBufferRecyclerPool.java:85: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether Netty is available, without it this pool always uses the fallback pool
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether Netty is available, without it this pool always uses the fallback pool.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▎··│ 82% EXECUTING [6m 28s]> IDLE> :micronaut-core:micronaut-jackson-core:compileJava> IDLE> IDLE/src/micronaut-core/jackson-core/src/main/java/io/micronaut/jackson/core/parser/JacksonCoreProcessor.java:84: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether more input is needed
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether more input is needed.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▎··│ 82% EXECUTING [6m 28s]> IDLE> :micronaut-core:micronaut-jackson-core:compileJava> IDLE> IDLENote: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 14 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 28s]> :micronaut-core:micronaut-jackson-databind:compileJava > Resolve files of con> :micronaut-core:micronaut-jackson-databind:compileJava > Resolve files of con> IDLE> IDLE│████████████▌··│ 83% EXECUTING [6m 29s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> :micronaut-core:micronaut-jackson-databind:compileJava > Requesting from remo> :micronaut-core:micronaut-jackson-databind:compileJava│████████████▌··│ 83% EXECUTING [6m 30s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-jackson-databind:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:51: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonMediaTypeCodec extends JacksonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:49: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": @Bean(typed = {JsonMediaTypeCodec.class, JacksonMediaTypeCodec.class}) // do not expose MapperMediaTypeCodec
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:51: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonMediaTypeCodec extends JacksonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:49: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": @Bean(typed = {JsonMediaTypeCodec.class, JacksonMediaTypeCodec.class}) // do not expose MapperMediaTypeCodec
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:51: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonMediaTypeCodec extends JacksonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:49: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": @Bean(typed = {JsonMediaTypeCodec.class, JacksonMediaTypeCodec.class}) // do not expose MapperMediaTypeCodec
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:51: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonMediaTypeCodec extends JacksonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:49: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": @Bean(typed = {JsonMediaTypeCodec.class, JacksonMediaTypeCodec.class}) // do not expose MapperMediaTypeCodec
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:92: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public JacksonMediaTypeCodec cloneWithFeatures(JacksonFeatures jacksonFeatures) {
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:92: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public JacksonMediaTypeCodec cloneWithFeatures(JacksonFeatures jacksonFeatures) {
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:92: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public JacksonMediaTypeCodec cloneWithFeatures(JacksonFeatures jacksonFeatures) {
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonMediaTypeCodec.java:92: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public JacksonMediaTypeCodec cloneWithFeatures(JacksonFeatures jacksonFeatures) {
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:52: warning: [removal] JsonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonStreamMediaTypeCodec extends JsonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:50: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": @Bean(typed = {JsonStreamMediaTypeCodec.class, JacksonMediaTypeCodec.class}) // do not expose MapperMediaTypeCodec
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:52: warning: [removal] JsonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonStreamMediaTypeCodec extends JsonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:50: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": @Bean(typed = {JsonStreamMediaTypeCodec.class, JacksonMediaTypeCodec.class}) // do not expose MapperMediaTypeCodec
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:52: warning: [removal] JsonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonStreamMediaTypeCodec extends JsonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:50: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": @Bean(typed = {JsonStreamMediaTypeCodec.class, JacksonMediaTypeCodec.class}) // do not expose MapperMediaTypeCodec
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:52: warning: [removal] JsonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": public class JsonStreamMediaTypeCodec extends JsonMediaTypeCodec {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:50: warning: [removal] JacksonMediaTypeCodec in io.micronaut.jackson.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64": @Bean(typed = {JsonStreamMediaTypeCodec.class, JacksonMediaTypeCodec.class}) // do not expose MapperMediaTypeCodec
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 30s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE│████████████▌··│ 83% EXECUTING [6m 31s]/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/convert/JacksonConverterRegistrar.java:120: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A converter that converts an object to a json node
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a converter that converts an object to a json node.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/convert/JacksonConverterRegistrar.java:135: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A converter that converts object nodes to convertible values
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a converter that converts object nodes to convertible values.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/convert/JacksonConverterRegistrar.java:142: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The JSON node to object converter
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the JSON node to object converter.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 31s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/convert/JacksonConverterRegistrar.java:174: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Converts array nodes to iterables.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns converts array nodes to iterables.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/convert/JacksonConverterRegistrar.java:192: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Converts array nodes to objects.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns converts array nodes to objects.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 31s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/DatabindPropertyBinderExceptionHandler.java:56: warning: [NonCanonicalType] The type `JacksonException.Reference` was referred to by the non-canonical name `DatabindException.Reference`. This may be misleading.
Step #3 - "compile-libfuzzer-coverage-x86_64":             List<DatabindException.Reference> path = ife.getPath();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NonCanonicalType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'List<JacksonException.Reference> path = ife.getPath();'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 31s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/JacksonDatabindMapper.java:255: warning: [NotJavadoc] This element has multiple Javadoc comments; only the last one will be used.
Step #3 - "compile-libfuzzer-coverage-x86_64":     /**
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NotJavadoc)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 31s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/JacksonDatabindMapper.java:197: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (cached != null && cached.type == type) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (cached != null && Objects.equals(cached.type, type)) {' or 'if (cached != null && cached.type.equals(type)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/JacksonDatabindMapper.java:231: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (cached != null && cached.type == type) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (cached != null && Objects.equals(cached.type, type)) {' or 'if (cached != null && cached.type.equals(type)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 32s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/annotation/JacksonFeatures.java:41: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The enabled serialization features
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the enabled serialization features.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/annotation/JacksonFeatures.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The disabled serialization features
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the disabled serialization features.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/annotation/JacksonFeatures.java:51: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The enabled serialization features
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the enabled serialization features.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/annotation/JacksonFeatures.java:56: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The disabled serialization features
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the disabled serialization features.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/annotation/JacksonFeatures.java:61: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Additional modules to add to the jackson mapper
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns additional modules to add to the jackson mapper.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:91: warning: [NonCanonicalType] The type `TokenStreamFactory.Feature` was referred to by the non-canonical name `JsonFactory.Feature`. This may be misleading.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private Map<JsonFactory.Feature, Boolean> jsonFactoryFeatures = Collections.emptyMap();
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NonCanonicalType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'private Map<TokenStreamFactory.Feature, Boolean> jsonFactoryFeatures = Collections.emptyMap();'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 32s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:127: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default serialization inclusion settings
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default serialization inclusion settings.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:134: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The global defaultTyping using for Polymorphic handling
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the global defaultTyping using for Polymorphic handling.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:142: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default locale to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default locale to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:150: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default time zone to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default time zone to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:158: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The date format to use for dates
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the date format to use for dates.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:174: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The property naming strategy
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the property naming strategy.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:312: warning: [NonCanonicalType] The type `TokenStreamFactory.Feature` was referred to by the non-canonical name `JsonFactory.Feature`. This may be misleading.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Map<JsonFactory.Feature, Boolean> getJsonFactoryFeatures() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NonCanonicalType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'public Map<TokenStreamFactory.Feature, Boolean> getJsonFactoryFeatures() {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonConfiguration.java:321: warning: [NonCanonicalType] The type `TokenStreamFactory.Feature` was referred to by the non-canonical name `JsonFactory.Feature`. This may be misleading.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public void setJsonFactoryFeatures(Map<JsonFactory.Feature, Boolean> jsonFactoryFeatures) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NonCanonicalType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'public void setJsonFactoryFeatures(Map<TokenStreamFactory.Feature, Boolean> jsonFactoryFeatures) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java:80: warning: [UnnecessaryAssignment] Fields annotated with @Inject should not be manually assigned to, as they should be initialized by a framework. Remove the assignment if a framework is being used, or the annotation if one isn't.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected JacksonModule[] jacksonModules = new JacksonModule[0];
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryAssignment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'protected JacksonModule[] jacksonModules ;' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java:83: warning: [UnnecessaryAssignment] Fields annotated with @Inject should not be manually assigned to, as they should be initialized by a framework. Remove the assignment if a framework is being used, or the annotation if one isn't.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected ValueSerializer[] serializers = new ValueSerializer[0];
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryAssignment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'protected ValueSerializer[] serializers ;' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java:86: warning: [UnnecessaryAssignment] Fields annotated with @Inject should not be manually assigned to, as they should be initialized by a framework. Remove the assignment if a framework is being used, or the annotation if one isn't.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected ValueDeserializer[] deserializers = new ValueDeserializer[0];
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryAssignment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'protected ValueDeserializer[] deserializers ;' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 32s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java:89: warning: [UnnecessaryAssignment] Fields annotated with @Inject should not be manually assigned to, as they should be initialized by a framework. Remove the assignment if a framework is being used, or the annotation if one isn't.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected ValueSerializerModifier[] beanSerializerModifiers = new ValueSerializerModifier[0];
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryAssignment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'protected ValueSerializerModifier[] beanSerializerModifiers ;' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java:92: warning: [UnnecessaryAssignment] Fields annotated with @Inject should not be manually assigned to, as they should be initialized by a framework. Remove the assignment if a framework is being used, or the annotation if one isn't.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected ValueDeserializerModifier[] beanDeserializerModifiers = new ValueDeserializerModifier[0];
Step #3 - "compile-libfuzzer-coverage-x86_64":                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryAssignment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'protected ValueDeserializerModifier[] beanDeserializerModifiers ;' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java:95: warning: [UnnecessaryAssignment] Fields annotated with @Inject should not be manually assigned to, as they should be initialized by a framework. Remove the assignment if a framework is being used, or the annotation if one isn't.
Step #3 - "compile-libfuzzer-coverage-x86_64":     protected KeyDeserializer[] keyDeserializers = new KeyDeserializer[0];
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryAssignment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'protected KeyDeserializer[] keyDeserializers ;' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java:122: warning: [UnnecessaryAssignment] Fields annotated with @Inject should not be manually assigned to, as they should be initialized by a framework. Remove the assignment if a framework is being used, or the annotation if one isn't.
Step #3 - "compile-libfuzzer-coverage-x86_64":         this.serializers = serializers;
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryAssignment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java:132: warning: [UnnecessaryAssignment] Fields annotated with @Inject should not be manually assigned to, as they should be initialized by a framework. Remove the assignment if a framework is being used, or the annotation if one isn't.
Step #3 - "compile-libfuzzer-coverage-x86_64":         this.deserializers = deserializers;
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryAssignment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 32s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/env/JsonPropertySourceLoader.java:63: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param input The input stream
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/JacksonDatabindFeature.java:66: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":         } catch (LinkageError ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 32s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/serialize/ResourceDeserializerModifier.java:29: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":  * @author graemerocher
Step #3 - "compile-libfuzzer-coverage-x86_64":    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 32s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JacksonMediaTypeCodec.java:87: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The object mapper
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the object mapper.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/codec/JsonStreamMediaTypeCodec.java:56: warning: [HidingField] Hiding fields of superclasses may cause confusion and errors. This field is hiding MapperMediaTypeCodec.additionalTypes.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private final List<MediaType> additionalTypes;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/HidingField)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 32s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLENote: /src/micronaut-core/jackson-databind/src/main/java/io/micronaut/jackson/databind/JacksonDatabindMapper.java uses or overrides a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 56 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▌··│ 83% EXECUTING [6m 33s]> :micronaut-core:micronaut-jackson-databind:compileJava> IDLE> IDLE> IDLE│████████████▊··│ 85% EXECUTING [6m 33s]> :micronaut-core:micronaut-discovery-core:compileJava│████████████▊··│ 85% EXECUTING [6m 34s]│████████████▊··│ 85% EXECUTING [6m 35s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-discovery-core:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/DiscoveryClient.java:45: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The known service IDs
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the known service IDs.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:54: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The identifier of the service used for purposes of service discovery
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the identifier of the service used for purposes of service discovery.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:59: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The service URI
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the service URI.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:64: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link HealthStatus} of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link HealthStatus} of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:71: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The ID of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the ID of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:105: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The service metadata
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the service metadata.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:112: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The service host
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the service host.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:119: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the service instance available over a secure connection
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is the service instance available over a secure connection.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:127: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The service port
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the service port.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 35s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstance.java:292: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The instance
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/health/HealthStatus.java:109: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the status
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the status.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/health/HealthStatus.java:116: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The description of the status
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the description of the status.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/health/HealthStatus.java:142: warning: [EqualsGetClass] Prefer instanceof to getClass when implementing Object#equals. Note that this may be a behaviour change.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean equals(Object o) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EqualsGetClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof HealthStatus)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 35s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstanceList.java:30: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The service ID
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the service ID.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/ServiceInstanceList.java:42: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The context path to use for requests to the service.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the context path to use for requests to the service.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/EmbeddedServerInstance.java:29: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A reference to the server
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a reference to the server.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/event/AbstractServiceInstanceEvent.java:22: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":  * @author graemerocher
Step #3 - "compile-libfuzzer-coverage-x86_64":    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 35s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/registration/RegistrationConfiguration.java:118: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default timeout for registration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default timeout for registration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/registration/RegistrationConfiguration.java:125: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param timeout The timeout for registration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/registration/RegistrationConfiguration.java:132: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether to fail server startup if registration fails
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to fail server startup if registration fails.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/registration/RegistrationConfiguration.java:148: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether to deregister the service on shutdown
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to deregister the service on shutdown.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/registration/RegistrationConfiguration.java:181: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The number of times to retry registration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the number of times to retry registration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/registration/RegistrationConfiguration.java:197: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default retry delay
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default retry delay.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/registration/RegistrationConfiguration.java:213: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The path to the health endpoint
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the path to the health endpoint.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/registration/RegistrationConfiguration.java:220: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param healthPath The health endpoint path
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 35s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/config/ConfigDiscoveryConfiguration.java:70: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The path where the configuration is stored
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the path where the configuration is stored.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/config/ConfigDiscoveryConfiguration.java:77: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param path The path to store the configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/config/ConfigDiscoveryConfiguration.java:84: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The configuration format
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the configuration format.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/config/ConfigDiscoveryConfiguration.java:91: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param format The configuration format
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 35s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/StaticServiceInstanceList.java:77: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URIs that are load balanced
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URIs that are load balanced.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/DefaultServiceInstance.java:117: warning: [EqualsGetClass] Prefer instanceof to getClass when implementing Object#equals. Note that this may be a behaviour change.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean equals(Object o) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EqualsGetClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof DefaultServiceInstance)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 35s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/DefaultServiceInstance.java:169: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (this.metadata == ConvertibleValues.EMPTY) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(this.metadata, ConvertibleValues.EMPTY)) {' or 'if (this.metadata.equals(ConvertibleValues.EMPTY)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 36s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:47: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link ComputePlatform}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link ComputePlatform}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:66: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The instance id
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the instance id.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:71: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The machine type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the machine type.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:76: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The availability zone of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the availability zone of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:81: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The region of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the region of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:86: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The local host name of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the local host name of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:91: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The private host name of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the private host name of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:96: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The public host name of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the public host name of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:101: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The public IP of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the public IP of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:106: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The public IP v6 of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the public IP v6 of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:111: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The private IP of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the private IP of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:116: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The private IP v6 of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the private IP v6 of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:121: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A description of the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a description of the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:126: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The account the instance is associated with
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the account the instance is associated with.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:131: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The ID of the image used for the instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the ID of the image used for the instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/ComputeInstanceMetadata.java:136: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is this cached instance metadata
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is this cached instance metadata.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 36s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:41: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The IPv4 address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the IPv4 address.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:48: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The IPv6 address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the IPv6 address.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:55: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Name of the Network interface
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns name of the Network interface.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:62: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The MAC address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the MAC address.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:69: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The ID of network interface
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the ID of network interface.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:76: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The gateway
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the gateway.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:83: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The network
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the network.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:90: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The network mask
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the network mask.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:97: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param ipv4 The IPv4 address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:104: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param ipv6 The IPv6 address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:111: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:118: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param mac The MAC address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:125: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param id The ID of network interface
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:132: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param gateway The network gateway
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:139: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param network The network
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/NetworkInterface.java:146: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param netmask The network mask
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanMetadataKeys.java:59: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the metadata key represented in Digital Ocean Metadata JSON.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the metadata key represented in Digital Ocean Metadata JSON.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanMetadataConfiguration.java:71: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The Url
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the Url.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanNetworkInterface.java:75: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return the CIDR mask
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the CIDR mask.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanNetworkInterface.java:82: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param cidr the CIDR mask
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanNetworkInterface.java:89: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return the IPV6 gateway
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the IPV6 gateway.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanNetworkInterface.java:97: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param ipv6Gateway the IPV6 gateway
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanInstanceMetadata.java:45: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return the user data
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the user data.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanInstanceMetadata.java:53: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param userData the user data
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanInstanceMetadata.java:60: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return the vendor data
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the vendor data.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/digitalocean/DigitalOceanInstanceMetadata.java:68: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param vendorData the vendor data
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 36s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:160: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param interfaces the list of interfaces
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:167: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param metadata key/value metadata
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:174: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name instance name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:181: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param availabilityZone the availability zone
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:188: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param localHostname the local host name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:195: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param publicHostname the public host name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:202: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param description the description
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:209: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param machineType the machine type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:216: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param instanceId the instance ID
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:223: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param region the region
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:230: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param account the account
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:237: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param imageId the image ID
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:244: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param publicIpV4 the public IPV4
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:251: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param publicIpV6 the public IPV6
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:258: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param privateIpV4 the private IPV4
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:265: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param privateIpV6 the private IPV4
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:272: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param cached whether this instance is cached
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/cloud/AbstractComputeInstanceMetadata.java:280: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param tags the instance tags
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 36s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/DiscoveryClientStages.java:43: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param discoveryClient The discovery client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the stage of {@link AsyncDiscoveryClient#getInstancesAsync(String)}, or of {@link DiscoveryClient#getInstances(String)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/DiscoveryClientStages.java:62: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param discoveryClient The discovery client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the stage of {@link AsyncDiscoveryClient#getServiceIdsAsync()}, or of {@link DiscoveryClient#getServiceIds()}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/discovery/exceptions/NoAvailableServiceException.java:37: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The service ID
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the service ID.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/health/HeartbeatConfiguration.java:58: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The interval with which to publish {@link HeartbeatEvent} instances
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the interval with which to publish {@link HeartbeatEvent} instances.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/discovery-core/src/main/java/io/micronaut/health/CurrentHealthStatus.java:29: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The current {@link HealthStatus} of the server
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the current {@link HealthStatus} of the server.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │████████████▊··│ 85% EXECUTING [6m 36s]> :micronaut-core:micronaut-discovery-core:compileJava> IDLE> IDLE> IDLENote: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: /src/micronaut-core/discovery-core/src/main/java/io/micronaut/health/HeartbeatTask.java uses unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 97 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 36s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE> :micronaut-core:micronaut-http-client-core:compileJava > Requesting from remo> :micronaut-core:micronaut-http-client-core:compileJava│█████████████··│ 87% EXECUTING [6m 37s]│█████████████··│ 87% EXECUTING [6m 38s]│█████████████··│ 87% EXECUTING [6m 39s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-http-client-core:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": warning: unknown enum constant Mode.DELEGATING
Step #3 - "compile-libfuzzer-coverage-x86_64":   reason: class file for com.fasterxml.jackson.annotation.JsonCreator$Mode not found
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 39s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/interceptor/HttpClientIntroductionAdvice.java:130: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     private final JsonMediaTypeCodec jsonMediaTypeCodec;
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/interceptor/HttpClientIntroductionAdvice.java:130: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     private final JsonMediaTypeCodec jsonMediaTypeCodec;
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/interceptor/HttpClientIntroductionAdvice.java:130: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     private final JsonMediaTypeCodec jsonMediaTypeCodec;
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/interceptor/HttpClientIntroductionAdvice.java:130: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     private final JsonMediaTypeCodec jsonMediaTypeCodec;
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/interceptor/HttpClientIntroductionAdvice.java:146: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             JsonMediaTypeCodec jsonMediaTypeCodec,
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/interceptor/HttpClientIntroductionAdvice.java:146: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             JsonMediaTypeCodec jsonMediaTypeCodec,
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/interceptor/HttpClientIntroductionAdvice.java:146: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             JsonMediaTypeCodec jsonMediaTypeCodec,
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/interceptor/HttpClientIntroductionAdvice.java:146: warning: [removal] JsonMediaTypeCodec in io.micronaut.json.codec has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":             JsonMediaTypeCodec jsonMediaTypeCodec,
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 39s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE│█████████████··│ 87% EXECUTING [6m 40s]/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:71: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A new options builder, starting from the {@link #getDefault() defaults}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a new options builder, starting from the {@link #getDefault() defaults}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:78: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The options that behave like an exchange without options
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the options that behave like an exchange without options.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:95: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A builder initialized with these options
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a builder initialized with these options.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 40s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:269: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param readIdleTimeout See {@link RawRequestOptions#getReadIdleTimeout()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:282: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param returnUnsentBody See {@link RawRequestOptions#isReturnUnsentBody()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:292: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param allowUpgrade See {@link RawRequestOptions#isAllowUpgrade()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:302: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param activityTimeout See {@link RawRequestOptions#getActivityTimeout()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:315: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param followRedirects See {@link RawRequestOptions#isFollowRedirects()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:324: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param retainHostHeader See {@link RawRequestOptions#isRetainHostHeader()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:333: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param decompress See {@link RawRequestOptions#isDecompress()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:342: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param responseTimeout See {@link RawRequestOptions#getResponseTimeout()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns this builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestOptions.java:354: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The options
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the options.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 40s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:419: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param eventLoopGroup Sets the event loop group to use for the client.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:434: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link SslConfiguration} for the client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link SslConfiguration} for the client.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:487: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether redirects should be followed
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether redirects should be followed.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:494: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether throwing an exception upon HTTP error status (&gt;= 400) is preferred.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether throwing an exception upon HTTP error status (&gt;= 400) is preferred.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:533: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The client-specific logger name if configured
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the client-specific logger name if configured.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:558: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Header names that are always filtered for redirects.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns header names that are always filtered for redirects.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 40s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:575: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Additional header names filtered for redirects that do not preserve the request body.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns additional header names filtered for redirects that do not preserve the request body.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:593: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Header names that are additionally filtered for cross-origin redirects.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns header names that are additionally filtered for cross-origin redirects.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:655: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param channelOptions The Client channel options
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:662: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default read timeout. Defaults to 10 seconds.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default read timeout. Defaults to 10 seconds.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:725: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default connect timeout. Defaults to Netty default.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default connect timeout. Defaults to Netty default.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:990: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param proxyType The proxy type
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:1017: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The proxy username to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the proxy username to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:1020: warning: [StringCaseLocaleUsage] Specify a `Locale` when calling `String#to{Lower,Upper}Case`. (Note: there are multiple suggested fixes; the third may be most appropriate if you're dealing with ASCII Strings.)
Step #3 - "compile-libfuzzer-coverage-x86_64":         String type = proxyType.name().toLowerCase();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringCaseLocaleUsage)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'String type = proxyType.name().toLowerCase(Locale.ROOT);' or 'String type = proxyType.name().toLowerCase(Locale.getDefault());' or 'String type = Ascii.toLowerCase(proxyType.name());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:1034: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The proxy password to use.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the proxy password to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:1038: warning: [StringCaseLocaleUsage] Specify a `Locale` when calling `String#to{Lower,Upper}Case`. (Note: there are multiple suggested fixes; the third may be most appropriate if you're dealing with ASCII Strings.)
Step #3 - "compile-libfuzzer-coverage-x86_64":         String type = proxyType.name().toLowerCase();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringCaseLocaleUsage)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'String type = proxyType.name().toLowerCase(Locale.ROOT);' or 'String type = proxyType.name().toLowerCase(Locale.getDefault());' or 'String type = Ascii.toLowerCase(proxyType.name());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClientConfiguration.java:1062: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The proxy selector provided
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the proxy selector provided.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 40s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpVersionSelection.java:176: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Connection mode to use for plaintext connections
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns connection mode to use for plaintext connections.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpVersionSelection.java:184: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Protocols that should be shown as supported via ALPN
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns protocols that should be shown as supported via ALPN.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpVersionSelection.java:192: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether ALPN should be used
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether ALPN should be used.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpVersionSelection.java:200: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether TLS cipher suites should be constrained to those defined by the HTTP/2 spec
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether TLS cipher suites should be constrained to those defined by the HTTP/2 spec.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 40s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClient.java:48: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A blocking HTTP client suitable for testing and non-production scenarios.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a blocking HTTP client suitable for testing and non-production scenarios.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/HttpClient.java:53: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return An {@link AsyncHttpClient} backed by this reactive client.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 40s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE│█████████████··│ 87% EXECUTING [6m 41s]/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/ProxyRequestOptions.java:33: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A new options builder.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a new options builder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/ProxyRequestOptions.java:40: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A default {@link ProxyRequestOptions} that will behave the same way as
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a default {@link ProxyRequestOptions} that will behave the same way as'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/ProxyRequestOptions.java:65: warning: [ObjectsHashCodePrimitive] Objects.hashCode(Object o) should not be passed a primitive value
Step #3 - "compile-libfuzzer-coverage-x86_64":         return Objects.hashCode(isRetainHostHeader());
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ObjectsHashCodePrimitive)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return Boolean.hashCode(isRetainHostHeader());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/DefaultHttpClientConfiguration.java:71: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public DefaultHttpClientConfiguration(DefaultConnectionPoolConfiguration connectionPoolConfiguration,
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "this(connectionPoolConfiguration, webSocketCompressionConfiguration, new DefaultHttp2ClientConfiguration(), applicationConfiguration)", imports = "io.micronaut.http.client.DefaultHttpClientConfiguration.DefaultHttp2ClientConfiguration")'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/RawRequestCookies.java:47: warning: [StringSplitter] String.split(String) has surprising behavior
Step #3 - "compile-libfuzzer-coverage-x86_64":             for (String pair : existing.split(";")) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringSplitter)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'for (String pair : Splitter.on(';').split(existing)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 41s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/DefaultAsyncOverReactiveHttpClient.java:78: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The underlying {@link HttpClient}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the underlying {@link HttpClient}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 41s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/annotation/Client.java:43: warning: [InjectScopeAnnotationOnInterfaceOrAbstractClass] Scope annotation on an interface or abstract class is not allowed
Step #3 - "compile-libfuzzer-coverage-x86_64": @Singleton
Step #3 - "compile-libfuzzer-coverage-x86_64": ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InjectScopeAnnotationOnInterfaceOrAbstractClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/annotation/Client.java:48: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URL or service ID of the remote service
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URL or service ID of the remote service.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/annotation/Client.java:54: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The ID of the client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the ID of the client.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/annotation/Client.java:90: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The type used to decode errors
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the type used to decode errors.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 41s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/annotation/Client.java:95: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The http client configuration bean to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the http client configuration bean to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 41s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:228: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":         this.noFilters = filterResolver == null || this.clientFilterEntries.isEmpty() && filterResolver.getClass() == DefaultHttpClientFilterResolver.class;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'this.noFilters = filterResolver == null || (this.clientFilterEntries.isEmpty() && filterResolver.getClass() == DefaultHttpClientFilterResolver.c'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:299: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The scheduler of the timeouts of the exchanges
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the scheduler of the timeouts of the exchanges.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:304: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The factory of the buffers of the event data of {@link #eventStream(HttpRequest)}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the factory of the buffers of the event data of {@link #eventStream(HttpRequest)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:331: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The configuration used by this client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the configuration used by this client.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:338: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The client-specific logger name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the client-specific logger name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:345: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link MediaTypeCodecRegistry} used by this client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link MediaTypeCodecRegistry} used by this client.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:363: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The handler registry
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the handler registry.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:370: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param handlerRegistry The handler registry
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:377: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The size limits of response bodies
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the size limits of response bodies.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:384: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The conversion service
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the conversion service.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:402: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param request The request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the request accepts {@code text/event-stream}, possibly among other types.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:425: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param response The response
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the response has a body.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 41s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:440: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param request The request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the request, mutable.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:449: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param httpRequest The request, given the conversion service of this client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:458: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param exc The exception
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the exception, with the service id of this client.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:481: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param request The request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a flow with the resolved target.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:490: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param request            The request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a flow with the resolved target.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:506: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param parentRequest The parent request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a flow with the resolved target.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:527: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param request The request object
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the discriminator to use when selecting a server for the purposes of load balancing (defaults to {@link HttpRequest}).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:597: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         future.whenComplete((instance, throwable) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'future = future.whenComplete((instance, throwable) -> {' or 'var unused = future.whenComplete((instance, throwable) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 41s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:801: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param a The first URI
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether both URIs name the same server: scheme and host ignoring case, and port,'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 41s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:1071: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (errorType != null && errorType != HttpClient.DEFAULT_ERROR_TYPE) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (errorType != null && !errorType.equals(HttpClient.DEFAULT_ERROR_TYPE)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:1111: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         return errorType != null && (errorType != HttpClient.DEFAULT_ERROR_TYPE || configuration.isBufferErrorBodyForStreaming());
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return errorType != null && (!errorType.equals(HttpClient.DEFAULT_ERROR_TYPE) || configuration.isBufferErrorBodyForStreaming());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 42s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:1563: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                     if (cleanupError != error) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!cleanupError.equals(error)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:1669: warning: [BadInstanceof] `response.getBody().orElse(null)` is an instance of BodyElements<ByteBuffer<?>> which is a subtype of BodyElements<?>, so this is equivalent to a null check.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (response.getBody().orElse(null) instanceof BodyElements<?> elements) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/BadInstanceof)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 42s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:1734: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param flow    The flow
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the flow as a Mono, for the reactive API.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:1794: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The selected instance, or {@code null} if the request URI was absolute
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the selected instance, or {@code null} if the request URI was absolute.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/AbstractHttpClient.java:1801: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The URI, for a caller that sends no exchange: the selection is released
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI, for a caller that sends no exchange: the selection is released.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/LoadBalancer.java:42: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param discriminator An object used to discriminate the server to select. Usually the service ID
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the selected {@link ServiceInstance}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/LoadBalancer.java:113: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The context path to use for requests.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the context path to use for requests.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/LoadBalancer.java:120: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The selected {@link ServiceInstance}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the selected {@link ServiceInstance}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 42s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/LoadBalancer.java:149: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return An error because there are no load balancer
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns an error because there are no load balancer.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/filter/ClientFilterResolutionContext.java:53: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The client ID.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the client ID.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/loadbalance/LoadBalancerSelection.java:54: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The selected instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the selected instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/exceptions/HttpClientResponseException.java:88: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link io.micronaut.http.HttpStatus} returned
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link io.micronaut.http.HttpStatus} returned'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/exceptions/HttpClientResponseException.java:96: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The response status code
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the response status code.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/exceptions/HttpClientResponseException.java:103: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The HTTP status reason phrase
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the HTTP status reason phrase.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 42s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/internal/ElementsResponse.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param response The response, for its status, headers and attributes
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the response with the elements as its body.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 42s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/internal/RawResponseFuture.java:70: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param flow             The response flow
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/internal/RawResponseFuture.java:129: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (context == PropagatedContext.empty()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(context, PropagatedContext.empty())) {' or 'if (context.equals(PropagatedContext.empty())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/internal/ResponseSubscriberElements.java:54: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         response.whenComplete((r, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'response = response.whenComplete((r, error) -> {' or 'var unused = response.whenComplete((r, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 42s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/internal/ElementsStages.java:125: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         future.whenComplete((result, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'future = future.whenComplete((result, error) -> {' or 'var unused = future.whenComplete((result, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/internal/ElementsStages.java:157: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         mapped.whenComplete((result, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'mapped = mapped.whenComplete((result, error) -> {' or 'var unused = mapped.whenComplete((result, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/internal/RawHttpRequestWrapper.java:69: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether {@link #body(Object)} replaced the raw bytes, which are then not sent
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether {@link #body(Object)} replaced the raw bytes, which are then not sent.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 42s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/http-client-core/src/main/java/io/micronaut/http/client/loadbalance/FixedLoadBalancer.java:104: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URI of the {@link LoadBalancer}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI of the {@link LoadBalancer}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 42s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE│█████████████··│ 87% EXECUTING [6m 43s]│█████████████··│ 87% EXECUTING [6m 44s]Note: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████··│ 87% EXECUTING [6m 45s]> :micronaut-core:micronaut-http-client-core:compileJava> IDLE> IDLE> IDLE> :micronaut-core:micronaut-http-client-core:compileJava > Packing build cache │█████████████▍·│ 89% EXECUTING [6m 45s]> :micronaut-core:micronaut-websocket:compileJava│█████████████▍·│ 89% EXECUTING [6m 46s]│█████████████▍·│ 89% EXECUTING [6m 47s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-websocket:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/WebSocketClientRegistry.java:57: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Return the default Websocket HTTP client.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns return the default Websocket HTTP client.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/WebSocketComponent.java:44: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URI of the action
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI of the action.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/WebSocketComponent.java:50: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URI of the action
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI of the action.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/WebSocketComponent.java:56: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The WebSocket version to use to connect
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the WebSocket version to use to connect.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/ClientWebSocket.java:51: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URI of the action
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI of the action.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/ClientWebSocket.java:59: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URI of the action
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI of the action.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/ClientWebSocket.java:67: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The WebSocket version to use to connect
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the WebSocket version to use to connect.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/ClientWebSocket.java:73: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The Sec-WebSocket-Protocol header field is used in the WebSocket opening handshake.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the Sec-WebSocket-Protocol header field is used in the WebSocket opening handshake.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/ServerWebSocket.java:48: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URI of the action
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI of the action.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/ServerWebSocket.java:56: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URI of the action
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI of the action.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/ServerWebSocket.java:64: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The WebSocket version to use to connect
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the WebSocket version to use to connect.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/annotation/ServerWebSocket.java:70: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A csv of the supported subprotocols
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a csv of the supported subprotocols.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/AsyncOverReactiveWebSocketClient.java:83: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             whenComplete((ignored, error) -> cancelUnlessDone());
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = whenComplete((ignored, error) -> cancelUnlessDone());' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/WebSocketSession.java:49: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Only the attributes of the session
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns only the attributes of the session.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/CloseReason.java:118: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The code
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the code.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/CloseReason.java:125: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The reason
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the reason.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/CloseReason.java:132: warning: [EqualsGetClass] Prefer instanceof to getClass when implementing Object#equals. Note that this may be a behaviour change.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean equals(Object o) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EqualsGetClass)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!(o instanceof CloseReason)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/event/WebSocketMessageProcessedEvent.java:43: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The message that was processed
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the message that was processed.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▍·│ 89% EXECUTING [6m 47s]> :micronaut-core:micronaut-websocket:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/context/WebSocketMethods.java:80: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link OnOpen} method, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link OnOpen} method, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/context/WebSocketMethods.java:87: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link OnClose} method, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link OnClose} method, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/context/WebSocketMethods.java:94: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link OnMessage} method of the messages, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link OnMessage} method of the messages, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/context/WebSocketMethods.java:101: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link OnMessage} method of the pongs, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link OnMessage} method of the pongs, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/context/WebSocketMethods.java:108: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link OnError} method, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link OnError} method, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/context/DefaultWebSocketBeanRegistry.java:93: warning: [EmptyBlockTag] A block tag (@param, @return, @throws, @deprecated) has an empty description. Block tags without descriptions don't add much value for future readers of the code; consider removing the tag entirely or adding a description.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param <T>
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.1.3-javadoc-block-tags)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '*'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▍·│ 89% EXECUTING [6m 47s]> :micronaut-core:micronaut-websocket:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/context/WebSocketBean.java:44: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The target instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the target instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/context/WebSocketBean.java:58: warning: [StringSplitter] String.split(String) has surprising behavior
Step #3 - "compile-libfuzzer-coverage-x86_64":         for (String subprotocol : subprotocols.split(",")) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StringSplitter)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'for (String subprotocol : Splitter.on(',').split(subprotocols)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/bind/WebSocketState.java:46: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The session
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the session.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/bind/WebSocketState.java:53: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The originating request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the originating request.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▍·│ 89% EXECUTING [6m 47s]> :micronaut-core:micronaut-websocket:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/interceptor/ClientWebSocketInterceptor.java:91: warning: [RefactorSwitch] This switch can be refactored to be more readable
Step #3 - "compile-libfuzzer-coverage-x86_64":                     switch (parameterValues.length) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/RefactorSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return switch (parameterValues.length) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/interceptor/ClientWebSocketInterceptor.java:115: warning: [RefactorSwitch] This switch can be refactored to be more readable
Step #3 - "compile-libfuzzer-coverage-x86_64":         switch (interceptedMethod.resultType()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/RefactorSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return switch (interceptedMethod.resultType()) {' or 'return switch (interceptedMethod.resultType()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▍·│ 89% EXECUTING [6m 47s]> :micronaut-core:micronaut-websocket:compileJava> IDLE> IDLE> IDLE/src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/WebSocketPongMessage.java:40: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The content of the pong message. This buffer may be released after the message handler has completed.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the content of the pong message. This buffer may be released after the message handler has completed.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/WebSocketPingMessage.java:45: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The content of the ping message. This buffer may be released after the message handler has completed.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the content of the ping message. This buffer may be released after the message handler has completed.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/WebSocketMessagesSubscriber.java:71: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         sent.whenComplete((ignored, error) -> callSubscription());
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'sent = sent.whenComplete((ignored, error) -> callSubscription());' or 'var unused = sent.whenComplete((ignored, error) -> callSubscription());' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/WebSocketMessagesSubscriber.java:97: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         send.whenComplete((ignored, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'send = send.whenComplete((ignored, error) -> {' or 'var unused = send.whenComplete((ignored, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/websocket/src/main/java/io/micronaut/websocket/WebSocketMessagesSubscriber.java:116: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Objects.requireNonNull(lastSend.get()).whenComplete((ignored, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = Objects.requireNonNull(lastSend.get()).whenComplete((ignored, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▍·│ 89% EXECUTING [6m 47s]> :micronaut-core:micronaut-websocket:compileJava> IDLE> IDLE> IDLENote: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 35 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 47s]> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE> IDLE> :micronaut-core:micronaut-http-netty:compileJava > Resolve files of configura> :micronaut-core:micronaut-http-netty:compileJava > Resolve files of configura│█████████████▋·│ 90% EXECUTING [6m 48s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava│█████████████▋·│ 90% EXECUTING [6m 49s]│█████████████▋·│ 90% EXECUTING [6m 50s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-http-netty:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EpollEventLoopGroupFactory.java:53: warning: [removal] createIoHandlerFactory() in EventLoopGroupFactory has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public IoHandlerFactory createIoHandlerFactory() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/DefaultEventLoopGroupConfiguration.java:181: warning: [removal] isPreferNativeTransport() in EventLoopGroupConfiguration has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean isPreferNativeTransport() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NioEventLoopGroupFactory.java:47: warning: [removal] createIoHandlerFactory() in EventLoopGroupFactory has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public IoHandlerFactory createIoHandlerFactory() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/KQueueEventLoopGroupFactory.java:51: warning: [removal] createIoHandlerFactory() in EventLoopGroupFactory has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public IoHandlerFactory createIoHandlerFactory() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/DefaultEventLoopGroupFactory.java:135: warning: [removal] createIoHandlerFactory() in EventLoopGroupFactory has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public IoHandlerFactory createIoHandlerFactory() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/DefaultEventLoopGroupFactory.java:136: warning: [removal] createIoHandlerFactory() in EventLoopGroupFactory has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         return nativeFactory().createIoHandlerFactory();
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 50s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/IoUringEventLoopGroupFactory.java:50: warning: [removal] createIoHandlerFactory() in EventLoopGroupFactory has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public IoHandlerFactory createIoHandlerFactory() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 50s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/EventLoopFlow.java:101: warning: [Finally] If you return or throw from a finally, then values returned or thrown from the try-catch block will be ignored. Consider using try-with-resources instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":                             throw new AssertionError("Nested call?");
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/Finally)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 50s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/EventLoopFlow.java:147: warning: [Finally] If you return or throw from a finally, then values returned or thrown from the try-catch block will be ignored. Consider using try-with-resources instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         throw new AssertionError("Weird");
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/Finally)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 51s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyMutableHttpResponse.java:422: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (this.body != body) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!Objects.equals(this.body, body)) {' or 'if (!this.body.equals(body)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 51s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyMutableHttpResponse.java:523: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public abstract Optional<T> convert(ArgumentConversionContext<T> valueType, @Nullable T value);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'abstract Optional<T> convert(ArgumentConversionContext<T> valueType, @Nullable T value);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyMutableHttpResponse.java:525: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         protected synchronized Optional<T> convertFromNext(ConversionService conversionService, ArgumentConversionContext<T> conversionContext, @Nullable T value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'synchronized Optional<T> convertFromNext(ConversionService conversionService, ArgumentConversionCont'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyMutableHttpResponse.java:537: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                         if (currentConversionContext == conversionContext) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(currentConversionContext, conversionContext)) {' or 'if (currentConversionContext.equals(conversionContext)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyMutableHttpResponse.java:558: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public void cleanup() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'void cleanup() {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 51s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpResponseBuilder.java:76: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is the response a stream.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is the response a stream.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 51s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpHeaders.java:66: warning: [NullableOptional] Using an Optional variable which is expected to possibly be null is discouraged. It is best to indicate the absence of the value by assigning it an empty optional.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private Optional<MediaType> contentType;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NullableOptional)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpHeaders.java:68: warning: [NullableOptional] Using an Optional variable which is expected to possibly be null is discouraged. It is best to indicate the absence of the value by assigning it an empty optional.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private Optional<String> origin;
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NullableOptional)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpHeaders.java:72: warning: [NullableOptional] Using an Optional variable which is expected to possibly be null is discouraged. It is best to indicate the absence of the value by assigning it an empty optional.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private Optional<Charset> acceptCharset;
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NullableOptional)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpHeaders.java:74: warning: [NullableOptional] Using an Optional variable which is expected to possibly be null is discouraged. It is best to indicate the absence of the value by assigning it an empty optional.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private Optional<Locale> acceptLanguage;
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NullableOptional)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 51s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpHeaders.java:276: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":         sb.append(Base64.getEncoder().encodeToString((userInfo).getBytes(StandardCharsets.ISO_8859_1)));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'sb.append(Base64.getEncoder().encodeToString( userInfo.getBytes(StandardCharsets.ISO_8859_1)));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpHeaders.java:341: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":             } catch (IllegalArgumentException ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpHeaders.java:363: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":             } catch (NumberFormatException ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 51s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpHeaders.java:403: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":             } catch (Exception ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 51s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE│█████████████▋·│ 90% EXECUTING [6m 52s]/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/cookies/NettyLaxServerCookieDecoder.java:26: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":  * @author Sergio del Amo
Step #3 - "compile-libfuzzer-coverage-x86_64":    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 52s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/cookies/NettyCookie.java:75: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The Netty cookie
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the Netty cookie.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 52s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/cookies/NettyCookies.java:107: warning: [CollectionUndefinedEquality] CharSequence does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":         Cookie cookie = cookies.get(name);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/cookies/NettyCookies.java:117: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":             return findCookie(name).flatMap((cookie -> conversionService.convert(cookie.getValue(), requiredType)));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return findCookie(name).flatMap( cookie -> conversionService.convert(cookie.getValue(), requiredType));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/cookies/NettyCookies.java:123: warning: [UnnecessaryParentheses] These parentheses are unnecessary; it is unlikely the code will be misinterpreted without them
Step #3 - "compile-libfuzzer-coverage-x86_64":         return findCookie(name).flatMap((cookie -> conversionService.convert(cookie.getValue(), conversionContext)));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnnecessaryParentheses)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return findCookie(name).flatMap( cookie -> conversionService.convert(cookie.getValue(), conversionContext));'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 52s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/stream/JsonSubscriber.java:42: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 } else if (httpContent != closeBracket) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '} else if (!Objects.equals(httpContent, closeBracket)) {' or '} else if (!httpContent.equals(closeBracket)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/DefaultEventLoopGroupRegistry.java:100: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 eventLoopGroup.shutdownGracefully(quietPeriod, timeout, TimeUnit.MILLISECONDS);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = eventLoopGroup.shutdownGracefully(quietPeriod, timeout, TimeUnit.MILLISECONDS);' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 52s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupRegistry.java:37: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Obtains the default event loop group.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns obtains the default event loop group.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupFactory.java:48: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Is this a native factory.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns is this a native factory.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupConfiguration.java:65: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The number of threads for the event loop, or 0 to use {@link #getThreadCoreRatio()}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the number of threads for the event loop, or 0 to use {@link #getThreadCoreRatio()}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupConfiguration.java:80: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The I/O ratio.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the I/O ratio.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupConfiguration.java:85: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the executor to use.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the executor to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupConfiguration.java:90: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether to prefer the native transport
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to prefer the native transport.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupConfiguration.java:112: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The shutdown quiet period
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the shutdown quiet period.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 52s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupConfiguration.java:119: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The shutdown timeout (must be &gt;= shutdownQuietPeriod)
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the shutdown timeout (must be &gt;= shutdownQuietPeriod).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/EventLoopGroupConfiguration.java:126: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return When set to {@code true}, use a special <i>experimental</i> event loop that can also
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns when set to {@code true}, use a special <i>experimental</i> event loop that can also'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:173: warning: [ExposedPrivateType] Signature of non-private member 'localLoomQueue' should not reference private classes: ScheduledTask
Step #3 - "compile-libfuzzer-coverage-x86_64":         final Deque<ScheduledTask> localLoomQueue = new ArrayDeque<>();
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ExposedPrivateType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'private final Deque<ScheduledTask> localLoomQueue = new ArrayDeque<>();' or 'record ScheduledTask('?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:258: warning: [ThreadPriorityCheck] Relying on the thread scheduler is discouraged.
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 Thread.yield();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ThreadPriorityCheck)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:290: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 assert thread == Thread.currentThread();
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'assert thread.equals(Thread.currentThread());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:300: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             return !PrivateLoomSupport.isCarrierThreadSupported() || PrivateLoomSupport.getCarrierThread(thread) == carrier;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return !PrivateLoomSupport.isCarrierThreadSupported() || Objects.equals(PrivateLoomSupport.getCarrierThread(thread), carrier);' or 'return !PrivateLoomSupport.isCarrierThreadSupported() || PrivateLoomSupport.getCarrierThread(thread).equals(carrier);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 52s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:473: warning: [ThreadPriorityCheck] Relying on the thread scheduler is discouraged.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Thread.yield();
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ThreadPriorityCheck)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:484: warning: [ThreadPriorityCheck] Relying on the thread scheduler is discouraged.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 Thread.yield();
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ThreadPriorityCheck)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:534: warning: [NonAtomicVolatileUpdate] This update of a volatile variable is non-atomic
Step #3 - "compile-libfuzzer-coverage-x86_64":                 activeThreadsLocal--;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NonAtomicVolatileUpdate)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:555: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (thread == ioThread) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(thread, ioThread)) {' or 'if (thread.equals(ioThread)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:559: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (t != carrier && !isOnRunner(t)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!Objects.equals(t, carrier) && !isOnRunner(t)) {' or 'if (!t.equals(carrier) && !isOnRunner(t)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:574: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (ioContinuation == command) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(ioContinuation, command)) {' or 'if (ioContinuation.equals(command)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:577: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (t != carrier && !isOnRunner(t)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (!Objects.equals(t, carrier) && !isOnRunner(t)) {' or 'if (!t.equals(carrier) && !isOnRunner(t)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:622: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (Thread.currentThread() == carrier) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(Thread.currentThread(), carrier)) {' or 'if (Thread.currentThread().equals(carrier)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:624: warning: [NonAtomicVolatileUpdate] This update of a volatile variable is non-atomic
Step #3 - "compile-libfuzzer-coverage-x86_64":                 activeThreadsLocal++;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NonAtomicVolatileUpdate)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 52s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:656: warning: [ThreadPriorityCheck] Relying on the thread scheduler is discouraged.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         Thread.yield();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ThreadPriorityCheck)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:729: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (currentThread instanceof ForkJoinWorkerThread fjwt && fjwt.getPool() == PrivateLoomSupport.getDefaultScheduler()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (currentThread instanceof ForkJoinWorkerThread fjwt && Objects.equals(fjwt.getPool(), PrivateLoomSupport.getDefaultScheduler())) {' or 'if (currentThread instanceof ForkJoinWorkerThread fjwt && fjwt.getPool().equals(PrivateLoomSupport.getDefaultScheduler())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomCarrierGroup.java:731: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             } else if (currentThread.isVirtual() && PrivateLoomSupport.getScheduler(currentThread) == PrivateLoomSupport.getDefaultScheduler()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '} else if (currentThread.isVirtual() && Objects.equals(PrivateLoomSupport.getScheduler(currentThread), PrivateLoomSupport.getDefaultScheduler())) {' or '} else if (currentThread.isVirtual() && PrivateLoomSupport.getScheduler(currentThread).equals(PrivateLoomSupport.getDefaultScheduler())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/LoomBranchSupport.java:187: warning: [UnusedMethod] Method 'executeOrUnwrap' is never used.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private static void executeOrUnwrap(VirtualThreadSchedulerProxy target, Thread thread, Runnable task) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 52s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyChannelType.java:25: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see io.netty.channel.socket.ServerSocketChannel
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.netty.channel.socket.ServerSocketChannel}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyChannelType.java:29: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see io.netty.channel.socket.SocketChannel
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.netty.channel.socket.SocketChannel}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyChannelType.java:33: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see io.netty.channel.unix.DomainSocketChannel
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.netty.channel.unix.DomainSocketChannel}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyChannelType.java:37: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see io.netty.channel.unix.ServerDomainSocketChannel
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.netty.channel.unix.ServerDomainSocketChannel}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyChannelType.java:41: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see io.netty.channel.socket.DatagramChannel
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.netty.channel.socket.DatagramChannel}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/DefaultEventLoopGroupConfiguration.java:111: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public DefaultEventLoopGroupConfiguration(
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "this(name, numThreads, threadCoreRatio, ioRatio, preferNativeTransport, null, executor, shutdownQuietPeriod, shutdownTimeout, loomCarrier)")'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 53s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/loom/PrivateLoomSupport.java:149: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} if {@link #getCarrierThread(Thread)} can be used
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} if {@link #getCarrierThread(Thread)} can be used.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 53s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyThreadFactory.java:88: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public NettyThreadFactory() {
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "this(new NettyGlobalConfiguration())", imports = "io.micronaut.http.netty.configuration.NettyGlobalConfiguration")'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyThreadFactory.java:98: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public static int getDefaultEventLoopThreads() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "Math.max(1, SystemPropertyUtil.getInt(\"io.netty.eventLoopThreads\", NettyRuntime.availableProcessors() * 2))", imports = {"io.netty.util.NettyRuntime", "io.netty.util.internal.SystemPropertyUtil"})'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyThreadFactory.java:167: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public CustomizedThreadFactory(String poolName, boolean daemon, int priority, boolean nonBlocking) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'CustomizedThreadFactory(String poolName, boolean daemon, int priority, boolean nonBlocking) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/channel/NettyThreadFactory.java:184: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public NonBlockingFastThreadLocalThread(ThreadGroup group, Runnable target, String name) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'NonBlockingFastThreadLocalThread(ThreadGroup group, Runnable target, String name) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 53s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/StreamingNettyByteBody.java:78: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         return sharedBuffer.eventLoop == eventLoop;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return Objects.equals(sharedBuffer.eventLoop, eventLoop);' or 'return sharedBuffer.eventLoop.equals(eventLoop);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 53s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:139: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:194: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             ctx.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:206: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ctx.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:225: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         ctx.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 53s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:285: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:396: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:399: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ((DuplexChannel) channel).shutdownOutput();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ((DuplexChannel) channel).shutdownOutput();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:408: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                     channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/body/RawDuplexHandler.java:427: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 53s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketSession.java:137: warning: [NotJavadoc] This element has multiple Javadoc comments; only the last one will be used.
Step #3 - "compile-libfuzzer-coverage-x86_64":     /**
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NotJavadoc)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 53s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketSession.java:259: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param message   The message
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the frame of the message: the message itself if it is a frame.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketSession.java:280: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         sent.whenComplete((ignored, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'sent = sent.whenComplete((ignored, error) -> {' or 'var unused = sent.whenComplete((ignored, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketSession.java:281: warning: [CollectionUndefinedEquality] Future does not have well-defined equals behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":             sendingAll.remove(sent);
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/CollectionUndefinedEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketSession.java:326: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketSession.java:331: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketSession.java:336: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketSession.java:340: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 54s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:203: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The body argument for the message handler
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the body argument for the message handler.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:208: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The pong argument for the pong handler
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the pong argument for the pong handler.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:213: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The session
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the session.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 54s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:320: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (webSocketBean.closeMethod().orElse(null) == messageHandler || webSocketBean.errorMethod().orElse(null) == messageHandler) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(webSocketBean.closeMethod().orElse(null), messageHandler) || webSocketBean.errorMethod().orElse(null) == messageHandler) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:320: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (webSocketBean.closeMethod().orElse(null) == messageHandler || webSocketBean.errorMethod().orElse(null) == messageHandler) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (webSocketBean.closeMethod().orElse(null) == messageHandler || Objects.equals(webSocketBean.errorMethod().orElse(null), messageHandler)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:493: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             ctx.writeAndFlush(new PongWebSocketFrame(frame.content()));
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.writeAndFlush(new PongWebSocketFrame(frame.content()));' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 54s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:607: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ctx.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:637: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             ctx.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:701: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ctx.channel().close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.channel().close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:713: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ctx.channel().close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.channel().close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:738: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ctx.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/AbstractNettyWebSocketHandler.java:751: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             ctx.channel().close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.channel().close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/websocket/NettyWebSocketMessagesSubscriber.java:85: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         sent.whenComplete((ignored, error) -> onEventLoop(this::cancelIfNotTerminated));
Step #3 - "compile-libfuzzer-coverage-x86_64":                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'sent = sent.whenComplete((ignored, error) -> onEventLoop(this::cancelIfNotTerminated));' or 'var unused = sent.whenComplete((ignored, error) -> onEventLoop(this::cancelIfNotTerminated));' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 54s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/AbstractCompositeCustomizer.java:100: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (nev == old) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(nev, old)) {' or 'if (nev.equals(old)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-netty/src/main/java/io/micronaut/http/netty/NettyHttpRequestBuilder.java:134: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     static HttpRequest toHttpRequest(io.micronaut.http.HttpRequest<?> request) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "NettyHttpRequestBuilder.asBuilder(request).toHttpRequestWithoutBody()", imports = "io.micronaut.http.netty.NettyHttpRequestBuilder")'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 54s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLENote: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▋·│ 90% EXECUTING [6m 54s]> IDLE> :micronaut-core:micronaut-http-netty:compileJava> IDLE> IDLE> :micronaut-core:micronaut-http-netty:compileJava > Packing build cache entry│█████████████▉·│ 92% EXECUTING [6m 55s]> :micronaut-core:micronaut-router:compileJava│█████████████▉·│ 92% EXECUTING [6m 56s]│█████████████▉·│ 92% EXECUTING [6m 57s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-router:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/AbstractRouteMatch.java:285: warning: [removal] fulfill(Map<String,Object>) in RouteMatch has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public void fulfill(Map<String, Object> newValues) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [6m 58s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/DefaultFilterRoute.java:209: warning: [removal] match(HttpMethod,URI) in FilterRoute has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Optional<GenericHttpFilter> match(HttpMethod method, URI uri) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [6m 58s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:758: warning: [NotJavadoc] This element has multiple Javadoc comments; only the last one will be used.
Step #3 - "compile-libfuzzer-coverage-x86_64":     /**
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NotJavadoc)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:975: warning: [NotJavadoc] This element has multiple Javadoc comments; only the last one will be used.
Step #3 - "compile-libfuzzer-coverage-x86_64":         /**
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/NotJavadoc)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [6m 59s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:200: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The media types and the executor of the groups of the locator routes, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the media types and the executor of the groups of the locator routes, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [6m 59s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:326: warning: [DoNotCallSuggester] Methods that always throw an exception should be annotated with @DoNotCall to prevent calls at compilation time vs. at runtime (note that adding @DoNotCall will break any existing callers of this API).
Step #3 - "compile-libfuzzer-coverage-x86_64":     public Object handle() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DoNotCallSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@DoNotCall("Always throws java.lang.IllegalStateException") public Object handle() {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [6m 59s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:565: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         for (Throwable e = error; e != null; e = e.getCause() == e ? null : e.getCause()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'for (Throwable e = error; e != null; e = Objects.equals(e.getCause(), e) ? null : e.getCause()) {' or 'for (Throwable e = error; e != null; e = e.getCause().equals(e) ? null : e.getCause()) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:566: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (e == failure) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (e.equals(failure)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [6m 59s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:697: warning: [ModifyCollectionInEnhancedForLoop] Modifying a collection while iterating over it in a loop may cause a ConcurrentModificationException to be thrown or lead to undefined behavior.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 || !outcomes.replace(entry.getKey(), outcome, new Outcome(null, new LocationAbandoned(), null, null, outcome.location()))) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ModifyCollectionInEnhancedForLoop)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:712: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param error An error
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:744: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param inherited The annotations a route inherits
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the annotations of both.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:768: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param request A request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether it is a request a locator route located: its routes have the settings of the location.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:776: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param request A request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the route selector the routes of the location of a located request inherit, or'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:785: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param request A request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the order of the route selector the routes of the location of a located request'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [6m 59s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:1020: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param matches The matches of the rest of the path
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the matches of the request.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [6m 59s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:1056: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param request      The request, a {@link LocatedRequest} for a locator route of a located table
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the location.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:1199: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return What the locator route matched
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns what the locator route matched.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteLocator.java:1338: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The prefix as it was declared, nested or mounted
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the prefix as it was declared, nested or mounted.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/DynamicRouteTarget.java:49: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param route A route
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the dynamic target of the route, or {@code null} for an ordinary route.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/DynamicRouteTarget.java:142: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The resolved target, given to the path variables of a handler, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the resolved target, given to the path variables of a handler, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/DynamicRouteTarget.java:147: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The filters that run before the filters of the matched route
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the filters that run before the filters of the matched route.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/DynamicRouteTarget.java:152: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The groups whose error and status routes apply after the ones of the matched route
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the groups whose error and status routes apply after the ones of the matched route.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/DynamicRouteTarget.java:157: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The annotations the matched route inherits from the resolution, e.g. of the
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the annotations the matched route inherits from the resolution, e.g. of the'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteTableFactory.java:203: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 return lookup.routes == routes;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return Objects.equals(lookup.routes, routes);' or 'return lookup.routes.equals(routes);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteTableFactory.java:205: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             return o instanceof WeakKey other && other.get() == routes;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return o instanceof WeakKey other && Objects.equals(other.get(), routes);' or 'return o instanceof WeakKey other && other.get().equals(routes);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteTableFactory.java:223: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 return other.routes == routes;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return Objects.equals(other.routes, routes);' or 'return other.routes.equals(routes);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteTableFactory.java:225: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             return o instanceof WeakKey key && key.get() == routes;
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return o instanceof WeakKey key && Objects.equals(key.get(), routes);' or 'return o instanceof WeakKey key && key.get().equals(routes);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:116: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return A copy: a change of this settings does not change the copy
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a copy: a change of this settings does not change the copy.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:132: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the route is one of the routes of {@link HttpRouteBuilder#any(String)}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the route is one of the routes of {@link HttpRouteBuilder#any(String)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:148: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the route is declared together with a {@code HEAD} route of the same handler
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the route is declared together with a {@code HEAD} route of the same handler.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:187: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param mediaTypes The media types
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#consumes(MediaType...)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:195: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see HttpRouteSpec#consumesAll()
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#consumesAll()}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:202: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param mediaTypes The media types
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#produces(MediaType...)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:210: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param executorName The name of the executor
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#executeOn(String)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:219: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @see HttpRouteSpec#nonBlocking()
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#nonBlocking()}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:227: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param port The port, exposed now
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#port(int)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:236: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param order The order
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#order(int)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:244: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param selector The route selector of the route, or {@code null} for none, overriding the one of its groups
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link RouteSpec#selectedBy(RouteMatchSelector)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:253: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param name  The name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#attribute(String, Object)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:262: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param condition The condition
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#where(RequestCondition)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:270: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param constraint The constraint on the path variables
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link RouteSpec#constrain(Predicate)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:278: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param filter The filter, whose executor may be chosen until the route is built
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link RouteFilterSpec}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:306: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param annotationMetadata The annotated element whose annotations the route has
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#annotationMetadata(AnnotationMetadataProvider)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:320: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param annotation The annotation
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#annotate(AnnotationValue)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:334: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param responseType The type of the body of the response
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpRouteSpec#responseType(Argument)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:347: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The media types the route consumes, empty for any, or {@code null} if the route did not set them
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the media types the route consumes, empty for any, or {@code null} if the route did not set them.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:354: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The media types the route produces, or {@code null} if the route did not set them
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the media types the route produces, or {@code null} if the route did not set them.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:361: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The executor the route runs on, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the executor the route runs on, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:368: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the route runs on the event loop
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the route runs on the event loop.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:375: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The port of the route, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the port of the route, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:382: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the route sets its route selector, see {@link #getSelector()}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the route sets its route selector, see {@link #getSelector()}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:389: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The route selector the route sets, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the route selector the route sets, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:396: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The order of the route, or {@code null} if it has none of its own
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the order of the route, or {@code null} if it has none of its own.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:403: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The attributes of the route, a read-only view
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the attributes of the route, a read-only view.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:410: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The conditions of the route, a read-only view
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the conditions of the route, a read-only view.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:417: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The constraints on the path variables of the route, a read-only view
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the constraints on the path variables of the route, a read-only view.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:424: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The filters of the route, a read-only view
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the filters of the route, a read-only view.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:431: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The filters of the group of the route, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the filters of the group of the route, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/builder/RouteSettings.java:438: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The settings of the group of the route, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the settings of the group of the route, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:233: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The factory of the tables of the targets that the locator routes of the assembly
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the factory of the tables of the targets that the locator routes of the assembly'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:247: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return What the router asks the server for a request, e.g. the body for a route locator
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns what the router asks the server for a request, e.g. the body for a route locator.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:254: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The URI routes
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI routes.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:261: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The status routes
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the status routes.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:268: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The error routes
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the error routes.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:304: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The ports the routes are exposed on, a read-only view
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the ports the routes are exposed on, a read-only view.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:966: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The filters, to add the request and response filters to
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the filters, to add the request and response filters to.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:973: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param methods The methods of the requests to filter
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:984: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param order The order among the server filters
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:991: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param patternStyle The style of the patterns
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:998: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param appendContextPath Whether the patterns are under the context path
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1074: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param filter The filter, whose executor may be chosen until the filter chain is built
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1098: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether the filters are closed
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the filters are closed.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1132: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The response filters of this level, in the order the filter chain has them, see {@link #chain()}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the response filters of this level, in the order the filter chain has them, see {@link #chain()}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1219: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The enclosing group, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the enclosing group, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1226: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The error routes of this group only, built once
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the error routes of this group only, built once.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1233: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The status routes of this group only, built once
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the status routes of this group only, built once.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1240: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether the group, or an enclosing group, has error or status routes
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the group, or an enclosing group, has error or status routes.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1285: warning: [ObjectToString] DefaultStatusRoute is final and does not override Object.toString, so converting it to a string will print its identity (e.g. `DefaultStatusRoute@4488aabb`) instead of useful information.
Step #3 - "compile-libfuzzer-coverage-x86_64":                     throw new RoutingException("Attempted to register multiple status routes for http status [" + route.statusCode() + "] in a route group: " + route);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                                                                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ObjectToString)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1306: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The annotations and the annotated element of the routes of the group, to add to
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the annotations and the annotated element of the routes of the group, to add to.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1389: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The route selector of the group, or of the closest enclosing group that sets one, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the route selector of the group, or of the closest enclosing group that sets one, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1400: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether the group, or an enclosing group, sets the route selector
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether the group, or an enclosing group, sets the route selector.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1403: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             return selectorSet || enclosing != null && enclosing.declaresSelector();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return selectorSet || (enclosing != null && enclosing.declaresSelector());'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1407: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The order of the group, or of the closest enclosing group that has one, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the order of the group, or of the closest enclosing group that has one, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1445: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The port of the group, or of the closest enclosing group that has one, or {@code null}
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the port of the group, or of the closest enclosing group that has one, or {@code null}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1591: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The settings of the route, which the route info is built from
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the settings of the route, which the route info is built from.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1658: warning: [OperatorPrecedence] Use grouping parenthesis to make the operator precedence explicit
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (settings.isSelectorSet() || group != null && group.declaresSelector()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                           ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/OperatorPrecedence)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (settings.isSelectorSet() || (group != null && group.declaresSelector())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m 1s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteAssembly.java:1821: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The filters of the route in the order the filter chain runs them: the filters of
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the filters of the route in the order the filter chain runs them: the filters of'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/UriRouteMatch.java:55: warning: [MixedMutabilityReturnType] This method returns both mutable and immutable collections or maps from different paths. This may be confusing for users of the method.
Step #3 - "compile-libfuzzer-coverage-x86_64":     default List<Argument<?>> getRequiredArguments() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/MixedMutabilityReturnType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return ImmutableList.copyOf(actualArguments);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/UriRouteMatch.java:72: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The matched HTTP method
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the matched HTTP method.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteMatch.java:42: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The route info
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the route info.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteMatch.java:47: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The variable values following a successful match.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the variable values following a successful match.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m 1s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE/src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteMatch.java:79: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the route match can be executed without passing any additional arguments i.e. via
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/UriRouteInfo.java:41: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The HTTP method for this route
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the HTTP method for this route.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/UriRouteInfo.java:46: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link UriMatchTemplate} used to match URIs
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/UriRouteInfo.java:111: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The port the route listens to, or null if the default port
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the port the route listens to, or null if the default port.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/UriRouteInfo.java:118: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The http method. Is equal to {@link #getHttpMethod()} value for standard http methods.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Returns the http method. Is equal to {@link #getHttpMethod()} value for standard http methods.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/UriRouteInfo.java:180: warning: [InvalidLink] The reference `Router#findClosest(io.micronaut.http.HttpRequest, java.util.function.Consumer)` to a method doesn't resolve to anything. Is it misspelt, or is the parameter list not correct? See https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR654 for documentation on how to form method links.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * {@link Router#findClosest(io.micronaut.http.HttpRequest, java.util.function.Consumer)}, and
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InvalidLink)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/MethodBasedRouteInfo.java:40: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link MethodExecutionHandle}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link MethodExecutionHandle}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteInfo.java:59: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The message body writer, if any.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/router/src/main/java/io/micronaut/web/router/RouteInfo.java:68: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The message body reader. if any.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m 1s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE│█████████████▉·│ 92% EXECUTING [7m 2s]│█████████████▉·│ 92% EXECUTING [7m 3s]│█████████████▉·│ 92% EXECUTING [7m 4s]│█████████████▉·│ 92% EXECUTING [7m 5s]│█████████████▉·│ 92% EXECUTING [7m 6s]│█████████████▉·│ 92% EXECUTING [7m 7s]│█████████████▉·│ 92% EXECUTING [7m 8s]Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │█████████████▉·│ 92% EXECUTING [7m 8s]> IDLE> :micronaut-core:micronaut-router:compileJava> IDLE> IDLE> :micronaut-core:micronaut-router:compileJava > Packing build cache entry│█████████████▉·│ 93% EXECUTING [7m 8s]> :micronaut-core:micronaut-router:compileGroovy> :micronaut-core:micronaut-router:compileGroovy > Resolve dependencies of :mic> :micronaut-core:micronaut-router:compileGroovy > Resolve dependencies of :mic> :micronaut-core:micronaut-router:compileGroovy > Resolve dependencies of :mic> :micronaut-core:micronaut-router:compileGroovy > Resolve dependencies of :mic  (5 lines not showing)> IDLE> IDLE> IDLE│█████████████▉·│ 93% EXECUTING [7m 9s]> :micronaut-core:micronaut-router:compileGroovy > Resolve files of configurati> :micronaut-core:micronaut-router:compileGroovy > Resolve files of configurati> :micronaut-core:micronaut-router:compileGroovy> IDLE│█████████████▉·│ 93% EXECUTING [7m 10s]│█████████████▉·│ 93% EXECUTING [7m 11s]│██████████████·│ 93% EXECUTING [7m 11s]> :micronaut-core:micronaut-router:jar│██████████████▏│ 94% EXECUTING [7m 11s]> :micronaut-core:micronaut-http-server:compileJava> :micronaut-core:micronaut-http-server:compileJava > Resolve files of configur> :micronaut-core:micronaut-http-server:compileJava│██████████████▏│ 94% EXECUTING [7m 12s]│██████████████▏│ 94% EXECUTING [7m 13s]│██████████████▏│ 94% EXECUTING [7m 14s]│██████████████▏│ 94% EXECUTING [7m 15s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-http-server:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:223: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param corsOriginConfiguration CORS Origin configuration for request's HTTP Header origin.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@literal true} if the resolved host is localhost or 127.0.0.1 address and the CORS configuration has any for allowed origins.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:250: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param origin  HTTP Header {@link HttpHeaders#ORIGIN} value.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@literal true} if the resolved host is localhost or 127.0.0.1 and origin is not one of these then deny it.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 15s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:319: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param config   The {@link CorsOriginConfiguration} instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:341: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param exposedHeaders A list of the exposed headers
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:356: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param response The {@link MutableHttpResponse} object
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:363: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param origin   The origin
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:373: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param method   The {@link HttpMethod} object
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:381: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param optionalAllowHeaders A list with optional allow headers
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:400: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param maxAge   The max age
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 16s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsFilter.java:461: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (cached.annotationMetadata() == annotationMetadata) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(cached.annotationMetadata(), annotationMetadata)) {' or 'if (cached.annotationMetadata().equals(annotationMetadata)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 16s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1035: warning: [MixedMutabilityReturnType] This method returns both mutable and immutable collections or maps from different paths. This may be confusing for users of the method.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public Map<String, CorsOriginConfiguration> getConfigurations() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/MixedMutabilityReturnType)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'return ImmutableMap.copyOf(defaultConfiguration);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:291: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The application configuration instance
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the application configuration instance.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:298: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default charset to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default charset to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:305: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default server port
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default server port.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 16s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:312: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default host
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default host.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:328: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Configuration for multipart / file uploads
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns configuration for multipart / file uploads.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:335: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Configuration for CORS
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns configuration for CORS.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:342: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Configuration for the streamed response bodies written without Reactive Streams
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:351: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The maximum request body size
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the maximum request body size.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:358: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The maximum number of bytes from the request that may be buffered if the application requests buffering
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the maximum number of bytes from the request that may be buffered if the application requests buffering.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:365: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default amount of time to allow read operation connections  to remain idle
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default amount of time to allow read operation connections  to remain idle.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:372: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The default amount of time to allow to write operation connections to remain idle
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the default amount of time to allow to write operation connections to remain idle.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:379: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The time to allow an idle connection for
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the time to allow an idle connection for.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:387: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The optional server header value
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the optional server header value.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:394: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the date header should be set
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the date header should be set.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:401: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if exceptions handled by either an error
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if exceptions handled by either an error'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:419: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The host resolution configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the host resolution configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:427: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The host resolution configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the host resolution configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:435: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Which header stores the original client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns which header stores the original client.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:452: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return if dual protocol has been enabled or not
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns if dual protocol has been enabled or not.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:459: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return if redirection from HTTP to HTTPS is enabled or not
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns if redirection from HTTP to HTTPS is enabled or not.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:475: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param defaultCharset The default charset to use
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:633: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param hostResolution The host resolution configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:640: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param localeResolution The locale resolution configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:647: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param clientAddressHeader The header that stores the original client address
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:663: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param dualProtocol the dual protocol (http/https) configuration. Default value ({@value #DEFAULT_DUAL_PROTOCOL}).
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:670: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param httpToHttpsRedirect Set to true to enable redirecting all http requests to the same URL but with
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:737: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if not-found should be returned on missing body. False to return an empty body.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:745: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param notFoundOnMissingBody True if no found should be returned on missing body. False to return an empty body.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:792: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param http10KeepAlive Whether to keep the connection of an HTTP/1.0 keep-alive client
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:818: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param rejectUnsupportedHttpVersions Whether to reject a request of an unsupported HTTP version
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:828: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return the maximum parameter count.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 16s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:836: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param maxParams the maximum parameter count.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:890: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The location to store temporary files
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the location to store temporary files.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:897: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The max file size. Defaults to 1MB
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the max file size. Defaults to 1MB.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:923: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to use disk. Defaults to false.
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to use disk. Defaults to false.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:930: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether to use a mixed upload
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to use a mixed upload.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:937: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The threshold to trigger storage to disk
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the threshold to trigger storage to disk.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1025: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether localhost pass-through is enabled. Defaults to {@value #DEFAULT_LOCALHOST_PASS_THROUGH}.
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1033: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The cors configurations
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the cors configurations.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1046: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return Whether headers should be combined into a single header
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether headers should be combined into a single header.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1089: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The Cross-Origin-Embedder-Policy header value, or {@code null} if not configured
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1108: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The Cross-Origin-Resource-Policy header value, or {@code null} if not configured
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1144: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The host header name
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the host header name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1152: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param hostHeader The header name that stores the host
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1159: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The protocol header name
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the protocol header name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1167: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param protocolHeader The header name that stores the protocol
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1174: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The port header name
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the port header name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1182: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param portHeader The header name that stores the port
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1189: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return If the host header supports a port
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns if the host header supports a port.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1196: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param portInHost True if the host header supports a port
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1204: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The list of hosts to validate the resolved host against.
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the list of hosts to validate the resolved host against.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1211: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param allowedHosts The list of allowed host regex patterns. Any resolved
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1224: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return True if any host headers have been configured
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if any host headers have been configured.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 16s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1411: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return the cache seconds
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the cache seconds.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1426: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The cache control configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the cache control configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1461: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":              * @return True if the cache control should be public
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the cache control should be public.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1490: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The high-water mark, in bytes
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the high-water mark, in bytes.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/HttpServerConfiguration.java:1512: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The heartbeat period of a server-sent events stream, or {@code null} for none
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the heartbeat period of a server-sent events stream, or {@code null} for none.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsOriginConfiguration.java:63: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The allowed origins
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the allowed origins.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsOriginConfiguration.java:81: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return a regular expression for matching Allowed Origins.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns a regular expression for matching Allowed Origins.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsOriginConfiguration.java:130: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The allowed methods
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the allowed methods.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsOriginConfiguration.java:148: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The allowed headers
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the allowed headers.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsOriginConfiguration.java:166: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The exposed headers
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the exposed headers.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsOriginConfiguration.java:184: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether to allow credentials
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns whether to allow credentials.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsOriginConfiguration.java:200: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The max age. A value of -1 indicates no max age
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the max age. A value of -1 indicates no max age.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/cors/CorsOriginConfiguration.java:220: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether to allow private network
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 16s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/util/locale/HttpLocaleResolutionConfiguration.java:30: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The key in the session that stores the locale
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the key in the session that stores the locale.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/util/locale/HttpLocaleResolutionConfiguration.java:35: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The name of the cookie that contains the locale.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the name of the cookie that contains the locale.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/util/locale/HttpLocaleResolutionConfiguration.java:40: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the accept header should be searched for the locale.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the accept header should be searched for the locale.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 16s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/CompletableFutureBodyBinder.java:91: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             future.whenComplete((value, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'future = future.whenComplete((value, error) -> {' or 'var unused = future.whenComplete((value, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 16s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE│██████████████▏│ 94% EXECUTING [7m 17s]/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/multipart/FormFactory.java:89: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The server configuration, for the limits of form content
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 17s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/multipart/FormFactory.java:389: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 latestPieceWritten.whenCompleteAsync((p, t2) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'latestPieceWritten = latestPieceWritten.whenCompleteAsync((p, t2) -> {' or 'var unused = latestPieceWritten.whenCompleteAsync((p, t2) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/multipart/FormFactory.java:428: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 latestPieceWritten.whenCompleteAsync((ps, t) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'latestPieceWritten = latestPieceWritten.whenCompleteAsync((ps, t) -> {' or 'var unused = latestPieceWritten.whenCompleteAsync((ps, t) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 17s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/multipart/FormFactory.java:480: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (pr != null && pr != CLOSED_SENTINEL) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (pr != null && !pr.equals(CLOSED_SENTINEL)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/multipart/FormRouteCompleter.java:113: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Whether the form data is being read, see {@link #start()}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/multipart/FormRouteCompleter.java:230: warning: [TypeParameterUnusedInFormals] Declaring a type parameter that is only used in the return type is a misuse of generics: operations on the type parameter are unchecked, it hides unsafe casts at invocations of the method, and it interacts badly with method overload resolution.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private static <T extends Throwable, R> R sneakyThrow(Throwable t) throws T {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeParameterUnusedInFormals)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 17s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/StoredUploadContent.java:232: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 closeRejected().whenComplete((ignored, closeError) -> settle(null, e, closeError));
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = closeRejected().whenComplete((ignored, closeError) -> settle(null, e, closeError));' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 17s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:83: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return What the content is, in messages: the form field and its name
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns what the content is, in messages: the form field and its name.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:94: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param limit The limit
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the operation that reads the content into memory.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:100: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param destination The destination
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the operation that writes the content to a {@link #createStaging staging file} and'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:107: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param out The stream
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the operation that writes the content to the stream, without closing it.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:113: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The content, moved to the caller
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the content, moved to the caller.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:125: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The limit for content of this field, whatever the caller asks for
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the limit for content of this field, whatever the caller asks for.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:206: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The content, moved to the caller: the content of a file is held to the limit of a
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the content, moved to the caller: the content of a file is held to the limit of a'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:250: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         cleanup.whenComplete((ignored, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'cleanup = cleanup.whenComplete((ignored, error) -> {' or 'var unused = cleanup.whenComplete((ignored, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:298: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         operation.cleanup.whenComplete((ignored, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'operation.cleanup = operation.cleanup.whenComplete((ignored, error) -> {' or 'var unused = operation.cleanup.whenComplete((ignored, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:300: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (current == operation) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(current, operation)) {' or 'if (current.equals(operation)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 17s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/UploadContent.java:425: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (cleanupError != null && cleanupError != error) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (cleanupError != null && !cleanupError.equals(error)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 17s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE/src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/binding/StreamingUploadContent.java:545: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             next.whenComplete((ignored, error) -> {
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'next = next.whenComplete((ignored, error) -> {' or 'var unused = next.whenComplete((ignored, error) -> {' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 17s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE│██████████████▏│ 94% EXECUTING [7m 18s]│██████████████▏│ 94% EXECUTING [7m 19s]│██████████████▏│ 94% EXECUTING [7m 20s]│██████████████▏│ 94% EXECUTING [7m 21s]│██████████████▏│ 94% EXECUTING [7m 22s]│██████████████▏│ 94% EXECUTING [7m 23s]Note: /src/micronaut-core/http-server/src/main/java/io/micronaut/http/server/RouteResult.java uses or overrides a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▏│ 94% EXECUTING [7m 23s]> IDLE> :micronaut-core:micronaut-http-server:compileJava> IDLE> IDLE> :micronaut-core:micronaut-http-server:compileJava > Packing build cache entry│██████████████▎│ 95% EXECUTING [7m 24s]> :micronaut-core:micronaut-http-server:jar│██████████████▍│ 96% EXECUTING [7m 24s]> :micronaut-core:micronaut-http-server-netty:compileJava> :micronaut-core:micronaut-http-server-netty:compileJava > Resolve files of co> :micronaut-core:micronaut-http-server-netty:compileJava > Requesting from rem> :micronaut-core:micronaut-http-server-netty:compileJava│██████████████▍│ 96% EXECUTING [7m 25s]│██████████████▍│ 96% EXECUTING [7m 26s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-core:micronaut-http-server-netty:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpContentSubscriberFactory.java:35: warning: [removal] HttpContentProcessor in io.micronaut.http.server.netty has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     HttpContentProcessor build(NettyHttpRequest request);
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpContentSubscriberFactory.java:35: warning: [removal] HttpContentProcessor in io.micronaut.http.server.netty has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     HttpContentProcessor build(NettyHttpRequest request);
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpContentSubscriberFactory.java:35: warning: [removal] HttpContentProcessor in io.micronaut.http.server.netty has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     HttpContentProcessor build(NettyHttpRequest request);
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpContentSubscriberFactory.java:35: warning: [removal] HttpContentProcessor in io.micronaut.http.server.netty has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     HttpContentProcessor build(NettyHttpRequest request);
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/AbstractNettyHttpRequest.java:140: warning: [removal] isStream() in NettyHttpRequestBuilder has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public boolean isStream() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/AbstractNettyHttpRequest.java:95: warning: [removal] toHttpRequest() in NettyHttpRequestBuilder has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public io.netty.handler.codec.http.HttpRequest toHttpRequest() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/AbstractNettyHttpRequest.java:114: warning: [removal] toStreamHttpRequest() in NettyHttpRequestBuilder has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     public StreamedHttpRequest toStreamHttpRequest() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:702: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (k == HttpAttributes.ROUTE_MATCH.toString()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:702: warning: [removal] ROUTE_MATCH in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (k == HttpAttributes.ROUTE_MATCH.toString()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:707: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (k == HttpAttributes.ROUTE_INFO.toString() || v instanceof String) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:707: warning: [removal] ROUTE_INFO in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (k == HttpAttributes.ROUTE_INFO.toString() || v instanceof String) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:1458: warning: [removal] isStream() in NettyHttpRequestBuilder has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         public boolean isStream() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:1449: warning: [removal] toHttpRequest() in NettyHttpRequestBuilder has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         public io.netty.handler.codec.http. HttpRequest toHttpRequest() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                         ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:1430: warning: [removal] toStreamHttpRequest() in NettyHttpRequestBuilder has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         public StreamedHttpRequest toStreamHttpRequest() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 26s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1649: warning: [removal] isPreferNativeTransport() in EventLoopGroupConfiguration has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":         public boolean isPreferNativeTransport() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 26s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyRequestArgumentSatisfier.java:34: warning: [removal] NettyServerRequestBinderRegistry in io.micronaut.http.server.netty.binders has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     NettyRequestArgumentSatisfier(NettyServerRequestBinderRegistry requestBinderRegistry) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyRequestArgumentSatisfier.java:34: warning: [removal] NettyServerRequestBinderRegistry in io.micronaut.http.server.netty.binders has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     NettyRequestArgumentSatisfier(NettyServerRequestBinderRegistry requestBinderRegistry) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyRequestArgumentSatisfier.java:34: warning: [removal] NettyServerRequestBinderRegistry in io.micronaut.http.server.netty.binders has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     NettyRequestArgumentSatisfier(NettyServerRequestBinderRegistry requestBinderRegistry) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyRequestArgumentSatisfier.java:34: warning: [removal] NettyServerRequestBinderRegistry in io.micronaut.http.server.netty.binders has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":     NettyRequestArgumentSatisfier(NettyServerRequestBinderRegistry requestBinderRegistry) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                   ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/websocket/NettyServerWebSocketHandler.java:497: warning: [removal] HttpAttributes in io.micronaut.http has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                 return originatingRequest.getAttribute(HttpAttributes.PRINCIPAL, Principal.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/websocket/NettyServerWebSocketHandler.java:497: warning: [removal] PRINCIPAL in HttpAttributes has been deprecated and marked for removal
Step #3 - "compile-libfuzzer-coverage-x86_64":                 return originatingRequest.getAttribute(HttpAttributes.PRINCIPAL, Principal.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 26s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE│██████████████▍│ 96% EXECUTING [7m 27s]/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/ServerIdleStateHandler.java:47: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":         ctx.write(msg, promise);
Step #3 - "compile-libfuzzer-coverage-x86_64":                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.write(msg, promise);' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 27s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:388: warning: [TypeParameterShadowing] Found aliased type parameters: T declared in NettyHttpRequest
Step #3 - "compile-libfuzzer-coverage-x86_64":     public <T> Optional<T> getAttribute(CharSequence name, Class<T> type) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/TypeParameterShadowing)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'public <T2> Optional<T2> getAttribute(CharSequence name, Class<T2> type) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 27s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:441: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Obtain a reference to the native Netty HTTP request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns obtain a reference to the native Netty HTTP request.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:448: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The {@link ChannelHandlerContext}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the {@link ChannelHandlerContext}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:457: warning: [DoubleCheckedLocking] Double-checked locking on non-volatile fields is unsafe
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (cookies == null) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DoubleCheckedLocking)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'private volatile NettyCookies nettyCookies;'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:562: warning: [DoubleCheckedLocking] Double-checked locking on non-volatile fields is unsafe
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (bodyConvertor == null) {
Step #3 - "compile-libfuzzer-coverage-x86_64":         ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DoubleCheckedLocking)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'private volatile BodyConvertor bodyConvertor;'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:702: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (k == HttpAttributes.ROUTE_MATCH.toString()) {
Step #3 - "compile-libfuzzer-coverage-x86_64":               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(k, HttpAttributes.ROUTE_MATCH.toString())) {' or 'if (k.equals(HttpAttributes.ROUTE_MATCH.toString())) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:707: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (k == HttpAttributes.ROUTE_INFO.toString() || v instanceof String) {
Step #3 - "compile-libfuzzer-coverage-x86_64":               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(k, HttpAttributes.ROUTE_INFO.toString()) || v instanceof String) {' or 'if (k.equals(HttpAttributes.ROUTE_INFO.toString()) || v instanceof String) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:826: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                             channelHandlerContext.write(new DefaultHttp2PushPromiseFrame(outboundHeaders)
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channelHandlerContext.write(new DefaultHttp2PushPromiseFrame(outboundHeaders)' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:918: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":     public io.netty.handler.codec.http.HttpRequest toHttpRequest() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "this.toHttpRequestWithoutBody()")'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:1081: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (cached == null || cached.contentType != ct) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (cached == null || !Objects.equals(cached.contentType, ct)) {' or 'if (cached == null || !cached.contentType.equals(ct)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:1347: warning: [DoubleCheckedLocking] Double-checked locking on non-volatile fields is unsafe
Step #3 - "compile-libfuzzer-coverage-x86_64":             if (httpParameters == null) {
Step #3 - "compile-libfuzzer-coverage-x86_64":             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/DoubleCheckedLocking)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'private volatile MutableHttpParameters httpParameters;'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:1490: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public abstract Optional<T> convert(ArgumentConversionContext<T> conversionContext, T value);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'abstract Optional<T> convert(ArgumentConversionContext<T> conversionContext, T value);'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:1492: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         protected synchronized Optional<T> convertFromNext(ConversionService conversionService, ArgumentConversionContext<T> conversionContext, T value) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'synchronized Optional<T> convertFromNext(ConversionService conversionService, ArgumentConversionCont'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyHttpRequest.java:1499: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                         if (currentConversionContext == conversionContext) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(currentConversionContext, conversionContext)) {' or 'if (currentConversionContext.equals(conversionContext)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/AbstractNettyHttpRequest.java:145: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The native netty request
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the native netty request.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/AbstractNettyHttpRequest.java:200: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param characterEncoding The character encoding
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the Charset.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/AbstractNettyHttpRequest.java:206: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return the maximum number of parameters.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the maximum number of parameters.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/AbstractNettyHttpRequest.java:211: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return {@code true} if yes, {@code false} otherwise.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns {@code true} if yes, {@code false} otherwise.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/AbstractNettyHttpRequest.java:216: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param uri The URI
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the query string decoder.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/handler/OutboundAccess.java:24: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":  * @since 4.4.0
Step #3 - "compile-libfuzzer-coverage-x86_64":    ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 28s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE│██████████████▍│ 96% EXECUTING [7m 29s]/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/RoutingInBoundHandler.java:105: warning: [AlmostJavadoc] This comment contains Javadoc or HTML tags, but isn't started with a double asterisk (/**); is it meant to be Javadoc?
Step #3 - "compile-libfuzzer-coverage-x86_64":     /*
Step #3 - "compile-libfuzzer-coverage-x86_64":     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/AlmostJavadoc)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '/**'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 29s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/RoutingInBoundHandler.java:193: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":         if (terminateEventPublisher == applicationContext.getEventPublisher(HttpRequestTerminatedEvent.class)) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (terminateEventPublisher.equals(applicationContext.getEventPublisher(HttpRequestTerminatedEvent.class))) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 29s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/RoutingInBoundHandler.java:576: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                 channel.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = channel.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1439: warning: [UnusedVariable] The parameter 'cacheSeconds' is never read.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public FileTypeHandlerConfiguration(@Nullable @Property(name = "netty.responses.file.cache-seconds") Integer cacheSeconds,
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                                      ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedVariable)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1440: warning: [UnusedVariable] The parameter 'isPublic' is never read.
Step #3 - "compile-libfuzzer-coverage-x86_64":                                             @Nullable @Property(name = "netty.responses.file.cache-control.public") Boolean isPublic) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                                                                                                             ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedVariable)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:199: warning: [UnusedVariable] The field 'LOG' is never read.
Step #3 - "compile-libfuzzer-coverage-x86_64":     private static final Logger LOG = LoggerFactory.getLogger(NettyHttpServerConfiguration.class);
Step #3 - "compile-libfuzzer-coverage-x86_64":                                 ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedVariable)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line or 'static { LoggerFactory.getLogger(NettyHttpServerConfiguration.class); }'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 29s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:293: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Sets the server type.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link HttpServerType}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:391: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The pipeline customizers
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the pipeline customizers.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:398: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The fallback protocol to use when negotiating via ALPN
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link ApplicationProtocolNames}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:535: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The Netty child channel options.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.netty.bootstrap.ServerBootstrap#childOption(io.netty.channel.ChannelOption, Object)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:543: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The Netty channel options.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.netty.bootstrap.ServerBootstrap#childOption(io.netty.channel.ChannelOption, Object)}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:551: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Configuration for the worker {@link io.netty.channel.EventLoopGroup}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns configuration for the worker {@link io.netty.channel.EventLoopGroup}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:559: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The file type handler configuration.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:579: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Configuration for the parent {@link io.netty.channel.EventLoopGroup}
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns configuration for the parent {@link io.netty.channel.EventLoopGroup}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:587: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return True if the connection should be kept alive on internal server errors
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the connection should be kept alive on internal server errors.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 29s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1353: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The URI patterns to exclude from the access log.
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the URI patterns to exclude from the access log.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1444: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return the cache seconds
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the cache seconds.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1459: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The cache control configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the cache control configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1497: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":              * @return True if the cache control should be public
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the cache control should be public.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1575: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param preferNativeTransport Set whether to prefer the native transport if available
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1582: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param shutdownQuietPeriod Set the shutdown quiet period
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1591: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param shutdownTimeout Set the shutdown timeout (must be >= shutdownQuietPeriod)
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1600: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @return The number of threads to use
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the number of threads to use.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1689: warning: [MissingSummary] A summary line is required on public/protected Javadocs.
Step #3 - "compile-libfuzzer-coverage-x86_64":          * @param loomCarrier When set to {@code true}, use a special <i>experimental</i> event
Step #3 - "compile-libfuzzer-coverage-x86_64":            ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 29s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/configuration/NettyHttpServerConfiguration.java:1743: warning: [InlineMeSuggester] This deprecated API looks inlineable. If you'd like the body of the API to be automatically inlined to its callers, please annotate it with @InlineMe. NOTE: the suggested fix makes the method final if it was not already.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public NettyListenerConfiguration() {
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/InlineMeSuggester)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '@InlineMe(replacement = "this(\"unknown\")")'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:57: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The message body handler registry.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the message body handler registry.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:62: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The channel outbound handlers
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the channel outbound handlers.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:67: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The application context
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the application context.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:72: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The request argument satisfier
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.micronaut.http.server.binding.RequestArgumentSatisfier}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:80: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The route executor
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.micronaut.http.server.RouteExecutor}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:86: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The media type code registry
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.micronaut.http.codec.MediaTypeCodecRegistry}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:92: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The static resource resolver
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.micronaut.web.router.resource.StaticResourceResolver}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:98: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The executor resolver
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the executor resolver.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:105: warning: [MissingSummary] A summary fragment is required; consider using the value of the @see block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The server SSL builder or {@code null} if none is configured
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* See {@link io.micronaut.http.server.netty.ssl.CertificateProvidedSslBuilder}.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:112: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The channel option factory
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the channel option factory.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:117: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The http compression strategy
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the http compression strategy.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:122: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param embeddedServer The server
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the websocket upgrade handler if present.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:129: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The event loop group registry.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the event loop group registry.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/NettyEmbeddedServices.java:134: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Obtains the router
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns obtains the router.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/ssl/ServerSslBuilder.java:32: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The SSL configuration
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the SSL configuration.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/ssl/ServerSslBuilder.java:37: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return Builds the SSL configuration wrapped inside an optional
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns builds the SSL configuration wrapped inside an optional.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpCompressionStrategy.java:31: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @param response The HTTP response
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns true if the response should be compressed.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpCompressionStrategy.java:37: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The compression level (0-9)
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the compression level (0-9).'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpCompressionStrategy.java:44: warning: [MissingSummary] A summary fragment is required; consider using the value of the @return block as a summary fragment instead.
Step #3 - "compile-libfuzzer-coverage-x86_64":      * @return The maximum size of data that can be encoded using the zstd algorithm.
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s7.2-summary-fragment)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean '* Returns the maximum size of data that can be encoded using the zstd algorithm.'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 29s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE│██████████████▍│ 96% EXECUTING [7m 30s]/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/websocket/NettyServerWebSocketUpgradeHandler.java:332: warning: [EmptyCatch] Caught exceptions should not be ignored
Step #3 - "compile-libfuzzer-coverage-x86_64":             } catch (NoSuchElementException ignored) {
Step #3 - "compile-libfuzzer-coverage-x86_64":               ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://google.github.io/styleguide/javaguide.html#s6.2-caught-exceptions)
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/websocket/NettyServerWebSocketUpgradeHandler.java:346: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":             ctx.writeAndFlush(new CloseWebSocketFrame(CloseReason.INTERNAL_ERROR.getCode(), CloseReason.INTERNAL_ERROR.getReason()));
Step #3 - "compile-libfuzzer-coverage-x86_64":                              ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.writeAndFlush(new CloseWebSocketFrame(CloseReason.INTERNAL_ERROR.getCode(), CloseReason.INTERNAL' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 30s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/websocket/NettyServerWebSocketUpgradeHandler.java:609: warning: [ReferenceEquality] Comparison using reference equality instead of value equality
Step #3 - "compile-libfuzzer-coverage-x86_64":                 if (r == proceed) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                       ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/ReferenceEquality)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'if (Objects.equals(r, proceed)) {' or 'if (r.equals(proceed)) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 30s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:943: warning: [UnusedMethod] Method 'numberOfActiveStreams' is never used.
Step #3 - "compile-libfuzzer-coverage-x86_64":         protected abstract int numberOfActiveStreams();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/UnusedMethod)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 30s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:374: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                             ch.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ch.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 30s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:557: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ctx.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:576: warning: [StatementSwitchToExpressionSwitch] This statement switch can be converted to a new-style arrow switch
Step #3 - "compile-libfuzzer-coverage-x86_64":                     switch (protocol) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                     ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/StatementSwitchToExpressionSwitch)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'switch (protocol) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:622: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         public Http2ServerUpgradeCodecImpl(Http2ConnectionHandler connectionHandler) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Http2ServerUpgradeCodecImpl(Http2ConnectionHandler connectionHandler) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:626: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         public Http2ServerUpgradeCodecImpl(Http2FrameCodec http2Codec, ChannelHandler... handlers) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Http2ServerUpgradeCodecImpl(Http2FrameCodec http2Codec, ChannelHandler... handlers) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 30s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE/src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:937: warning: [FutureReturnValueIgnored] Return value of methods returning Future must be checked. Ignoring returned Futures suppresses exceptions thrown from the code that completes the Future.
Step #3 - "compile-libfuzzer-coverage-x86_64":                         ctx.close();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                  ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/FutureReturnValueIgnored)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'var unused = ctx.close();' or to remove this line?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:943: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         protected abstract int numberOfActiveStreams();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'abstract int numberOfActiveStreams();'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:945: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         protected abstract ChannelFuture goAway();
Step #3 - "compile-libfuzzer-coverage-x86_64":                                          ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'abstract ChannelFuture goAway();'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:951: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public Http2GracefulShutdown(ChannelHandlerContext ctx, Http2ConnectionHandler connectionHandler) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Http2GracefulShutdown(ChannelHandlerContext ctx, Http2ConnectionHandler connectionHandler) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-core/http-server-netty/src/main/java/io/micronaut/http/server/netty/HttpPipelineBuilder.java:970: warning: [EffectivelyPrivate] This declaration has public or protected modifiers, but is effectively private.
Step #3 - "compile-libfuzzer-coverage-x86_64":         public Http3GracefulShutdown(ChannelHandlerContext ctx, AtomicLong maxStreamId) {
Step #3 - "compile-libfuzzer-coverage-x86_64":                ^
Step #3 - "compile-libfuzzer-coverage-x86_64":     (see https://errorprone.info/bugpattern/EffectivelyPrivate)
Step #3 - "compile-libfuzzer-coverage-x86_64":   Did you mean 'Http3GracefulShutdown(ChannelHandlerContext ctx, AtomicLong maxStreamId) {'?
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 30s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE│██████████████▍│ 96% EXECUTING [7m 31s]│██████████████▍│ 96% EXECUTING [7m 32s]│██████████████▍│ 96% EXECUTING [7m 33s]│██████████████▍│ 96% EXECUTING [7m 34s]Note: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Some input files use unchecked or unsafe operations.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:unchecked for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 100 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▍│ 96% EXECUTING [7m 34s]> IDLE> :micronaut-core:micronaut-http-server-netty:compileJava> IDLE> IDLE> :micronaut-core:micronaut-http-server-netty:compileGroovy│██████████████▋│ 97% EXECUTING [7m 34s]> :micronaut-fuzzing-tests:compileJava│██████████████▋│ 97% EXECUTING [7m 35s]> :micronaut-fuzzing-tests:compileJava > Requesting from remote build cache> :micronaut-fuzzing-tests:compileJava│██████████████▋│ 97% EXECUTING [7m 36s]│██████████████▋│ 97% EXECUTING [7m 37s]
Step #3 - "compile-libfuzzer-coverage-x86_64": > Task :micronaut-fuzzing-tests:compileJava
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-fuzzing/fuzzing-tests/src/main/java/io/micronaut/fuzzing/IngredientTarget.java:25: warning: No dictionary defined for fuzz target. Fuzzing may be inefficient!
Step #3 - "compile-libfuzzer-coverage-x86_64": public class IngredientTarget {
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-fuzzing/fuzzing-tests/src/main/java/io/micronaut/fuzzing/sanitizer/TestOutOfBoundsTarget.java:28: warning: No dictionary defined for fuzz target. Fuzzing may be inefficient!
Step #3 - "compile-libfuzzer-coverage-x86_64": public class TestOutOfBoundsTarget {
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-fuzzing/fuzzing-tests/src/main/java/io/micronaut/fuzzing/CpuTestTarget.java:25: warning: No dictionary defined for fuzz target. Fuzzing may be inefficient!
Step #3 - "compile-libfuzzer-coverage-x86_64": public class CpuTestTarget {
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-fuzzing/fuzzing-tests/src/main/java/io/micronaut/fuzzing/http/MediaTypeTarget.java:29: warning: No dictionary defined for fuzz target. Fuzzing may be inefficient!
Step #3 - "compile-libfuzzer-coverage-x86_64": public class MediaTypeTarget {
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-fuzzing/fuzzing-tests/src/main/java/io/micronaut/fuzzing/TestTarget.java:25: warning: No dictionary defined for fuzz target. Fuzzing may be inefficient!
Step #3 - "compile-libfuzzer-coverage-x86_64": public class TestTarget {
Step #3 - "compile-libfuzzer-coverage-x86_64":        ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-fuzzing/fuzzing-tests/src/main/java/io/netty/buffer/PooledByteBufAllocatorFuzzer.java:26: warning: No dictionary defined for fuzz target. Fuzzing may be inefficient!
Step #3 - "compile-libfuzzer-coverage-x86_64": public final class PooledByteBufAllocatorFuzzer extends ByteBufAllocatorFuzzerBase {
Step #3 - "compile-libfuzzer-coverage-x86_64":              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": /src/micronaut-fuzzing/fuzzing-tests/src/main/java/io/netty/buffer/AdaptiveByteBufAllocatorFuzzer.java:28: warning: No dictionary defined for fuzz target. Fuzzing may be inefficient!
Step #3 - "compile-libfuzzer-coverage-x86_64": public final class AdaptiveByteBufAllocatorFuzzer extends ByteBufAllocatorFuzzerBase {
Step #3 - "compile-libfuzzer-coverage-x86_64":              ^
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% EXECUTING [7m 37s]> IDLE> :micronaut-fuzzing-tests:compileJava> IDLE> IDLE│██████████████▋│ 97% EXECUTING [7m 38s]Note: Some input files use or override a deprecated API.
Step #3 - "compile-libfuzzer-coverage-x86_64": Note: Recompile with -Xlint:deprecation for details.
Step #3 - "compile-libfuzzer-coverage-x86_64": 7 warnings
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": │██████████████▋│ 97% EXECUTING [7m 38s]> IDLE> :micronaut-fuzzing-tests:compileJava> IDLE> IDLE│██████████████▋│ 97% EXECUTING [7m 39s]│██████████████▊│ 99% EXECUTING [7m 39s]> :micronaut-fuzzing-tests:jar│██████████████▉│ 99% EXECUTING [7m 39s]> :micronaut-fuzzing-tests:prepareClusterFuzz│██████████████▉│ 99% EXECUTING [7m 40s]│██████████████▉│ 99% EXECUTING [7m 41s]> :micronaut-fuzzing-tests:prepareClusterFuzz > Resolve files of configuration > :micronaut-fuzzing-tests:prepareClusterFuzz > Resolve files of configuration > IDLE> :micronaut-fuzzing-tests:prepareClusterFuzz> :micronaut-fuzzing-tests:prepareClusterFuzz > Resolve dependencies of :micron│██████████████▉│ 99% EXECUTING [7m 42s]> :micronaut-fuzzing-tests:prepareClusterFuzz > Resolve files of configuration > :micronaut-fuzzing-tests:prepareClusterFuzz > Resolve files of configuration > IDLE> :micronaut-fuzzing-tests:prepareClusterFuzz│██████████████▉│ 99% EXECUTING [7m 43s]│██████████████▉│ 99% EXECUTING [7m 44s]
Step #3 - "compile-libfuzzer-coverage-x86_64": [Incubating] Problems report is available at: file:///src/micronaut-fuzzing/build/reports/problems/problems-report.html
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": Deprecated Gradle features were used in this build, making it incompatible with Gradle 10.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": For more on this, please refer to https://docs.gradle.org/9.8.1/userguide/command_line_interface.html#sec:command_line_warnings in the Gradle documentation.
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": BUILD SUCCESSFUL in 7m 54s
Step #3 - "compile-libfuzzer-coverage-x86_64": 155 actionable tasks: 144 executed, 11 from cache
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Step #3 - "compile-libfuzzer-coverage-x86_64": 
Finished Step #3 - "compile-libfuzzer-coverage-x86_64"
Starting Step #4
Step #4: Pulling image: gcr.io/oss-fuzz-base/base-runner
Step #4: Using default tag: latest
Step #4: latest: Pulling from oss-fuzz-base/base-runner
Step #4: b549f31133a9: Already exists
Step #4: 950ef7e48fca: Already exists
Step #4: dbc1400359b3: Already exists
Step #4: 235a783691a7: Pulling fs layer
Step #4: cb9e3373af8a: Pulling fs layer
Step #4: 3147f52c9f08: Pulling fs layer
Step #4: fed57ec86cd8: Pulling fs layer
Step #4: 6e467b1013b8: Pulling fs layer
Step #4: 7ee342a497aa: Pulling fs layer
Step #4: 7b8acf34f499: Pulling fs layer
Step #4: 18651fb0283e: Pulling fs layer
Step #4: ad2f969b9a60: Pulling fs layer
Step #4: b842e07876da: Pulling fs layer
Step #4: 32b555f26cb4: Pulling fs layer
Step #4: 4502bdf86b71: Pulling fs layer
Step #4: 6ada203fdd7d: Pulling fs layer
Step #4: 6af0045a07ba: Pulling fs layer
Step #4: a4b94f4c448b: Pulling fs layer
Step #4: 0645c0271570: Pulling fs layer
Step #4: 394ab25c12f2: Pulling fs layer
Step #4: 3ecd4f7f0d9a: Pulling fs layer
Step #4: b842e07876da: Waiting
Step #4: 36679f7664a6: Pulling fs layer
Step #4: 32b555f26cb4: Waiting
Step #4: d8217a274b75: Pulling fs layer
Step #4: 1436536fabd3: Pulling fs layer
Step #4: 4502bdf86b71: Waiting
Step #4: 14f3f7afd914: Pulling fs layer
Step #4: 1c845da0583a: Pulling fs layer
Step #4: 69051071ea39: Pulling fs layer
Step #4: 6ada203fdd7d: Waiting
Step #4: 45265a2a7264: Pulling fs layer
Step #4: 7b8acf34f499: Waiting
Step #4: 36679f7664a6: Waiting
Step #4: 394ab25c12f2: Waiting
Step #4: d8217a274b75: Waiting
Step #4: 6af0045a07ba: Waiting
Step #4: a4b94f4c448b: Waiting
Step #4: 1436536fabd3: Waiting
Step #4: 3ecd4f7f0d9a: Waiting
Step #4: 14f3f7afd914: Waiting
Step #4: 18651fb0283e: Waiting
Step #4: 1c845da0583a: Waiting
Step #4: ad2f969b9a60: Waiting
Step #4: 45265a2a7264: Waiting
Step #4: 0645c0271570: Waiting
Step #4: 3147f52c9f08: Verifying Checksum
Step #4: 3147f52c9f08: Download complete
Step #4: 6e467b1013b8: Verifying Checksum
Step #4: 6e467b1013b8: Download complete
Step #4: 235a783691a7: Verifying Checksum
Step #4: 235a783691a7: Download complete
Step #4: cb9e3373af8a: Verifying Checksum
Step #4: cb9e3373af8a: Download complete
Step #4: 7b8acf34f499: Verifying Checksum
Step #4: 7b8acf34f499: Download complete
Step #4: fed57ec86cd8: Verifying Checksum
Step #4: fed57ec86cd8: Download complete
Step #4: 18651fb0283e: Verifying Checksum
Step #4: 18651fb0283e: Download complete
Step #4: ad2f969b9a60: Download complete
Step #4: 235a783691a7: Pull complete
Step #4: 6ada203fdd7d: Download complete
Step #4: 4502bdf86b71: Verifying Checksum
Step #4: 4502bdf86b71: Download complete
Step #4: 32b555f26cb4: Verifying Checksum
Step #4: 32b555f26cb4: Download complete
Step #4: a4b94f4c448b: Download complete
Step #4: 7ee342a497aa: Verifying Checksum
Step #4: 7ee342a497aa: Download complete
Step #4: cb9e3373af8a: Pull complete
Step #4: 394ab25c12f2: Verifying Checksum
Step #4: 394ab25c12f2: Download complete
Step #4: 3ecd4f7f0d9a: Download complete
Step #4: 3147f52c9f08: Pull complete
Step #4: 1436536fabd3: Verifying Checksum
Step #4: 1436536fabd3: Download complete
Step #4: b842e07876da: Verifying Checksum
Step #4: b842e07876da: Download complete
Step #4: d8217a274b75: Verifying Checksum
Step #4: d8217a274b75: Download complete
Step #4: fed57ec86cd8: Pull complete
Step #4: 1c845da0583a: Verifying Checksum
Step #4: 1c845da0583a: Download complete
Step #4: 6e467b1013b8: Pull complete
Step #4: 14f3f7afd914: Verifying Checksum
Step #4: 14f3f7afd914: Download complete
Step #4: 45265a2a7264: Verifying Checksum
Step #4: 45265a2a7264: Download complete
Step #4: 36679f7664a6: Verifying Checksum
Step #4: 36679f7664a6: Download complete
Step #4: 6af0045a07ba: Verifying Checksum
Step #4: 6af0045a07ba: Download complete
Step #4: 69051071ea39: Download complete
Step #4: 0645c0271570: Verifying Checksum
Step #4: 0645c0271570: Download complete
Step #4: 7ee342a497aa: Pull complete
Step #4: 7b8acf34f499: Pull complete
Step #4: 18651fb0283e: Pull complete
Step #4: ad2f969b9a60: Pull complete
Step #4: b842e07876da: Pull complete
Step #4: 32b555f26cb4: Pull complete
Step #4: 4502bdf86b71: Pull complete
Step #4: 6ada203fdd7d: Pull complete
Step #4: 6af0045a07ba: Pull complete
Step #4: a4b94f4c448b: Pull complete
Step #4: 0645c0271570: Pull complete
Step #4: 394ab25c12f2: Pull complete
Step #4: 3ecd4f7f0d9a: Pull complete
Step #4: 36679f7664a6: Pull complete
Step #4: d8217a274b75: Pull complete
Step #4: 1436536fabd3: Pull complete
Step #4: 14f3f7afd914: Pull complete
Step #4: 1c845da0583a: Pull complete
Step #4: 69051071ea39: Pull complete
Step #4: 45265a2a7264: Pull complete
Step #4: Digest: sha256:29e4fcca00f6b844d732ee7427e86dae478db7f78d3ef7128ba1505ea4ab7126
Step #4: Status: Downloaded newer image for gcr.io/oss-fuzz-base/base-runner:latest
Step #4: gcr.io/oss-fuzz-base/base-runner:latest
Finished Step #4
Starting Step #5
Step #5: Already have image (with digest): gcr.io/oss-fuzz-base/base-runner
Step #5: [/corpus/Base64DecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Base64DecoderFuzzer.zip or
Step #5:         /corpus/Base64DecoderFuzzer.zip.zip, and cannot find /corpus/Base64DecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Base64DecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/Base64EncoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Base64EncoderFuzzer.zip or
Step #5:         /corpus/Base64EncoderFuzzer.zip.zip, and cannot find /corpus/Base64EncoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Base64EncoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/BrotliDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/BrotliDecoderFuzzer.zip or
Step #5:         /corpus/BrotliDecoderFuzzer.zip.zip, and cannot find /corpus/BrotliDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for BrotliDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/BrotliDecompressorComparisonFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for BrotliDecompressorComparisonFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/BrotliDecompressorFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/BrotliDecompressorFuzzer.zip or
Step #5:         /corpus/BrotliDecompressorFuzzer.zip.zip, and cannot find /corpus/BrotliDecompressorFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for BrotliDecompressorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/BrotliEncoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/BrotliEncoderFuzzer.zip or
Step #5:         /corpus/BrotliEncoderFuzzer.zip.zip, and cannot find /corpus/BrotliEncoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for BrotliEncoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/Bzip2DecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Bzip2DecoderFuzzer.zip or
Step #5:         /corpus/Bzip2DecoderFuzzer.zip.zip, and cannot find /corpus/Bzip2DecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Bzip2DecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/Bzip2DecompressorComparisonFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Bzip2DecompressorComparisonFuzzer.zip or
Step #5:         /corpus/Bzip2DecompressorComparisonFuzzer.zip.zip, and cannot find /corpus/Bzip2DecompressorComparisonFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Bzip2DecompressorComparisonFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/Bzip2DecompressorFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Bzip2DecompressorFuzzer.zip or
Step #5:         /corpus/Bzip2DecompressorFuzzer.zip.zip, and cannot find /corpus/Bzip2DecompressorFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Bzip2DecompressorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/CleartextHttp2ServerUpgradeHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/CleartextHttp2ServerUpgradeHandlerFuzzer.zip or
Step #5:         /corpus/CleartextHttp2ServerUpgradeHandlerFuzzer.zip.zip, and cannot find /corpus/CleartextHttp2ServerUpgradeHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for CleartextHttp2ServerUpgradeHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/CorsHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/CorsHandlerFuzzer.zip or
Step #5:         /corpus/CorsHandlerFuzzer.zip.zip, and cannot find /corpus/CorsHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for CorsHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/DelimiterBasedFrameDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/DelimiterBasedFrameDecoderFuzzer.zip or
Step #5:         /corpus/DelimiterBasedFrameDecoderFuzzer.zip.zip, and cannot find /corpus/DelimiterBasedFrameDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for DelimiterBasedFrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/EmbeddedHttp2Target.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/EmbeddedHttp2Target.zip or
Step #5:         /corpus/EmbeddedHttp2Target.zip.zip, and cannot find /corpus/EmbeddedHttp2Target.zip.ZIP, period.
Step #5: Failed to unpack the corpus for EmbeddedHttp2Target. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/EmbeddedHttpNoValidateTarget.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for EmbeddedHttpNoValidateTarget. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/EmbeddedHttpTarget.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/EmbeddedHttpTarget.zip or
Step #5:         /corpus/EmbeddedHttpTarget.zip.zip, and cannot find /corpus/EmbeddedHttpTarget.zip.ZIP, period.
Step #5: Failed to unpack the corpus for EmbeddedHttpTarget. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/FastLzFrameDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/FastLzFrameDecoderFuzzer.zip or
Step #5:         /corpus/FastLzFrameDecoderFuzzer.zip.zip, and cannot find /corpus/FastLzFrameDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for FastLzFrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/FixedLengthFrameDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/FixedLengthFrameDecoderFuzzer.zip or
Step #5:         /corpus/FixedLengthFrameDecoderFuzzer.zip.zip, and cannot find /corpus/FixedLengthFrameDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for FixedLengthFrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/HAProxyMessageDecoderFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for HAProxyMessageDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/Http2ConnectionHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Http2ConnectionHandlerFuzzer.zip or
Step #5:         /corpus/Http2ConnectionHandlerFuzzer.zip.zip, and cannot find /corpus/Http2ConnectionHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Http2ConnectionHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/Http2FrameCodecFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Http2FrameCodecFuzzer.zip or
Step #5:         /corpus/Http2FrameCodecFuzzer.zip.zip, and cannot find /corpus/Http2FrameCodecFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Http2FrameCodecFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpClientCodecFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpClientCodecFuzzer.zip or
Step #5:         /corpus/HttpClientCodecFuzzer.zip.zip, and cannot find /corpus/HttpClientCodecFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpClientCodecFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpClientUpgradeHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpClientUpgradeHandlerFuzzer.zip or
Step #5:         /corpus/HttpClientUpgradeHandlerFuzzer.zip.zip, and cannot find /corpus/HttpClientUpgradeHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpClientUpgradeHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/HttpContentCompressorFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for HttpContentCompressorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpContentDecompressorFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpContentDecompressorFuzzer.zip or
Step #5:         /corpus/HttpContentDecompressorFuzzer.zip.zip, and cannot find /corpus/HttpContentDecompressorFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpContentDecompressorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpObjectAggregatorFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpObjectAggregatorFuzzer.zip or
Step #5:         /corpus/HttpObjectAggregatorFuzzer.zip.zip, and cannot find /corpus/HttpObjectAggregatorFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpObjectAggregatorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpRequestDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpRequestDecoderFuzzer.zip or
Step #5:         /corpus/HttpRequestDecoderFuzzer.zip.zip, and cannot find /corpus/HttpRequestDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpRequestDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpRequestEncoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpRequestEncoderFuzzer.zip or
Step #5:         /corpus/HttpRequestEncoderFuzzer.zip.zip, and cannot find /corpus/HttpRequestEncoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpRequestEncoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpResponseDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpResponseDecoderFuzzer.zip or
Step #5:         /corpus/HttpResponseDecoderFuzzer.zip.zip, and cannot find /corpus/HttpResponseDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpResponseDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/HttpResponseEncoderFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for HttpResponseEncoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpServerCodecFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpServerCodecFuzzer.zip or
Step #5:         /corpus/HttpServerCodecFuzzer.zip.zip, and cannot find /corpus/HttpServerCodecFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpServerCodecFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpServerExpectContinueHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpServerExpectContinueHandlerFuzzer.zip or
Step #5:         /corpus/HttpServerExpectContinueHandlerFuzzer.zip.zip, and cannot find /corpus/HttpServerExpectContinueHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpServerExpectContinueHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpServerKeepAliveHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpServerKeepAliveHandlerFuzzer.zip or
Step #5:         /corpus/HttpServerKeepAliveHandlerFuzzer.zip.zip, and cannot find /corpus/HttpServerKeepAliveHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpServerKeepAliveHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/HttpServerUpgradeHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/HttpServerUpgradeHandlerFuzzer.zip or
Step #5:         /corpus/HttpServerUpgradeHandlerFuzzer.zip.zip, and cannot find /corpus/HttpServerUpgradeHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for HttpServerUpgradeHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/JZlibDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/JZlibDecoderFuzzer.zip or
Step #5:         /corpus/JZlibDecoderFuzzer.zip.zip, and cannot find /corpus/JZlibDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for JZlibDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/JdkZlibDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/JdkZlibDecoderFuzzer.zip or
Step #5:         /corpus/JdkZlibDecoderFuzzer.zip.zip, and cannot find /corpus/JdkZlibDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for JdkZlibDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/JdkZlibDecompressorComparisonFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/JdkZlibDecompressorComparisonFuzzer.zip or
Step #5:         /corpus/JdkZlibDecompressorComparisonFuzzer.zip.zip, and cannot find /corpus/JdkZlibDecompressorComparisonFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for JdkZlibDecompressorComparisonFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/JdkZlibDecompressorFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for JdkZlibDecompressorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/JsonBeanPropertyBinderTarget.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for JsonBeanPropertyBinderTarget. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/JsonDeserializationTarget.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for JsonDeserializationTarget. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/JsonObjectDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/JsonObjectDecoderFuzzer.zip or
Step #5:         /corpus/JsonObjectDecoderFuzzer.zip.zip, and cannot find /corpus/JsonObjectDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for JsonObjectDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/LengthFieldBasedFrameDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/LengthFieldBasedFrameDecoderFuzzer.zip or
Step #5:         /corpus/LengthFieldBasedFrameDecoderFuzzer.zip.zip, and cannot find /corpus/LengthFieldBasedFrameDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for LengthFieldBasedFrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/LineBasedFrameDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/LineBasedFrameDecoderFuzzer.zip or
Step #5:         /corpus/LineBasedFrameDecoderFuzzer.zip.zip, and cannot find /corpus/LineBasedFrameDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for LineBasedFrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/Lz4FrameDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Lz4FrameDecoderFuzzer.zip or
Step #5:         /corpus/Lz4FrameDecoderFuzzer.zip.zip, and cannot find /corpus/Lz4FrameDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Lz4FrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/Lz4FrameEncoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/Lz4FrameEncoderFuzzer.zip or
Step #5:         /corpus/Lz4FrameEncoderFuzzer.zip.zip, and cannot find /corpus/Lz4FrameEncoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for Lz4FrameEncoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/LzfDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/LzfDecoderFuzzer.zip or
Step #5:         /corpus/LzfDecoderFuzzer.zip.zip, and cannot find /corpus/LzfDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for LzfDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/MultipartTarget.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/MultipartTarget.zip or
Step #5:         /corpus/MultipartTarget.zip.zip, and cannot find /corpus/MultipartTarget.zip.ZIP, period.
Step #5: Failed to unpack the corpus for MultipartTarget. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/PooledByteBufAllocatorFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for PooledByteBufAllocatorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/RedisArrayAggregatorFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for RedisArrayAggregatorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/RedisDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/RedisDecoderFuzzer.zip or
Step #5:         /corpus/RedisDecoderFuzzer.zip.zip, and cannot find /corpus/RedisDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for RedisDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/RtspDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/RtspDecoderFuzzer.zip or
Step #5:         /corpus/RtspDecoderFuzzer.zip.zip, and cannot find /corpus/RtspDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for RtspDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/SnappyFrameDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/SnappyFrameDecoderFuzzer.zip or
Step #5:         /corpus/SnappyFrameDecoderFuzzer.zip.zip, and cannot find /corpus/SnappyFrameDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for SnappyFrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/SnappyFrameEncoderFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for SnappyFrameEncoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/SniHandlerFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for SniHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/SslHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/SslHandlerFuzzer.zip or
Step #5:         /corpus/SslHandlerFuzzer.zip.zip, and cannot find /corpus/SslHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for SslHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/StringDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/StringDecoderFuzzer.zip or
Step #5:         /corpus/StringDecoderFuzzer.zip.zip, and cannot find /corpus/StringDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for StringDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/TypeConversionTarget.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/TypeConversionTarget.zip or
Step #5:         /corpus/TypeConversionTarget.zip.zip, and cannot find /corpus/TypeConversionTarget.zip.ZIP, period.
Step #5: Failed to unpack the corpus for TypeConversionTarget. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/WebSocket08FrameDecoderFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for WebSocket08FrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/WebSocketClientProtocolHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/WebSocketClientProtocolHandlerFuzzer.zip or
Step #5:         /corpus/WebSocketClientProtocolHandlerFuzzer.zip.zip, and cannot find /corpus/WebSocketClientProtocolHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for WebSocketClientProtocolHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/WebSocketFrameAggregatorFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/WebSocketFrameAggregatorFuzzer.zip or
Step #5:         /corpus/WebSocketFrameAggregatorFuzzer.zip.zip, and cannot find /corpus/WebSocketFrameAggregatorFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for WebSocketFrameAggregatorFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/WebSocketServerProtocolHandlerFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/WebSocketServerProtocolHandlerFuzzer.zip or
Step #5:         /corpus/WebSocketServerProtocolHandlerFuzzer.zip.zip, and cannot find /corpus/WebSocketServerProtocolHandlerFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for WebSocketServerProtocolHandlerFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/XmlFrameDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/XmlFrameDecoderFuzzer.zip or
Step #5:         /corpus/XmlFrameDecoderFuzzer.zip.zip, and cannot find /corpus/XmlFrameDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for XmlFrameDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: [/corpus/ZstdDecoderFuzzer.zip]
Step #5:   End-of-central-directory signature not found.  Either this file is not
Step #5:   a zipfile, or it constitutes one disk of a multi-part archive.  In the
Step #5:   latter case the central directory and zipfile comment will be found on
Step #5:   the last disk(s) of this archive.
Step #5: unzip:  cannot find zipfile directory in one of /corpus/ZstdDecoderFuzzer.zip or
Step #5:         /corpus/ZstdDecoderFuzzer.zip.zip, and cannot find /corpus/ZstdDecoderFuzzer.zip.ZIP, period.
Step #5: Failed to unpack the corpus for ZstdDecoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: warning [/corpus/ZstdEncoderFuzzer.zip]:  zipfile is empty
Step #5: Failed to unpack the corpus for ZstdEncoderFuzzer. This usually means that corpus backup for a particular fuzz target does not exist. If a fuzz target was added in the last 24 hours, please wait one more day. Otherwise, something is wrong with the fuzz target or the infrastructure, and corpus pruning task does not finish successfully.
Step #5: ********************************************************************************
Step #5: Code coverage report generation failed.
Step #5: To reproduce, run:
Step #5: python infra/helper.py build_image micronaut
Step #5: python infra/helper.py build_fuzzers --sanitizer coverage micronaut
Step #5: python infra/helper.py coverage micronaut
Step #5: ********************************************************************************
Finished Step #5
ERROR
ERROR: build step 5 "gcr.io/oss-fuzz-base/base-runner" failed: step exited with non-zero status: 1
Step #3 - "compile-libfuzzer-coverage-x86_64": │███████████████│ 100% EXECUTING [7m 44s]> IDLE> IDLE> IDLE> IDLE│···············│ 0% WAITING[?12l[?25h