* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.integtests.fixtures

import groovy.transform.EqualsAndHashCode
import groovy.transform.ToString
import org.gradle.integtests.fixtures.TestClassExecutionResult.TestCase
import org.gradle.test.fixtures.file.TestFile
import org.hamcrest.Matcher

import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode
import org.gradle.initialization.ParallelismBuildOptions
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.profiler.BuildAction
import org.gradle.profiler.gradle.RunTasksAction

@CompileStatic
@EqualsAndHashCode
class GradleInvocationSpec implements InvocationSpec {

class AddressTest {
  private val factory =
    TestValueFactory().apply {
      uriHost = "example.com"
      uriPort = 80
    }

  @AfterEach fun tearDown() {
    factory.close()
  }

  @Test fun equalsAndHashcode() {
    val a = factory.newAddress()
    val b = factory.newAddress()
    assertThat(b).isEqualTo(a)
    assertThat(b.hashCode()).isEqualTo(a.hashCode())
  }

  @Test fun differentProxySelectorsAreDifferent() {

        expect:
        // Note: buildTime is null when running a local build
        version.buildTimestamp == null || version.buildTimestamp.endsWith("UTC")
    }

    def equalsAndHashCode() {
        expect:
        Matchers.strictlyEquals(GradleVersion.version('0.9'), GradleVersion.version('0.9'))
        GradleVersion.version('0.9') != GradleVersion.version('1.0')
    }

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

package org.gradle.internal.properties.bean

import groovy.transform.EqualsAndHashCode
import org.gradle.api.DefaultTask
import org.gradle.api.Named
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.FileCollection
import org.gradle.api.internal.TaskInternal

      )
    assertThat(tlsSpec.isCompatible(socket)).isTrue()
    socket.enabledProtocols = arrayOf(TlsVersion.TLS_1_1.javaName)
    assertThat(tlsSpec.isCompatible(socket)).isFalse()
  }

  @Test
  fun equalsAndHashCode() {
    val allCipherSuites =
      ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
        .allEnabledCipherSuites()
        .build()
    val allTlsVersions =

 * limitations under the License.
 */

package org.gradle.internal.properties.annotations

import com.google.common.reflect.TypeToken
import groovy.transform.EqualsAndHashCode
import org.gradle.api.Named
import org.gradle.api.provider.Property
import org.gradle.api.provider.Provider
import org.gradle.internal.reflect.annotations.Ignored
import org.gradle.internal.reflect.annotations.Long

            includeBuild 'includedBuild'
        """
        buildFile << """
            enum SomeEnum { free, paid }
            interface Thing extends Named { }
            @groovy.transform.EqualsAndHashCode
            class OtherThing implements Thing, Serializable { String name }

            def flavor = Attribute.of('flavor', $type)
            allprojects {
                dependencies {

        resolvedDependency.getAllArtifacts(parentResolvedDependency1) == expectedArtifacts
    }

    def equalsAndHashCode() {
        when:
        DefaultResolvedDependency dependency = new DefaultResolvedDependency("config", newId("group", "name", "version"), buildOperationProcessor)

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

package org.gradle.integtests.resolve.transform

import groovy.transform.EqualsAndHashCode
import org.gradle.api.artifacts.transform.InputArtifact
import org.gradle.api.artifacts.transform.TransformAction
import org.gradle.api.artifacts.transform.TransformOutputs