import jcifs.internal.smb2.create.CreateContextResponse;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Durable Handle V2 Response Create Context
 *
 * MS-SMB2 Section 2.2.14.2.4
 */
public class DurableHandleV2Response implements CreateContextResponse {

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

    /**
     * Creates a Lucene Query from this query builder.
     *
     * @param context the query shard context
     * @return the Lucene Query
     * @throws IOException if an I/O error occurs
     */
    @Override
    public Query toQuery(final QueryShardContext context) throws IOException {
        return queryBuilder.toQuery(context);
    }

    /**
     * Returns whether this query builder is a fragment.

			rel, ok := db.Statement.Schema.Relationships.Relations[column]
			if !ok {
				continue
			}

			switch rel.Type {
			case schema.HasOne, schema.HasMany:
				queryConds := rel.ToQueryConditions(db.Statement.Context, db.Statement.ReflectValue)
				modelValue := reflect.New(rel.FieldSchema.ModelType).Interface()
				tx := db.Session(&gorm.Session{NewDB: true}).Model(modelValue)
				withoutConditions := false
				if db.Statement.Unscoped {

		user2 = *GetUser("transaction-nested-2", Config{})
	)

	if err := transaction(context.Background(), DB, func(ctx context.Context, tx *gorm.DB) error {
		tx.Create(&user)

		if err := tx.First(&User{}, "name = ?", user.Name).Error; err != nil {
			t.Fatalf("Should find saved record")
		}

		if err := transaction(ctx, tx, func(ctx context.Context, tx1 *gorm.DB) error {
			tx1.Create(&user1)

     * @param sessionKey
     * @param label
     * @param context
     */
    private static byte[] derive(final byte[] sessionKey, final byte[] label, final byte[] context) {
        final KDFCounterBytesGenerator gen = new KDFCounterBytesGenerator(new HMac(new SHA256Digest()));

        final int r = 32;
        final byte[] suffix = new byte[label.length + context.length + 5];
        // per bouncycastle

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(),

	// 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
	}

	memAvailableMD = NewGaugeMD(memAvailable, "Available memory on the node")
)

// loadMemoryMetrics - `MetricsLoaderFn` for node memory metrics.
func loadMemoryMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	memMetrics, err := c.memoryMetrics.Get()
	if err != nil {
		metricsLogIf(ctx, err)
		return err
	}

	m.Set(memTotal, float64(memMetrics.Total))

        sidSet.add(sid);
        if (type == SID.SID_TYPE_DOM_GRP || type == SID.SID_TYPE_ALIAS) {
            try {
                final CIFSContext context = file.getContext();
                final SID[] children = context.getSIDResolver()
                        .getGroupMemberSids(context, file.getServer(), sid.getDomainSid(), sid.getRid(),
                                org.codelibs.jcifs.smb.impl.SID.SID_FLAG_RESOLVE_SIDS);

	sysCPUSystemMD    = NewGaugeMD(sysCPUSystem, "CPU system time")
	sysCPUUserMD      = NewGaugeMD(sysCPUUser, "CPU user time")
)

// loadCPUMetrics - `MetricsLoaderFn` for system CPU metrics.
func loadCPUMetrics(ctx context.Context, m MetricValues, c *metricsCache) error {
	cpuMetrics, _ := c.cpuMetrics.Get()

	if cpuMetrics.LoadStat != nil {
		m.Set(sysCPULoad, cpuMetrics.LoadStat.Load1)