* is in the Antlr plugin which comes bundled with a version of Antlr but the user often times needs
     * to use a specific version. We need to make sure the version that they specify takes precedence.
     */
    @Test
    void testMojoWhereInternallyStatedDependencyIsOverriddenByProject() throws Exception {}

    /**

The following table lists these methods in order of highest to lowest precedence (the first one wins):

[cols="~,~,~,~"]
|===
|Priority |Method |Location |Notes

|1
|<<command_line_interface#command_line_interface,Command-line flags>>
|Command line
|Flags have precedence over properties and environment variables

|2
|<<#sec:gradle_system_properties,System properties>>

type jwtTokenGenerator struct {
	iss    string
	signer jose.Signer
}

func (j *jwtTokenGenerator) GenerateToken(claims *jwt.Claims, privateClaims interface{}) (string, error) {
	// claims are applied in reverse precedence
	return jwt.Signed(j.signer).
		Claims(privateClaims).
		Claims(claims).
		Claims(&jwt.Claims{
			Issuer: j.iss,
		}).
		CompactSerialize()
}

                    for param in parameters
                    if param.get("required")
                }
                # Make sure required definitions of the same parameter take precedence
                # over non-required definitions
                all_parameters.update(required_parameters)
                operation["parameters"] = list(all_parameters.values())
            if method in METHODS_WITH_BODY:

    Processing][uts46]. With this fix, the `ß` code point no longer maps to `ss`. OkHttp now embeds
    its own IDN mapping table in the library.

 *  New: Prefer the client's configured precedence order for TLS cipher suites. (OkHttp used to
    prefer the JDK’s precedence order.) This change may cause your HTTP calls to negotiate a
    different cipher suite than before! OkHttp's defaults cipher suites are selected for good
    security and performance.

=== Consequences of using strict versions

Using a strict version must be carefully considered, in particular by library authors.
As the _producer_, a strict version will effectively behave like a _force_: the version declaration takes precedence over whatever is found in the transitive dependency graph.
In particular, a _strict version_ will override any other _strict version_ on the same module found transitively.

    def setup() {
        // Avoid mixing JUnit dependencies with the ones from the JVM running this test
        // For example, when using PTS/TD for running this test, the JUnit Platform Launcher classes from the GE plugin take precedence
        toolingApi.requireDaemons()
        progressEventCollector = new ProgressEventCollector()
    }

    def "Emits test failure events for Junit 3 tests"() {
        setup:
        buildFile << """

		if f {
			vs := old.Spec.(*networking.VirtualService)
			vs.Http = append(vs.Http, httpRoutes...)
		} else {
			ingressByHost[host] = &virtualServiceConfig
		}

		// sort routes to meet ingress route precedence requirements
		// see https://kubernetes.io/docs/concepts/services-networking/ingress/#multiple-matches
		vs := ingressByHost[host].Spec.(*networking.VirtualService)
		sort.SliceStable(vs.Http, func(i, j int) bool {

                newLine();
            } finally {
                depth--;
            }

            if (spec.isShowAttributePrecedence()) {
                writeDescription("(#): Attribute disambiguation precedence");
                newLine();
            }
        }
    }

    private void writeLegend(List<ReportConfiguration> configs) {

			case err == ErrShortSrc && r.src1-r.src0 != len(r.src) && r.err == nil:
				// Read more bytes into src via the code below, and try again.
			default:
				r.transformComplete = true
				// The reader error (r.err) takes precedence over the
				// transformer error (err) unless r.err is nil or io.EOF.
				if r.err == nil || r.err == io.EOF {
					r.err = err
				}
				continue
			}
		}