}

            group = "com.example"
            version = "1.0"

            // Add an alternate variant
            def alternate = sourceSets.create('alternate')
            java {
                registerFeature(alternate.name) {
                    usingSourceSet(alternate)
                    capability(project.group.toString(), project.name, project.version.toString())
                }

	instructions["JNBE"] = x86.AJHI /* alternate */
	instructions["JNC"] = x86.AJCC  /* alternate */
	instructions["JNE"] = x86.AJNE  /* not equal (ZF = 0) */
	instructions["JNG"] = x86.AJLE  /* alternate */
	instructions["JNGE"] = x86.AJLT /* alternate */
	instructions["JNL"] = x86.AJGE  /* alternate */
	instructions["JNLE"] = x86.AJGT /* alternate */
	instructions["JNO"] = x86.AJOC  /* alternate */

        .url("https://square.com")
        .build()
    assertThat(request.tag<Any>()).isNull()
    assertThat(request.tag(Any::class)).isNull()
    assertThat(request.tag(String::class)).isNull()

    // Alternate access APIs also work.
    assertThat(request.tag<String>()).isNull()
    assertThat(request.tag(String::class)).isNull()
  }

  @Test
  fun defaultTag() {
    val tag = "1234"
    val request =

    assertThat(request.tag()).isNull()
    assertThat(request.tag(Any::class.java)).isNull()
    assertThat(request.tag(UUID::class.java)).isNull()
    assertThat(request.tag(String::class.java)).isNull()

    // Alternate access APIs also work.
    assertThat(request.tag<String>()).isNull()
    assertThat(request.tag(String::class)).isNull()
  }

  @Test
  fun defaultTag() {
    val tag = UUID.randomUUID()

                .longOpt("settings")
                .desc("Alternate path for the user settings file")
                .hasArg()
                .build());
        options.addOption(Option.builder(ALTERNATE_PROJECT_SETTINGS)
                .longOpt("project-settings")
                .desc("Alternate path for the project settings file")
                .hasArg()
                .build());

				// this alternate is the first following verifiedAbsentIdentity lexically
				firstFollowing = &ref
			}
		}
	}

	// return the first alternate identity following the verified absent identity, if there is one
	if firstFollowing != nil {
		return firstFollowing
	}
	// otherwise return the first alternate identity
	return first
}

        } else {
            outputs.recompiledClasses('greeter', 'renamed-sum', 'main')
        }

        outputDirectory.assertContainsDescendants(expectedIntermediateDescendants(app.alternate))
        installation("build/install/main/debug").exec().out == app.expectedAlternateOutput
    }

    def "removes stale object files for library"() {
        def lib = new IncrementalSwiftStaleCompileOutputLib()

                if (it.configurationVariant.name != 'alternate') {
                    skip()
                } else {
                    mapToMavenScope('compile')
                    mapToOptional()
                }
            }

            def alt = configurations.optionalFeatureRuntimeElements.outgoing.variants.create("alternate")
            alt.attributes {

// thread's alternate signal stack and signal mask.
func minitSignals() {
	minitSignalStack()
	minitSignalMask()
}

// minitSignalStack is called when initializing a new m to set the
// alternate signal stack. If the alternate signal stack is not set
// for the thread (the normal case) then set the alternate signal

                if (it.configurationVariant.name != 'alternate') {
                    skip()
                } else {
                    mapToOptional()
                }
            }

            def alt = configurations.optionalFeatureRuntimeElements.outgoing.variants.create("alternate")
            alt.attributes {