includeModule('gradle', 'gradle')
            }
        }
    }
}

// We support multiple accepted public api changes JSON files, but "accepted-public-api-changes.json"
// is the "main" one that is also shown in HTML report
def apiChangesJsonDirectory = layout.projectDirectory.dir("src/changes/accepted-changes")

def compatibilityBaselineVersion = gradleModule.identity.releasedVersions.get().mostRecentRelease.version

        }

        fun assertHasAccepted(vararg accepted: String) {
            assertThat("Has accepted", richReport.accepted.map { it.message }, inAnyOrder(accepted))
        }

        fun assertHasAccepted(vararg accepted: Pair<String, List<String>>) {
            assertThat("Has accepted", richReport.accepted, inAnyOrder(accepted.map { ReportMessage(it.first, it.second) }))
        }

occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

## Status

[PROPOSED, ACCEPTED, REJECTED, DEPRECATED, REPLACED]

## Consequences

* X
* Y
* Z
```

## Status

ACCEPTED

## Consequences

* We start to use Architectural Decision Records
* We use the proposed template from this ADR

type httpListener struct {
	opts        TCPOptions
	listeners   []net.Listener    // underlying TCP listeners.
	acceptCh    chan acceptResult // channel where all TCP listeners write accepted connection.
	ctxDoneCh   <-chan struct{}
	ctxCanceler context.CancelFunc
}

// start - starts separate goroutine for each TCP listener.  A valid new connection is passed to httpListener.acceptCh.

This includes adding the description of the changes to the `accepted-public-api-changes.json` file, and providing a reason for each change.
You can add the changes to any place in the file, e.g. at the top.

3. Make sure the file with accepted changes is sorted.\
Use the `./gradlew :architecture-test:sortAcceptedApiChanges` task to sort the file.

 * limitations under the License.
 */
package okhttp3.sse

import okhttp3.Response

abstract class EventSourceListener {
  /**
   * Invoked when an event source has been accepted by the remote peer and may begin transmitting
   * events.
   */
  open fun onOpen(
    eventSource: EventSource,
    response: Response,
  ) {
  }

  open fun onEvent(
    eventSource: EventSource,

testing/architecture-test                   @gradle/bt-architecture-council

# These files change frequently, and changes to them don't need to automatically alert the architecture council
testing/architecture-test/src/changes/accepted-changes/accepted-public-api-changes.json
testing/architecture-test/src/changes/archunit-store/internal-api-nullability.txt

# Core automation platform (core/configuration)
platforms/core-configuration/               @gradle/bt-cortex

	if len(bp.c) > 0 {
		t.Fatal("bytepool should have rejected invalid packets")
	}

	// Try putting a short slice into pool
	bp.Put(make([]byte, bp.w, bp.wcap)[:2])
	if len(bp.c) != 1 {
		t.Fatal("bytepool should have accepted short slice with sufficient capacity")
	}

	b = bp.Get()
	if len(b) != width {
		t.Fatalf("bytepool length invalid: got %v want %v", len(b), width)
	}

	// Close the channel.
	close(bp.c)

Not all client code is compiled with NullAway.
Do not make a parameter `@Nullable` just to check and throw a `NullPointerException` when it is `null`. 

## Status

ACCEPTED

## Consequences

* Classes are forced to have consistent nullability annotations.
* IDE warnings become more accurate, reducing warnings fatigue.
* Public API nullability annotations become closer to reality.

Or you could also pin it with:

```txt
fastapi[standard]>=0.112.0,<0.113.0
```

that would mean that you would use the versions `0.112.0` or above, but less than `0.113.0`, for example, a version `0.112.2` would still be accepted.

If you use any other tool to manage your installations, like `uv`, Poetry, Pipenv, or others, they all have a way that you can use to define specific versions for your packages.

## Available versions { #available-versions }