String type = null
            if (it != key) {
                type = StringUtils.substringAfter(it, "@")
            }
            assert dependency.hasType(type)
        }
    }

    void assertOptionalDependencies(String... expected) {
        assertDependencies(optionalDependencies, expected)
    }

    void assertDependencyManagement(String... expected) {

import org.gradle.plugins.signing.signatory.SignatoryProvider;
import org.gradle.security.internal.BaseSignatoryProvider;
import org.gradle.util.internal.ConfigureUtil;

import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asType;

public interface ConfigurableSignatoryProvider<T extends Signatory> extends BaseSignatoryProvider<T>, SignatoryProvider<T> {
    @Override
    default void configure(SigningExtension settings, Closure closure) {

        mavenRepo.module("test", "test-aar", "1.2")
            .hasPackaging('aar')
            .hasType('aar')
            .publish()
        mavenRepo.module("test", "test-thing", "1.2")
            .hasPackaging('thing')
            .hasType('thing')
            .publish()
        mavenRepo.module("test", "test", "1.2")
            .artifact(type: 'aar')
            .artifact(type: 'thing')

            if (leftValue.isMissing()) {
                return leftValue.asType();
            }
            Value<? extends B> rightValue = right.calculateValue(consumer);
            if (rightValue.isMissing()) {
                return rightValue.asType();
            }

    def data_gen():
      for _ in range(255):
        yield {
            'x': ops.convert_to_tensor(
                np.random.uniform(size=(10)).astype('f4')
            ),
            'y': ops.convert_to_tensor(
                np.random.uniform(size=(10)).astype('f4')
            ),
        }

    root = ModelWithAdd()

    temp_path = self.create_tempdir().full_path
    saved_model_save.save(

        static <T> Value<T> ofNullable(@Nullable T value) {
            if (value == null) {
                return MISSING.asType();
            }
            return new Present<>(value);
        }

        static <T> Value<T> missing() {
            return MISSING.asType();
        }

        static <T> Value<T> of(T value) {
            if (value == null) {

    <component name="NewModuleRootManager">
        <output url="file://$MODULE_DIR$/out"/>
        <output-test url="file://$MODULE_DIR$/outTest"/>
        <exclude-output/>
        <orderEntry type="jdk" jdkName="1.6" jdkType="JavaSDK" />
        <content url="file://$MODULE_DIR$">
            <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false"/>

    String groupId
    String artifactId
    String version
    String classifier
    String type
    boolean optional
    Collection<MavenDependencyExclusion> exclusions = []

    MavenDependency hasType(def type) {
        assert this.type == type
        return this
    }

    @Override
    public String toString() {

        mavenHttpRepo.module("test", "provider", "1.0")
            .hasPackaging("pom")
            .hasType("pom")
            .dependsOn("test", "other", "1.0")
            .publish()
            .allowAll()
        mavenHttpRepo.module("test", "other", "1.0")
            .hasPackaging("pom")
            .hasType("pom")
            .publish()
            .allowAll()
    }

    def expectDownloadOtherTypes() {

        assert this.classifier == classifier
    }

    IvyDescriptorArtifact hasConf(def conf) {
        assert this.conf == conf
        return this
    }

    IvyDescriptorArtifact hasType(def type) {
        assert this.type == type
        return this
    }

    String getClassifier() {
        this.mavenAttributes.get("classifier")
    }