if _, isZero := rel.Field.ValueOf(ctx, value); !isZero {
				result := reflect.Indirect(rel.Field.ReflectValueOf(ctx, value))
				switch result.Kind() {
				case reflect.Struct:
					reflectResults = reflect.Append(reflectResults, result.Addr())
				case reflect.Slice, reflect.Array:
					for i := 0; i < result.Len(); i++ {
						if elem := result.Index(i); elem.Kind() == reflect.Ptr {

        that actually comes up in the real world. We want to hear the real-world use case so the
        community can discuss and debate whether this feature is actually the *best* way to address
        the real use case, or whether or not a different abstraction might be more appropriate.


        It's okay if you can't provide complete context on a use case. We understand if you are not

            sids[si].type = rpc.names.names[si].sid_type;
            sids[si].domainName = null;

            switch (sids[si].type) {
            case SID_TYPE_USER:
            case SID_TYPE_DOM_GRP:
            case SID_TYPE_DOMAIN:
            case SID_TYPE_ALIAS:
            case SID_TYPE_WKN_GRP:
                final int sid_index = rpc.names.names[si].sid_index;

        switch (algorithm) {
        case COMPRESSION_NONE:
            return "None";
        case COMPRESSION_LZ77:
            return "LZ77";
        case COMPRESSION_LZ77_HUFFMAN:
            return "LZ77+Huffman";
        case COMPRESSION_LZNT1:
            return "LZNT1";
        case COMPRESSION_PATTERN_V1:
            return "Pattern_V1";
        default:

	go func() {
		saveTicker := time.NewTicker(10 * time.Second)
		defer saveTicker.Stop()
		quit := false
		after := time.Minute
		for !quit {
			select {
			case <-saveTicker.C:
			case <-ctx.Done():
				quit = true
			case <-saverQuitCh:
				quit = true
			}

			if quit {
				// save immediately if we are quitting
				after = 0
			}

   * message buffer will be rejected and trigger a [graceful shutdown][close] of this web socket.
   * This method returns false in that case, and in any other case where this web socket is closing,
   * closed, or canceled.
   *
   * This method returns immediately.
   */
  fun send(text: String): Boolean

  /**

func convPartErrToInt(err error) int {
	err = unwrapAll(err)
	switch err {
	case nil:
		return checkPartSuccess
	case errFileNotFound, errFileVersionNotFound:
		return checkPartFileNotFound
	case errFileCorrupt:
		return checkPartFileCorrupt
	case errVolumeNotFound:
		return checkPartVolumeNotFound
	case errDiskNotFound:
		return checkPartDiskNotFound
	default:
		return checkPartUnknown
	}
}

        FileInformation inf;
        switch (this.informationLevel) {
        case FileInformation.FILE_BASIC_INFO:
            inf = new FileBasicInfo();
            break;
        case FileInformation.FILE_STANDARD_INFO:
            inf = new FileStandardInfo();
            break;
        case FileInformation.FILE_INTERNAL_INFO:
            inf = new FileInternalInfo();
            break;

	case DeleteType:
		return time.Unix(0, j.DeleteMarker.ModTime)
	case LegacyType:
		return j.ObjectV1.Stat.ModTime
	}
	return time.Time{}
}

// getVersionID will return the versionID of the underlying version.
func (j xlMetaV2Version) getVersionID() [16]byte {
	switch j.Type {
	case ObjectType:
		return j.ObjectV2.VersionID
	case DeleteType:
		return j.DeleteMarker.VersionID
	case LegacyType:

			}
			_, statErr := obj.GetObjectInfo(ctx, bucketName, objectName, ObjectOptions{
				VersionID: names[i].VersionID,
			})
			switch statErr.(type) {
			case VersionNotFound:
			default:
				t.Errorf("Test %d: Object %s is not removed", testIdx, objectName)
			}
		}
	}
}

func TestDeleteObjectsVersioned(t *testing.T) {