/**
     * The language of this packaging.
     */
    @Nonnull
    default Language language() {
        return type().getLanguage();
    }

    /**
     * The type of main artifact produced by this packaging.
     */
    @Nonnull
    Type type();

    /**
     * Returns the binding to use specifically for this packaging keyed by lifecycle id.

		if err != nil {
			return fmt.Errorf("external type %s not interpretable: %v", et, err)
		}
		if reflect.TypeOf(obj) != reflect.TypeOf(internalType) {
			return fmt.Errorf("decode of external type %s produced: %#v", et, obj)
		}
		if err = DecodeInto(c, exBytes, internalType); err != nil {
			return fmt.Errorf("external type %s not convertible to internal type: %v", et, err)
		}
	}
	return nil

        when:
        repository.asMappingAction().execute(mapping)

        then:
        0 * mapping._
    }

    def "attaches git repo when requested module matches one of those produced by the repo"() {
        def selector = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId("test", "test2"), "1.2")

                    return new DefaultSwiftcMetadata(line, version);
                }
            }
            throw new BrokenResultException(String.format("Could not determine %s metadata: %s produced unexpected output.", getCompilerType().getDescription(), swiftc.getName()));
        } catch (IOException e) {
            // Should not happen when reading from a StringReader
            throw new UncheckedIOException(e);

     * @since 6.6
     */
    @LocalState
    public RegularFileProperty getClassfileBackupDir() {
        return classfileBackupDir;
    }

    /**
     * Returns the directory or archive path by which the code produced by this task
     * is published to other {@code ScalaCompile} tasks.
     */
    // only an input for other task instances
    @Internal
    public RegularFileProperty getPublishedCode() {
        return publishedCode;

option cc_enable_arenas = true;

// Represents an exported TensorFlow model. It consists of a GraphDef and extra
// metadata required for building a SavedModel. This message is primarily used
// to "export" the model produced from various quantization passes in c++ to
// Python layer.
// Next ID: 11
message ExportedModel {
  reserved 3, 4, 7, 9;
  reserved 'variable_shared_names';
  reserved 'restore_node_name';

        then:
        isolatedProjectsEvents().enabled == [enabled]
        configurationCacheEvents().enabled == [GradleContextualExecuter.configCache || enabled]

        // Ensure events are produced on CC hit as well
        when:
        succeeds("help", "-Dorg.gradle.unsafe.isolated-projects=$enabled")
        then:
        isolatedProjectsEvents().enabled == [enabled]

      // the sense that they're values produced inside this op.
      for (Region& region : op->getRegions()) {
        for (Block& block : region.getBlocks()) {
          for (BlockArgument& arg : block.getArguments()) {
            all_internal_results.insert(arg);
          }
        }
      }
    });
  }

  // All operand values in our set not produced as result by some op in our set.

    }

    /**
     * Expect a deprecation warning to appear when {@link #build()} or {@link #buildAndFail()} is called if the given condition is true.
     *
     * @param condition only expect the warning to be produced when this condition is {@code true}.
     * @param warning the text of the warning to match.
     * @param followup how are we planning to resolve the deprecation before it turns into a breakage;

 *         }
 *     }
 * </pre>
 */
@HasInternalProtocol
public interface NativePlatform extends Platform, Describable {
    /**
     * The cpu architecture being targeted. Defaults to the default architecture produced by the tool chain.
     */
    @Nested
    Architecture getArchitecture();

    /**
     * Sets the cpu architecture being targeted.
     * <p>