v.ioStats[d] = getDriveIOStatMetrics(getDiffStats(ps, cs), duration)
					}
				}
			}
		}

		prevDriveIOStats = currentStats
		prevDriveIOStatsRefreshedAt = now
		prevDriveIOStatsMu.Unlock()

		return v, err
	}

	return cachevalue.NewFromFunc(1*time.Minute,
		cachevalue.Opts{ReturnLastGood: true},
		loadDriveMetrics)
}

    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
  }

  public void testListenerCalledOnException() throws Exception {
    throwException = true;

    // Start up the task and unblock the latch to finish the task.
    exec.execute(task);
    runLatch.await();
    taskLatch.countDown();

    ExecutionException e = assertThrows(ExecutionException.class, () -> task.get(5, SECONDS));

            leases.put(newKey, newEntry);
            pathToLease.put(path, newKey);
            
            return newKey;
        } finally {
            lock.writeLock().unlock();
        }
    }
    
    public void updateLease(Smb2LeaseKey key, int grantedState) {
        LeaseEntry entry = leases.get(key);
        if (entry != null) {
            entry.updateState(grantedState);

	globalObjLayerMutex.Lock()
	globalObjectAPI = nil
	globalObjLayerMutex.Unlock()
}

// reset the value of the Global server config.
// set it to `nil`.
func resetGlobalConfig() {
	// hold the mutex lock before a new config is assigned.
	globalServerConfigMu.Lock()
	// Save the loaded config globally.
	globalServerConfig = nil
	globalServerConfigMu.Unlock()
}

func resetGlobalEndpoints() {

		ch <- metric
	}
}

// LockAndSetBuckets - locks the buckets and sets the given buckets. It returns
// a function to unlock the buckets.
func (mg *MetricsGroup) LockAndSetBuckets(buckets []string) func() {
	mg.bucketsLock.Lock()
	mg.buckets = buckets
	return func() {
		mg.bucketsLock.Unlock()
	}
}

// MetricFQN - returns the fully qualified name for the given metric name.

}

func (d *naughtyDisk) Close() (err error) {
	if err = d.calcError(); err != nil {
		return err
	}
	return d.disk.Close()
}

func (d *naughtyDisk) calcError() (err error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	d.callNR++
	if err, ok := d.errors[d.callNR]; ok {
		return err
	}
	if d.defaultErr != nil {
		return d.defaultErr
	}
	return nil
}

	siteLK.Lock()
	s.name = n.name
	s.region = n.region
	siteLK.Unlock()
}

// Name returns currently configured site name
func (s *Site) Name() string {
	siteLK.RLock()
	defer siteLK.RUnlock()

	return s.name
}

// Region returns currently configured site region
func (s *Site) Region() string {
	siteLK.RLock()
	defer siteLK.RUnlock()

	return s.region
}

         */
        public short time_hi_and_version;
        /**
         * The high field of the clock sequence multiplexed with the variant.
         */
        public byte clock_seq_hi_and_reserved;
        /**
         * The low field of the clock sequence.
         */
        public byte clock_seq_low;
        /**
         * The spatially unique node identifier (6 bytes).
         */

        void testExclusiveLockFlag() {
            assertEquals(0x2, Smb2Lock.SMB2_LOCKFLAG_EXCLUSIVE_LOCK);
        }

        @Test
        @DisplayName("Should have correct unlock flag value")
        void testUnlockFlag() {
            assertEquals(0x4, Smb2Lock.SMB2_LOCKFLAG_UNLOCK);
        }

        @Test
        @DisplayName("Should have correct fail immediately flag value")

	return func(endpoint Endpoint, err error, once bool) {
		reqInfo := (&logger.ReqInfo{}).AppendTags("endpoint", endpoint.String())
		ctx := logger.SetReqInfo(GlobalContext, reqInfo)
		mutex.Lock()
		defer mutex.Unlock()

		m, ok := printOnce[endpoint]
		if !ok {
			m = make(map[string]int)
			printOnce[endpoint] = m
			if once {
				m[err.Error()]++
				peersLogAlwaysIf(ctx, err)
				return
			}
		}