DefaultCompositeModel(DefaultModel nested) { this.nested = nested }
                BaseModel getNested() { nested }
            }
        """
    }

    def "supports model polymorphism"() {
        given:
        file("plugins/src/main/groovy/my/MyModelBuilder.groovy") << """
            package my

            import org.gradle.tooling.provider.model.ToolingModelBuilder

# Using Dataclasses

FastAPI is built on top of **Pydantic**, and I have been showing you how to use Pydantic models to declare requests and responses.

But FastAPI also supports using <a href="https://docs.python.org/3/library/dataclasses.html" class="external-link" target="_blank">`dataclasses`</a> the same way:

```Python hl_lines="1  7-12  19-20"
{!../../../docs_src/dataclasses/tutorial001.py!}
```

#include "mlir/Pass/Pass.h"  // from @llvm-project

namespace mlir {
namespace odml {

// Adds passes which transform TF_XlaCallModule Op to StableHLO Ops.
// Note that this pass only supports static shape tensors for now.
std::unique_ptr<mlir::OperationPass<ModuleOp>>
CreateLegalizeTFXlaCallModuleToStablehloPass();

}  // namespace odml
}  // namespace mlir

import spock.lang.Specification

import static org.gradle.api.internal.file.TestFiles.fileCollectionFactory

class FixedFileCollectionExecutionTimeValue extends Specification {

    def "FixedFileCollection supports execution time value"() {
        given:
        def collection = fileCollectionFactory().fixed("foo", new File("foo.txt"))

        when:
        def executionTimeValue = collection.calculateExecutionTimeValue()

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// This is a sample chained plugin that supports multiple CNI versions. It
// parses prevResult according to the cniVersion
package plugin

import "errors"

// ErrNotImplemented is returned when a requested feature is not implemented.

		return false, ""
	case "android", "wasip1":
		// For wasip1, some runtimes forbid absolute symlinks,
		// or symlinks that escape the current working directory.
		// Perform a simple test to see whether the runtime
		// supports symlinks or not. If we get a permission
		// error, the runtime does not support symlinks.
		dir, err := os.MkdirTemp("", "")
		if err != nil {
			return false, ""
		}
		defer func() {
			_ = os.RemoveAll(dir)

# MinIO FTP/SFTP Server

MinIO natively supports FTP/SFTP protocol, this allows any ftp/sftp client to upload and download files.

Currently supported `FTP/SFTP` operations are as follows:

| ftp-client commands | supported |
|:-------------------:|:----------|
| get                 | yes       |
| put                 | yes       |
| ls                  | yes       |
| mkdir               | yes       |
| rmdir               | yes       |

import java.util.Locale;

/**
 * This class is emulated in GWT.
 *
 * @author Hayward Chan
 */
@GwtCompatible
final class Platform {

  /** Format the template with args, only supports the placeholder {@code %s}. */
  static String format(String template, Object... args) {
    return String.format(Locale.ROOT, template, args);
  }

  /** See {@link ListListIteratorTester} */

    /**
     * The version of the Zinc compiler to use for compiling Scala code.
     * <p>
     *     Default version is Zinc {@value ScalaBasePlugin#DEFAULT_ZINC_VERSION}.
     * </p>
     *
     * Gradle supports Zinc from 1.6.0.
     *
     * @return zinc compiler version
     * @since 6.0
     */
    Property<String> getZincVersion();

package options

import (
	"fmt"
	"syscall"
)

func permitPortReuse(network, address string, c syscall.RawConn) error {
	return fmt.Errorf("port reuse is not supported on Windows")
}

// Windows supports SO_REUSEADDR, but it may cause undefined behavior, as
// there is no protection against port hijacking.
func permitAddressReuse(network, addr string, conn syscall.RawConn) error {