return delegate().subSet(fromElement, toElement);
  }

  @Override
  public SortedSet<E> tailSet(@ParametricNullness E fromElement) {
    return delegate().tailSet(fromElement);
  }

  /**
   * A sensible definition of {@link #contains} in terms of the {@code first()} method of {@link
   * #tailSet}. If you override {@link #tailSet}, you may wish to override {@link #contains} to
   * forward to this implementation.
   *

 */

package org.gradle.api.internal.artifacts.ivyservice

import org.gradle.api.internal.component.ArtifactType
import spock.lang.Specification

class ArtifactTypeTest extends Specification {
    def "have sensible toString values"() {
        expect:
        ArtifactType.SOURCES.toString() == "'sources' artifacts"
        ArtifactType.JAVADOC.toString() == "'javadoc' artifacts"

 * 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

                <td><literal>'lib'</literal></td>
            </tr>
            <tr>
                <td>deploymentDescriptor</td>
                <td>A deployment descriptor initialized with sensible defaults</td>
            </tr>
            <tr>
                <td>generateDeploymentDescriptor</td>
                <td><literal>true</literal></td>
            </tr>
        </table>
    </section>

                    ${toolChain.buildScriptConfig}
                }
            }
        """
    }

    def "toolchain is not available when the discovered swift executable does not return sensible output"() {
        def scriptDir = testDirectory.createDir("scriptDir")
        def script = scriptDir.createFile("swiftc")
        script << """
            #!/bin/sh
            echo "foo"
        """

	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
}

      : library(OpRegistry::Global(), FunctionDefLibrary()) {
    session_options.env = Env::Default();
  }

  // Create GraphOptimizationPassOptions with a graph passed in constructor and
  // sensible options.
  GraphOptimizationPassOptions CreateGraphOptimizationPassOptions(
      std::unique_ptr<Graph>* graph) {
    GraphOptimizationPassOptions options;
    options.session_options = &session_options;

            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.
 */

     *
     * @since 6.0
     */
    public abstract Property<Boolean> getGenerateDeploymentDescriptor();

    /**
     * A custom deployment descriptor configuration.
     * Default is an "application.xml" with sensible defaults.
     */
    public abstract DeploymentDescriptor getDeploymentDescriptor();

    public abstract void setDeploymentDescriptor(DeploymentDescriptor deploymentDescriptor);

    /**