Name:      "foo",
					Namespace: "default",
				}.HashCode(),
				model.ConfigKey{
					Kind:      kind.HTTPRoute,
					Name:      "bar",
					Namespace: "default",
				}.HashCode(),
				model.ConfigKey{
					Kind:      kind.HTTPRoute,
					Name:      "baz",
					Namespace: "default",
				}.HashCode(),
			},
		},
	}
	for _, tt := range tests {

    }

    @Override
    public int hashCode() {
        int result = moduleId.hashCode();
        result = 31 * result + (artifact != null ? artifact.hashCode() : 0);
        result = 31 * result + configurations.hashCode();
        result = 31 * result + (patternMatcher != null ? patternMatcher.hashCode() : 0);
        return result;
    }

    assertEquals(
        "A Map's hashCode() should be the sum of those of its entries (where "
            + "a null element in an entry counts as having a hash of zero).",
        expectedHashCode,
        getMap().hashCode());
  }

  private static int hash(Entry<?, ?> e) {
    return (e.getKey() == null ? 0 : e.getKey().hashCode())
        ^ (e.getValue() == null ? 0 : e.getValue().hashCode());
  }

        assertTrue(f1.equals(f2));
        assertTrue(f2.equals(f1));
        assertTrue(f1.hashCode() == f2.hashCode());

        IncludesArtifactFilter f3 = new IncludesArtifactFilter(Arrays.asList("d", "c", "e"));
        assertTrue(f1.equals(f3));
        assertTrue(f1.hashCode() == f3.hashCode());
    }

    override fun equals(other: Any?): Boolean {
        return this === other || other is KaContractConstantValue && other.backingConstantType == backingConstantType
    }

    override fun hashCode(): Int = backingConstantType.hashCode()
}

public typealias KtContractConstantValue = KaContractConstantValue

/**
 * Represents parameter that can be passed to `value` argument of [kotlin.contracts.ContractBuilder.callsInPlace].
 */

    }

    def hash() {
        expect:
        new ModuleDependency("a", null).hashCode() == new ModuleDependency("a", "COMPILE").hashCode()
        new ModuleDependency("a", "").hashCode() == new ModuleDependency("a", "COMPILE").hashCode()
    }

    def shouldNotExportDependencies() {
        expect:
        !(new ModuleDependency("a", "COMPILE").exported)

        strictlyEquals(key1, key2) == equality
        (key1.hashCode() == key2.hashCode()) == hashCode
        (key1.toString() == key2.toString()) == stringRepresentation

        where:
        groupId     | artifactId     | type  | classifier | equality | hashCode | stringRepresentation
        'group-one' | 'artifact-one' | 'jar' | null       | false    | false    | false

    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);
  }

  public void testShort() {
    Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros

    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    private int doComputeHashCode() {
        int result = libraries.hashCode();
        result = 31 * result + bundles.hashCode();
        result = 31 * result + versions.hashCode();
        result = 31 * result + plugins.hashCode();
        return result;
    }

    public boolean isNotEmpty() {

import java.util.Set;

final class DefaultModuleSetExclude implements ModuleSetExclude {
    private final Set<String> modules;
    private final int hashCode;

    DefaultModuleSetExclude(Set<String> modules) {
        this.modules = modules;
        this.hashCode = modules.hashCode();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }