*/
public interface Platform extends Named {
    @Override
    @Input
    String getName();

    /**
     * Returns a human consumable name for this platform.
     *
     */
    @Internal
    String getDisplayName();

     */
    String getProcessIdentifier();

    /**
     * Returns a display name for this process. Should allow a human to figure out which process the display name refers to.
     */
    String getProcessDisplayName();

 * limitations under the License.
 */

package org.gradle.performance.results;

import javax.annotation.Nullable;
import java.util.List;

public interface ScenarioDefinition {
    /**
     * A human consumable display name for this definition.
     */
    String getDisplayName();

    /**
     * The test project name.
     */
    String getTestProject();

    /**
     * The tasks executed.
     */

        return convertToId(getDisplayName());
    }

    static String convertToId(String displayName) {
        return displayName.replaceAll("[^a-zA-Z0-9]", "-");
    }

    /**
     * A human consumable display name for this performance test.
     */
    default String getDisplayName() {
        return getExperiment().getDisplayName();
    }

    PerformanceExperiment getExperiment();

    /**

        ),
    ] = None,
    title: Annotated[
        Optional[str],
        Doc(
            """
            Human-readable title.
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            Human-readable description.
            """
        ),
    ] = None,
    gt: Annotated[
        Optional[float],
        Doc(

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

/**
 * Types can implement this interface when they provide a human-readable display name.
 * It is strongly encouraged to compute this display name lazily: computing a display name,
 * even if it's only a string concatenation, can take a significant amount of time during

    /**
     * Converts the given path to a relative path.
     */
    String resolveAsRelativePath(Object path);

    /**
     * Converts the given path to a path that is useful to display to a human, for example in logging or error reports.
     * Generally attempts to use a relative path, but may switch to an absolute path for files outside and some distance from the base directory.
     */

 *
 * @implSpec Extending types should be immutable data classes with no nullable fields, they
 * must also be serializable by the configuration cache.
 */
public interface ResolutionFailure {
    /**
     * Returns a human-readable name of the requested component or configuration, for use
     * primarily in error messages.
     *
     * @return the name of the requested component or configuration
     */
    String getRequestedName();

/**
 * A node identifier that uniquely identifies a variant within a component by the variant's name.
 *
 * Note: Generally, variants should be identified by their attributes and capabilities, as the name
 * is more of a human-readable identifier.
 */
public class ComponentVariantNodeIdentifier implements NodeIdentifier {
    private final ComponentIdentifier componentId;
    private final String variantName;

 * limitations under the License.
 */
package okhttp3.logging.internal

import java.io.EOFException
import okio.Buffer

/**
 * Returns true if the body in question probably contains human readable text. Uses a small
 * sample of code points to detect unicode control characters commonly used in binary file
 * signatures.
 */
fun Buffer.isProbablyUtf8(): Boolean {
  try {
    val prefix = Buffer()