isValid:  true,
		},
		{
			version:  version1_8,
			expected: 8,
			errMsg:   nil,
			isValid:  true,
		},
		{
			version:  version1_18,
			expected: 18,
			errMsg:   nil,
			isValid:  true,
		},
		{
			version:  version1_19,
			expected: 19,
			errMsg:   nil,
			isValid:  true,
		},
		{
			version:  version1_20,
			expected: 20,
			errMsg:   nil,

)

func AssertObjEqual(t *testing.T, r, e interface{}, names ...string) {
	for _, name := range names {
		rv := reflect.Indirect(reflect.ValueOf(r))
		ev := reflect.Indirect(reflect.ValueOf(e))
		if rv.IsValid() != ev.IsValid() {
			t.Errorf("%v: expect: %+v, got %+v", utils.FileWithLineNum(), r, e)
			return
		}
		got := rv.FieldByName(name).Interface()
		expect := ev.FieldByName(name).Interface()
		t.Run(name, func(t *testing.T) {

type SourceSelectionCriteria struct {
	ReplicaModifications ReplicaModifications `xml:"ReplicaModifications" json:"ReplicaModifications"`
}

// IsValid - checks whether SourceSelectionCriteria is valid or not.
func (s SourceSelectionCriteria) IsValid() bool {
	return s.ReplicaModifications.Status == Enabled || s.ReplicaModifications.Status == Disabled
}

// Validate source selection criteria

        SecDispatcher.ValidationResponse response = secDispatcher.validateConfiguration();
        if (!response.isValid() || context.invokerRequest.options().verbose().orElse(false)) {
            dumpResponse(context, "", response);
        }
        return response.isValid();
    }

    protected void dumpResponse(

     * @throws SmbException
     */
    public int getFid () throws SmbException {
        if ( !isValid() ) {
            throw new SmbException("Descriptor is no longer valid");
        }
        return this.fid;
    }


    public byte[] getFileId () throws SmbException {
        if ( !isValid() ) {
            throw new SmbException("Descriptor is no longer valid");
        }
        return this.fileId;

func (d Destination) isValidStorageClass() bool {
	if d.StorageClass == "" {
		return true
	}
	return d.StorageClass == "STANDARD" || d.StorageClass == "REDUCED_REDUNDANCY"
}

// IsValid - checks whether Destination is valid or not.
func (d Destination) IsValid() bool {
	return d.Bucket != "" || !d.isValidStorageClass()
}

func (d Destination) String() string {
	return d.ARN
}

            ) : {};

            isValid = qp.state === sentState;

            if ((
              oauth2.auth.schema.get("flow") === "accessCode" ||
              oauth2.auth.schema.get("flow") === "authorizationCode" ||
              oauth2.auth.schema.get("flow") === "authorization_code"
            ) && !oauth2.auth.code) {
                if (!isValid) {
                    oauth2.errCb({

	if err := storageServerRequestValidate(r); err != nil {
		s.writeErrorResponse(w, err)
		return false
	}

	return true
}

// IsValid - To authenticate and check if the disk-id in the request corresponds to the underlying disk.
func (s *storageRESTServer) IsValid(w http.ResponseWriter, r *http.Request) bool {
	if !s.IsAuthValid(w, r) {
		return false
	}

	if err := r.ParseForm(); err != nil {

			for index, e := range etags {
				if partsMetadata[index].IsValid() && e == etag {
					onlineDisks[index] = disks[index]
				} else {
					onlineDisks[index] = nil
				}
			}
			return onlineDisks, modTime, etag
		}
	}

	// Create a new online disks slice, which have common uuid.
	for index, t := range modTimes {
		if partsMetadata[index].IsValid() && t.Equal(modTime) {
			onlineDisks[index] = disks[index]

    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbWatchHandle#watch()
     */
    @Override
    public List<FileNotifyInformation> watch () throws CIFSException {
        if ( !this.handle.isValid() ) {
            throw new SmbException("Watch was broken by tree disconnect");
        }
        try ( SmbTreeHandleImpl th = this.handle.getTree() ) {

            CommonServerMessageBlockRequest req;