log_id bigint NOT NULL
);

ALTER TABLE public.log_usage ALTER COLUMN log_id ADD GENERATED BY DEFAULT AS IDENTITY (
    SEQUENCE NAME public.log_usage_log_id_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1
);
	`).Error; err != nil {
		t.Fatalf("failed to create table, got error %v", err)
	}

	columns, err := DB.Migrator().ColumnTypes("log_usage")

        SmbComNtCancel cancelRequest = mock(SmbComNtCancel.class);

        digest.sign(data, 0, data.length, cancelRequest, null);

        verify(cancelRequest).setSignSeq(10);
        // Sequence should increment by 1 for cancel requests
    }

    @Test
    @DisplayName("Test sign method with null response")
    void testSignWithNullResponse() {

         *
         * @return true if should retry
         */
        public boolean shouldRetry() {
            return retryCount < 3;
        }

        /**
         * Increment retry count and update next retry time
         */
        public void incrementRetry() {
            retryCount++;
            // Exponential backoff: 1s, 2s, 4s

// Input should be root -> object input. Each root indicates a record.
// If r.input is closed, it is assumed that no more input will come.
// When this function returns r.readerWg will be decremented and r.decoded will be closed.
// On errors, r.err will be set. This should only be accessed after r.decoded has been closed.
func (r *Reader) startReader() {
	defer r.onReaderExit()
	var tmpObj simdjson.Object
	for {

		m.expMovingAvg = float64(bytesSinceLastWindow) / duration.Seconds()
		return
	}

	increment := float64(bytesSinceLastWindow) / duration.Seconds()
	m.expMovingAvg = exponentialMovingAverage(beta, m.expMovingAvg, increment)
}

// exponentialMovingAverage calculates the exponential moving average
func exponentialMovingAverage(beta, previousAvg, incrementAvg float64) float64 {

        }

        /* The message provided to batch has a batchLimit that is
         * higher than the current batchLevel so we will now encode
         * that chained message. Before doing so we must increment
         * the batchLevel of the andx message in case it itself is an
         * andx message and needs to perform the same check as above.
         */

        andx.batchLevel = batchLevel + 1;

                if (cleanupData != null) {
                    cleanupData.set(data);
                }
                if (cleanupReturns) {
                    // Simulate cleanup success: retry with decremented count
                    return tryStartOperation(operationName, data, remainingRetries - 1);
                }
                return false;
            }
        };
    }

    @Test

              if (workerRunningState == RUNNING) {
                // Don't want to have two workers pulling from the queue.
                return;
              } else {
                // Increment the run counter to avoid the ABA problem of a submitter marking the
                // thread as QUEUED after it already ran and exhausted the queue before returning
                // from execute().

                // drop without counting towards preserved problems
                return false;
            }
            int currentCount = totalCount.incrementAndGet();
            getCounter(problem.getSeverity()).increment();
            if (currentCount <= maxCountLimit || dropProblemWithLowerSeverity(problem.getSeverity())) {
                getProblems(problem.getSeverity()).add(problem);
                return true;
            }

     */
    private int getFailureCount(ChangeNotificationHandle handle) {
        return failureCounts.getOrDefault(handle.getDirectoryPath(), 0);
    }

    /**
     * Increment failure count for a handle
     *
     * @param handle notification handle
     */
    private void incrementFailureCount(ChangeNotificationHandle handle) {