if err != nil {
			c.Fatalf("normalize err: %v", err)
		}
		return normalizedDN
	}

	actualUserDN := mustNormalizeDN("uid=svc.algorithm,OU=swengg,DC=min,DC=io")

	// \uFE52 is the unicode dot SMALL FULL STOP used below:
	userDNWithUnicodeDot := "uid=svc﹒algorithm,OU=swengg,DC=min,DC=io"

	if err = s.adm.SetPolicy(ctx, policy, userDNWithUnicodeDot, false); err != nil {
		c.Fatalf("Unable to set policy: %v", err)
	}

			wantResult: `{"first":"1","_100":null}`,
		},
		{
			name:       "select-is_null_noresults",
			input:      testInput,
			query:      `select _2 from S3object where _2 IS NULL`,
			wantResult: ``,
		},
		{
			name:  "select-is_null_results",
			input: testInput,
			query: `select _2 from S3object WHERE _100 IS NULL`,
			wantResult: `{"_2":"2010-01-01T"}
{"_2":"2017-01-02T03:04Z"}`,

	}

	toEncode := io.Reader(data)
	if data.Size() >= bigFileThreshold {
		// We use 2 buffers, so we always have a full buffer of input.
		pool := globalBytePoolCap.Load()
		bufA := pool.Get()
		bufB := pool.Get()
		defer pool.Put(bufA)
		defer pool.Put(bufB)

		HTTPStatusCode: http.StatusNotImplemented,
	},
	ErrAdminLDAPExpectedLoginName: {
		Code:           "XMinioLDAPExpectedLoginName",
		Description:    "Expected LDAP short username but was given full DN.",
		HTTPStatusCode: http.StatusBadRequest,
	},
}

// toAPIErrorCode - Converts embedded errors. Convenience
// function written to handle all cases where we have known types of

	if err != nil {
		return nil, err
	}

	if body == nil {
		// this is added to avoid panic during io.ReadAll(req.Body).
		// th stack trace can be found here  https://github.com/minio/minio/pull/2074 .
		// This is very similar to https://github.com/golang/go/issues/7527.
		req.Body = io.NopCloser(bytes.NewReader([]byte("")))
	}

	contentLength := calculateStreamContentLength(dataLength, chunkSize)

	windows := []int{1, 2, 3, 4, 15, 16, 17, 31, 32, 33, 63, 64, 65, 128}
	for i := 0; i <= len(b); i++ {
		for _, window := range windows {
			if window > len(b[i:]) {
				window = len(b[i:])
			}
			// Fill the window with non-match
			for j := 0; j < window; j++ {
				b[i+j] = byte(100)
			}
			// Try to find something that doesn't exist
			p := Count(b[i:i+window], []byte{0})
			if p != 0 {

	// Empty fi.VersionID indicates that versioning is either
	// suspended or disabled on this bucket. RenameData will replace
	// the 'null' version. We add a free-version to track its tiered
	// content for asynchronous deletion.
	//
	// Note: RestoreObject and HealObject requests don't end up replacing the
	// null version and therefore don't require the free-version to track
	// anything

		meta            map[string]string
		versionID       string
		expectDelMarker bool
	}{
		{testBuckets[0], "delete-file", "contentstring", nil, "", true},
		{testBuckets[1], "delete-file", "contentstring", nil, "null", false},
	}
	for _, object := range testObjects {
		md5Bytes := md5.Sum([]byte(object.content))
		_, err := obj.PutObject(context.Background(), object.parentBucket, object.name,

		// sqlserver driver treats NULL and 'NULL' the same
		t.Skip("skip sqlserver")
	}

	type NullModel struct {
		ID      uint
		Content string `gorm:"default:null"`
	}

	type NullStringModel struct {
		ID      uint
		Content string `gorm:"default:'null'"`
		Active  bool   `gorm:"default:false"`
	}

	tableName := "null_string_model"

		return
	}

	// SPECIAL CASE: For service accounts, any valid JSON is allowed as a
	// policy, regardless of whether the number of statements is 0, this
	// includes `null`, `{}` and `{"Statement": null}`. In fact, MinIO Console
	// sends `null` when no policy is set and the intended behavior is that the
	// service account should inherit parent policy.
	//
	// However, for a policy like `{"Statement":[]}`, the intention is to not