and:
        def lock = createLock(lockMode)
        def beforeUpdate = lock.state
        lock.close()

        and:
        writeFile(lockManager)
        writeFile(lockManager)

        when:
        lock = createLock(lockMode)
        def afterUpdate = lock.state

        then:
        lock.state.hasBeenUpdatedSince(beforeUpdate)

        when:
        lock.close()

					}
				}
			}
		}
	}
}

// BeforeUpdate before update hooks
func BeforeUpdate(db *gorm.DB) {
	if db.Error == nil && db.Statement.Schema != nil && !db.Statement.SkipHooks && (db.Statement.Schema.BeforeSave || db.Statement.Schema.BeforeUpdate) {
		callMethod(db, func(value interface{}, tx *gorm.DB) (called bool) {
			if db.Statement.Schema.BeforeSave {

import "gorm.io/gorm"

type BeforeCreateInterface interface {
	BeforeCreate(*gorm.DB) error
}

type AfterCreateInterface interface {
	AfterCreate(*gorm.DB) error
}

type BeforeUpdateInterface interface {
	BeforeUpdate(*gorm.DB) error
}

type AfterUpdateInterface interface {
	AfterUpdate(*gorm.DB) error
}

type BeforeSaveInterface interface {
	BeforeSave(*gorm.DB) error
}

type AfterSaveInterface interface {

		if !reflect.Indirect(reflect.ValueOf(user)).FieldByName(str).Interface().(bool) {
			t.Errorf("%v should be true", str)
		}
	}

	for _, str := range []string{"BeforeCreate", "BeforeUpdate", "AfterUpdate", "AfterSave", "BeforeDelete", "AfterDelete", "AfterFind"} {
		if reflect.Indirect(reflect.ValueOf(user)).FieldByName(str).Interface().(bool) {
			t.Errorf("%v should be false", str)
		}
	}

func (s *Product) BeforeCreate(tx *gorm.DB) (err error) {
	if s.Code == "Invalid" {
		err = errors.New("invalid product")
	}
	s.BeforeCreateCallTimes = s.BeforeCreateCallTimes + 1
	return
}

func (s *Product) BeforeUpdate(tx *gorm.DB) (err error) {
	if s.Code == "dont_update" {
		err = errors.New("can't update")
	}
	s.BeforeUpdateCallTimes = s.BeforeUpdateCallTimes + 1
	return
}

     */
    LockState completeUpdate();

    /**
     * Called before an update is complete, returns a new dirty state based on this state.
     */
    LockState beforeUpdate();

        lockStateAccess.writeState(lockFileAccess, newState);
        return newState;
    }

    public LockState markDirty(LockState lockState) throws IOException {
        LockState newState = lockState.beforeUpdate();
        lockStateAccess.writeState(lockFileAccess, newState);
        return newState;
    }

    public void clearLockInfo() throws IOException {
        lockInfoAccess.clearLockInfo(lockFileAccess);
    }

            return false;
        }

        @Override
        public boolean isInInitialState() {
            return false;
        }

        @Override
        public LockState beforeUpdate() {
            return new DirtyFlagLockState(true);
        }

        @Override
        public LockState completeUpdate() {
            return new DirtyFlagLockState(false);
        }

        @Override

	updateCallback.Match(enableTransaction).Register("gorm:begin_transaction", BeginTransaction)
	updateCallback.Register("gorm:setup_reflect_value", SetupUpdateReflectValue)
	updateCallback.Register("gorm:before_update", BeforeUpdate)
	updateCallback.Register("gorm:save_before_associations", SaveBeforeAssociations(false))
	updateCallback.Register("gorm:update", Update(config))

        }

        @Override
        public String toString() {
            return String.format("[%s,%s,%s]", creationNumber, sequenceNumber, isDirty());
        }

        @Override
        public LockState beforeUpdate() {
            return new SequenceNumberLockState(creationNumber, originalSequenceNumber, 0);
        }

        @Override
        public LockState completeUpdate() {
            long newSequenceNumber;