// Part size.
	partSize = int64(partSizeFlt)
	if partSize == 0 {
		return minPartSize, nil
	}
	return partSize, nil
}

func (m *warmBackendMinIO) PutWithMeta(ctx context.Context, object string, r io.Reader, length int64, meta map[string]string) (remoteVersionID, error) {
	partSize, err := optimalPartSize(length)
	if err != nil {
		return remoteVersionID(""), err
	}

        }
    }

    /**
     * Sets the query builder for this context.
     * @param queryBuilder The query builder to use.
     */
    public void setQueryBuilder(final QueryBuilder queryBuilder) {
        this.queryBuilder = queryBuilder;
    }

    /**
     * Adds sort builders to the query context.
     * @param sortBuilders Variable number of sort builders to add.
     */

package schema_test

import (
	"context"
	"database/sql"
	"reflect"
	"sync"
	"testing"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils/tests"
)

func TestFieldValuerAndSetter(t *testing.T) {
	var (
		userSchema, _ = schema.Parse(&tests.User{}, &sync.Map{}, schema.NamingStrategy{})
		user          = tests.User{
			Model: gorm.Model{
				ID:        10,
				CreatedAt: time.Now(),

        }
        return new EventSpyRepositoryListener(this, listener);
    }

    public void init(EventSpy.Context context) {
        if (eventSpies.isEmpty()) {
            return;
        }
        for (EventSpy eventSpy : eventSpies) {
            try {
                eventSpy.init(context);
            } catch (Exception | LinkageError e) {
                logError("initialize", e, eventSpy);
            }

import jcifs.smb.SIDCacheImpl;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbNamedPipe;
import jcifs.smb.SmbTransportPoolImpl;

/**
 * Base implementation of CIFS context providing core functionality for SMB operations.
 * This class serves as the foundation for context implementations in the jCIFS library.
 *
 * @author mbechler
 */
public class BaseContext extends AbstractCIFSContext {

    private final Configuration config;

	if err != nil {
		return nil, err
	}
	dialer := &net.Dialer{
		Timeout: 5 * time.Second,
	}
	var res TestGrid
	res.Hosts = hosts
	ready := make(chan struct{})
	ctx, cancel := context.WithCancel(context.Background())
	res.cancel = cancel
	for i, host := range hosts {
		manager, err := NewManager(ctx, ManagerOptions{
			Dialer: ConnectWS(dialer.DialContext,
				dummyNewToken,
				nil),
			Local:        host,

import jcifs.internal.smb2.create.CreateContextResponse;

/**
 * SMB2 Durable Handle Reconnect Response Create Context
 *
 * MS-SMB2 Section 2.2.14.2.5
 */
public class DurableHandleReconnectResponse implements CreateContextResponse {

    /**
     * Context name for durable handle reconnect response
     */
    public static final String CONTEXT_NAME = "DHnC";

	storageClass     string
	bucketName       string
	enableSha256     bool
	enableMultipart  bool
	creds            auth.Credentials
}

// Get the max throughput and iops numbers.
func objectSpeedTest(ctx context.Context, opts speedTestOpts) chan madmin.SpeedTestResult {
	ch := make(chan madmin.SpeedTestResult, 1)
	go func() {
		defer xioutil.SafeClose(ch)

		concurrency := opts.concurrencyStart

		if opts.autotune {

接著你可以在 `templates/item.html` 編寫模板，例如：

```jinja hl_lines="7"
{!../../docs_src/templates/templates/item.html!}
```

### 模板 context 值 { #template-context-values }

在包含以下內容的 HTML 中：

{% raw %}

```jinja
Item ID: {{ id }}
```

{% endraw %}

...它會顯示你在傳入的 context `dict` 中提供的 `id`：

```Python
{"id": id}
```

例如，若 ID 為 `42`，會渲染為：

```html
Item ID: 42
```

	// We should have either a trashed bucket or this
	return metacache{}, errVolumeNotFound
}

// getBucket will get a bucket metacache or load it from disk if needed.
func (m *metacacheManager) getBucket(ctx context.Context, bucket string) *bucketMetacache {
	m.init.Do(m.initManager)

	// Return a transient bucket for invalid or system buckets.
	m.mu.RLock()
	b, ok := m.buckets[bucket]
	if ok {
		m.mu.RUnlock()