@Override
  public boolean equals(@CheckForNull Object object) {
    return delegate().equals(object);
  }

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

  /**
   * A sensible definition of {@link #equals(Object)} in terms of {@link #getKey()} and {@link
   * #getValue()}. If you override either of these methods, you may wish to override {@link
   * #equals(Object)} to forward to this implementation.
   *

  @Override
  protected abstract SortedMultiset<E> delegate();

  @Override
  public SortedSet<E> elementSet() {
    return (SortedSet<E>) super.elementSet();
  }

  /**
   * A sensible implementation of {@link SortedMultiset#elementSet} in terms of the following
   * methods: {@link SortedMultiset#clear}, {@link SortedMultiset#comparator}, {@link

        when:
        run(":printTestSoftwareTypeExtensionConfiguration")

        then:
        assertThatDeclaredValuesAreSetProperly()
    }

    def 'sensible error when model types do not match in software type declaration'() {
        given:
        withSoftwareTypePluginWithMismatchedModelTypes().prepareToExecute()

  @Override
  public boolean equals(@CheckForNull Object object) {
    return delegate().equals(object);
  }

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

  /**
   * A sensible definition of {@link #equals(Object)} in terms of {@link #getKey()} and {@link
   * #getValue()}. If you override either of these methods, you may wish to override {@link
   * #equals(Object)} to forward to this implementation.
   *

 * limitations under the License.
 */

package org.gradle.internal.serialize;

import com.google.common.base.Objects;

/**
 * This abstract class provide a sensible default implementation for {@code Serializer} equality. This equality
 * implementation is required to enable cache instance reuse within the same Gradle runtime. Serializers are used

	var info SysvShmDesc

	_, err := SysvShmCtl(id, IPC_STAT, &info)
	if err != nil {
		// release the shared memory if we can't find the size

		// ignoring error from shmdt as there's nothing sensible to return here
		shmdt(addr)
		return nil, err
	}

	// Use unsafe to convert addr into a []byte.
	b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), int(info.Segsz))
	return b, nil
}

            executer.withTasks("b", "a").withArguments("-x", ":a").run().assertTasksExecuted(":b", ":sub:a")
        }
    }

    def "sensible error message for circular task dependency"() {
        buildFile << """
            task a(dependsOn: 'b')
            task b(dependsOn: 'a')
        """
        expect:
        2.times {

 */
public interface KotlinPlatformComponent

/**
 * An optional [KotlinPlatformComponent]. The Analysis API engine does not require an optional platform component to be implemented and
 * will use sensible fallbacks or disable/avoid certain behaviors instead.
 */

import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.util.Matchers
import spock.lang.Issue

class BuildOperationExecutorIntegrationTest extends AbstractIntegrationSpec {

    def "produces sensible error when there are failures both enqueuing and running operations" () {
        if (JavaVersion.current().isJava9Compatible() && GradleContextualExecuter.isConfigCache()) {

        try {
            File upperCased = new File(file.getPath().toUpperCase(Locale.ROOT));
            return !hasContent(upperCased, content);
        } catch (IOException e) {
            // not fully accurate but a sensible fallback
            // see http://stackoverflow.com/questions/1288102/how-do-i-detect-whether-the-file-system-is-case-sensitive
            boolean result = !new File("foo").equals(new File("FOO"));