* limitations under the License.
 */

package org.gradle.internal.instrumentation.property.upgrades;

import org.gradle.internal.instrumentation.api.annotations.VisitForInstrumentation;

/**
 * Add classes to visit to this registry to enable property upgrade instrumentation.
 *
 * Classes that should be visited should be added to the @VisitForInstrumentation annotation, e.g.

#
# b.1 ---- c.2
#
# If we downgrade module d to version 1, we must downgrade b as well.
# If that downgrade selects b version 1, we will upgrade module c to version 2.

cp go.mod go.mod.orig
go mod tidy
cmp go.mod.orig go.mod

# Downgrading d to version 1 downgrades b, which upgrades c.
go get -v example.com/d@v0.1.0
go list -m all
stdout '^example.com/b v0.1.0 '
stdout '^example.com/c v0.2.0 '

environment variables. If the persisted version differs from the target version,
`migrate-if-needed.sh` will migrate the data from the current to the target
version.

Upgrades to any target version are supported. The data will be automatically upgraded
in steps to each minor version until the target version is reached.

Downgrades to the previous minor version of the 3.x series is supported.

#### Permissions

env GO111MODULE=on

# Populate go.sum
go list -m -mod=mod all

# Check for upgrades.
go list -m -u all
stdout 'rsc.io/quote v1.2.0 \[v1\.5\.2\]'

-- go.mod --
module x

Having tests here breaks Gradle's ability to instrument plugins defined in this subproject and their dependencies when embedded runner is used.
Instrumenting the plugins is important to properly test configuration caching and bytecode upgrades, without it the behavior of the embedded runner doesn't match the normal Gradle execution.

# If that downgrade selects b version 1, we will upgrade module c to version 2.

cp go.mod go.mod.orig
go mod tidy
cmp go.mod.orig go.mod

# Downgrading d to version 1 downgrades b, which upgrades c.
go get example.com/d@v0.1.0
go list -m all
stdout '^example.com/b v0.1.0 '
stdout '^example.com/c v0.2.0 '
stdout '^example.com/d v0.1.0 '
cmp go.mod go.mod.down1

		errorMsg := fmt.Sprintf("unable to upgrade: missing upgrade headers in request: %#v", req.Header)
		http.Error(w, errorMsg, http.StatusBadRequest)
		return nil
	}

	hijacker, ok := w.(http.Hijacker)
	if !ok {
		errorMsg := "unable to upgrade: unable to hijack response"
		http.Error(w, errorMsg, http.StatusInternalServerError)
		return nil
	}

			required, err = reqs.Required(m)
		}

		u := m
		if upgrade != nil {
			upgradeTo, upErr := upgrade(m)
			if upErr == nil {
				u = upgradeTo
			} else if err == nil {
				err = upErr
			}
		}

		mu.Lock()
		if err != nil {
			errs[m] = err
		}
		if u != m {
			upgrades[m] = u
			required = append([]module.Version{u}, required...)
		}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Package with types of interceptors. Currently, we support bytecode upgrades or for configuration cache interceptors.
 */
@org.gradle.api.NonNullApi

See the License for the specific language governing permissions and
limitations under the License.
*/

// Package httpstream adds multiplexed streaming support to HTTP requests and
// responses via connection upgrades.