*            // On the other hand, a `KaCallableSignature` carries instantiated type information `(Int) -> String`.
 * }
 * ```
 *
 * Equality of [KaCallableSignature] is derived from its content.
 */
public sealed class KaCallableSignature<out S : KaCallableSymbol> : KaLifetimeOwner {
    /**
     * The original symbol for this signature.
     */

   *   <li>If there is no visible constructor or visible static factory method declared by {@code
   *       C}, {@code C} is skipped for equality test.
   *   <li>Equality test is not performed on method return values unless the method is a visible
   *       static factory method whose return type is {@code C} or {@code C}'s subtype.
   * </ul>
   *

        when:
        createVariable().appendNode(rootNode)

        then:
        new Variable(rootNode.classpathentry[0], fileReferenceFactory) == createVariable()
    }

    def equality() {
        Variable variable = createVariable()
        Variable same = createVariable()
        Variable different = createVariable()
        different.path = '/other'

        expect:

// license that can be found in the LICENSE file.

package test

import "testing"

// Tests to make sure logic simplification rules are correct.

func TestLogic64(t *testing.T) {
	// test values to determine function equality
	values := [...]int64{-1 << 63, 1<<63 - 1, -4, -3, -2, -1, 0, 1, 2, 3, 4}

	// golden functions we use repeatedly
	zero := func(x int64) int64 { return 0 }
	id := func(x int64) int64 { return x }

  }

  /**
   * Sets the default value for {@code type}. The default value isn't used in testing {@link
   * Object#equals} because more than one sample instances are needed for testing inequality. To set
   * distinct values for equality testing, use {@link #setDistinctValues} instead.
   */
  @CanIgnoreReturnValue
  public <T> ClassSanityTester setDefault(Class<T> type, T value) {
    nullPointerTester.setDefault(type, value);

// that A<C.
//
// It is possible to record equality relations between SSA values with SetEqual and check
// equality with Equal. Equality propagates into the transitive closure for the partial
// order so that if we know that A<B<C and later learn that A==D, Ordered will return
// true for D<C.
//
// It is also possible to record inequality relations between nodes with SetNonEqual;

		t.Error("Equal(nil, nil) = false, want true")
	}
	if ms := map[int]int{1: 2}; Equal(m1, ms) {
		t.Errorf("Equal(%v, %v) = true, want false", m1, ms)
	}

	// Comparing NaN for equality is expected to fail.
	mf := map[int]float64{1: 0, 2: math.NaN()}
	if Equal(mf, mf) {
		t.Errorf("Equal(%v, %v) = true, want false", mf, mf)
	}
}

// equal is simply ==.
func equal[T comparable](v1, v2 T) bool {

import static org.gradle.internal.snapshot.CaseSensitivity.CASE_SENSITIVE;

/**
 * Methods for dealing with paths on the file system.
 *
 * There are methods for checking equality and for comparing two paths.
 * All methods for equality and comparing need to be called with the correct case-sensitivity according to the underlying file system.
 *
 * A segment of a path is the part between two file separators.

import org.gradle.internal.serialize.graph.writeFile


internal
fun Encoder.writeClassPath(classPath: ClassPath) {
    // Ensure that the proper type is going to be restored,
    // because it is important for the equality checks.
    if (classPath is TransformedClassPath) {
        writeBoolean(true)
        writeTransformedClassPath(classPath)
    } else {
        writeBoolean(false)
        writeDefaultClassPath(classPath)
    }

        then:
        list.size() == 8
        for (int i = 0; i < 8; i++) {
            assert list.get(i) == i + 1
        }
    }

    def "list equality works"() {
        expect:
        ImmutableFilteredList.allOf([1, 2, 3, 4, 5, 6, 7, 8]) == [1, 2, 3, 4, 5, 6, 7, 8]
        [1, 2, 3, 4, 5, 6, 7, 8] == ImmutableFilteredList.allOf([1, 2, 3, 4, 5, 6, 7, 8])