when:
        MavenArtifact mavenArtifact = Mock()
        def output = parser.parseNotation(mavenArtifact)

        then:
        output == mavenArtifact
    }

    def "creates MavenArtifact for PublishArtifact"() {
        when:
        def mavenArtifact = parser.parseNotation(publishArtifact)

        then:
        mavenArtifact.extension == publishArtifact.extension

import com.intellij.openapi.project.Project
import com.intellij.openapi.util.ModificationTracker
import org.jetbrains.kotlin.analysis.api.platform.KotlinPlatformComponent

/**
 * [KotlinModificationTrackerFactory] creates modification trackers for select modification events.
 *
 * Further modification tracking is implemented with a subscription-based mechanism via [KotlinModificationTopics]. Modification trackers make the most

def ResultList : NativeCodeCall<"llvm::SmallVector<Value>{$0...}">;

// Creates a list of NamedAttributes. An example usage would be:
// (NamedAttributeList (NamedAttr<"transpose_a"> $transpose_a))
def NamedAttributeList : NativeCodeCall<"llvm::SmallVector<NamedAttribute>{$0...}">;

// Creates a NamedAttribute given its name and value. Essentially creates
// a pair: {attribute_name, attribute_value}.
class NamedAttr<string attr_name> :

    private final String message;

    private final String simpleMessage;

    /**
     * Creates {@link ClRuntimeException}.
     *
     * @param messageCode message code
     */
    public ClRuntimeException(final String messageCode) {
        this(messageCode, new Object[0], null);
    }

    /**
     * Creates {@link ClRuntimeException}.
     *
     * @param messageCode message code

import spock.lang.Specification

class PatternStepFactoryTest extends Specification {
    def "creates step for ** wildcard"() {
        expect:
        def step = PatternStepFactory.getStep("**", true);
        step instanceof AnyWildcardPatternStep
        step.matches("anything")
        step.matches("")
    }

    def "creates step for * wildcard"() {
        expect:
        def step = PatternStepFactory.getStep("*", true);

    def "defaults to Kotlin build scripts"() {
        when:
        run ('init', '--type', 'java-application')

        then:
        dslFixtureFor(KOTLIN).assertGradleFilesGenerated()
    }

    def "creates sample source if no source present with #scriptDsl build scripts"() {
        def dslFixture = dslFixtureFor(scriptDsl)

        when:

  Optional<Integer> expectedNodeCount = Optional.absent();

  /**
   * Creates a new instance with the specified edge directionality.
   *
   * @param directed if true, creates an instance for graphs whose edges are each directed; if
   *     false, creates an instance for graphs whose edges are each undirected.
   */
  AbstractGraphBuilder(boolean directed) {
    this.directed = directed;

    private List<Server> servers;

    private List<Proxy> proxies;

    /**
     * Creates an empty request.
     */
    public DefaultSettingsDecryptionRequest() {
        // does nothing
    }

    /**
     * Creates a new request to decrypt the specified settings.
     *
     * @param settings The settings to decrypt, must not be {@code null}.
     */

    }

    void "creates a dependency from some notation"() {
        Dependency dependency = Mock()

        when:
        def result = dependencyHandler.create("someNotation")

        then:
        result == dependency

        and:
        1 * dependencyFactory.createDependency("someNotation") >> dependency
    }

    void "creates and configures a dependency from some notation"() {

        1 * property.implicitFinalizeValue()
    }

    def "creates value for null value"() {
        expect:
        def value = StaticValue.of(null)
        value.call() == null
        value.taskDependencies == TaskDependencyContainer.EMPTY
        value.attachProducer(Stub(Task))
        value.maybeFinalizeValue()
    }

    def "creates value for other value"() {
        expect: