import org.gradle.tooling.model.eclipse.EclipseProject

class ToolingApiEclipseModelCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    def "can customize model late in the configuration phase"() {
        projectDir.file('build.gradle').text = """
apply plugin: 'java'

gradle.projectsEvaluated {
    ${mavenCentralRepository()}
}
dependencies {

  /**
   * Close connection after reading the request but before writing the response. Use this to
   * simulate late connection pool failures.
   */
  object DisconnectAfterRequest : SocketPolicy

  /**
   * Half close connection (InputStream for client) after reading the request but before
   * writing the response. Use this to simulate late connection pool failures.
   */
  object HalfCloseAfterRequest : SocketPolicy

configureIde(TestType.INTEGRATION)

createTestTask("integMultiVersionTest", "forking", sourceSet, TestType.INTEGRATION) {
    // This test task runs only multi-version tests and is intended to be used in the late pipeline to sweep up versions not previously tested
    includeSpockAnnotation("org.gradle.integtests.fixtures.compatibility.MultiVersionTestCategory")
    (options as JUnitPlatformOptions).includeEngines("spock")

}

// recordCall records a call from ODCLFUNC node "from", to function
// symbol "to" at position pos.
//
// This should be done as late as possible during compilation to
// capture precise call graphs. The target of the call is an LSym
// because that's all we know after we start SSA.
//
// This can be called concurrently for different from Nodes.

        then:
        thrown NullPointerException

        when:
        deferrable.completeAndGet()
        then:
        thrown NullPointerException
    }

    def "mapping deferred to null fails late"() {
        when:
        def deferrable = Deferrable.deferred(() -> "value").map(result -> null)
        then:
        noExceptionThrown()

        when:
        def result = deferrable.getCompleted()

 *   and therefore these locations should not be watched to cut down on the number of watchers needed.
 *
 * - Locations known to be modified during a build might receive late file events that would invalidate VFS state we just
 *   captured after the changes; to avoid this, after a known modification we assume no further modifications will

 * beforeLocking callback method is called, the previous incorrect behavior of the ArtifactView was to select without
 * considering these attributes.  This has been corrected to use a "live" view
 * of the attributes, to ensure that late changes to the attributes are reflected in the selection.
 *
 * These tests use the `java-library` plugin and should resolve the secondary "classes" variant of the producer

            // most cases. We could create an empty attribute set directly in the AbstractDependencyImpl,
            // but then it wouldn't be mutable. Therefore we proceed with "late injection" of the attributes
            ((AbstractDependencyImpl<?>) dependencyMetadata).setAttributes(attributesFactory.mutable());
        }

        T adapted = adapt(dependencyMetadata);

}

// formatURL formats a URL from args.  For testability.
func formatURL(scheme string, host string, port int, path string) *url.URL {
	u, err := url.Parse(path)
	// Something is busted with the path, but it's too late to reject it. Pass it along as is.
	//
	// This construction of a URL may be wrong in some cases, but it preserves
	// legacy prober behavior.
	if err != nil {
		u = &url.URL{
			Path: path,
		}
	}

(CMNWconst [c] x) && !isARM64addcon(int64(c))  => (CMNW x (MOVDconst [int64(c)]))

(ADDSconstflags [c] x) && !isARM64addcon(c)  => (ADDSflags x (MOVDconst [c]))

// These rules remove unneeded sign/zero extensions.
// They occur in late lower because they rely on the fact
// that their arguments don't get rewritten to a non-extended opcode instead.

// Boolean-generating instructions (NOTE: NOT all boolean Values) always