apiVersion: release-notes/v2
kind: bug-fix
area: security
releaseNotes:
  - |

            0.03,
            BloomFilterStrategies.MURMUR128_MITZ_32);

    // Insert "numInsertions" even numbers into the BF.
    for (int i = 0; i < numInsertions * 2; i += 2) {
      bf.put(Integer.toString(i));
    }
    assertApproximateElementCountGuess(bf, numInsertions);

    // Assert that the BF "might" have all of the even numbers.
    for (int i = 0; i < numInsertions * 2; i += 2) {

apiVersion: release-notes/v2
kind: bug-fix
area: networking
issue:
- 23494
releaseNotes:
- |

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that closures inside a generic function are not exported,
// even though not themselves generic.

package main

func Do[T any]() {
	_ = func() string {
		return ""
	}
}

func main() {
	Do[int]()

# The Module field should be populated even if there is an error loading the package.

env GO111MODULE=on

go list -e -f {{.Module}}
stdout '^mod.com$'

-- go.mod --
module mod.com

go 1.16

-- blah.go --
package blah

import _ "embed"

//go:embed README.md

=== "Python 3.8+"

    ```Python hl_lines="1  14"
    {!> ../../../docs_src/body_nested_models/tutorial003.py!}
    ```

With this, even if you receive a request with duplicate data, it will be converted to a set of unique items.

And whenever you output that data, even if the source had duplicates, it will be output as a set of unique items.

And it will be annotated / documented accordingly too.

## Nested Models

@RequiredFeature(feature = GradleMetadataResolveRunner.GRADLE_METADATA, value = "true")
class GradleModuleMetadataAvailableAtIntegrationTest extends AbstractModuleDependencyResolveTest {
    def "resolves available-at variant even if dependency is not transitive"() {
        given:
        repository {
            'org:moduleA:1.0' {
                variants(["api", "runtime"]) {

      } finally {
        monitor.leave();
      }
    } else {
      // It is possible due to races that we are currently in the expected state even though we
      // timed out. e.g. if we weren't event able to grab the lock within the timeout we would never
      // even check the guard. I don't think we care too much about this use case but it could lead
      // to a confusing error message.

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 39366
releaseNotes:
  - |

     * foo = when(direction) {
     *   Direction.NORTH -> 1
     *   Direction.SOUTH -> 2
     *   else -> 3
     * }
     *
     * If when-expression has no subject, then else-branch would be reported as missing even if it is explicitly present:
     *
     * fun test() {
     *     when {
     *         true -> {}
     *         else -> {}
     *     }
     * }
     *