* self-loops incident to {@code node}).
   *
   * <p>If the count is greater than {@code Integer.MAX_VALUE}, returns {@code Integer.MAX_VALUE}.
   *
   * @throws IllegalArgumentException if {@code node} is not an element of this network
   */
  int degree(N node);

  /**
   * Returns the count of {@code node}'s {@link #inEdges(Object) incoming edges} in a directed

   *
   * @throws RejectedExecutionException if the executor has been previously shutdown
   */
  private void startTask() {
    synchronized (lock) {
      if (shutdown) {
        throw new RejectedExecutionException("Executor already shutdown");
      }
      runningTasks++;
    }
  }

  /** Decrements the running task count. */
  private void endTask() {

    }

    /**
     * Updates the heartbeat timestamp to current time and resets failure count.
     */
    public void updateHeartbeat() {
        this.lastHeartbeat = System.currentTimeMillis();
        this.heartbeatFailures = 0;
    }

    /**
     * Increments the heartbeat failure count.
     */
    public void incrementHeartbeatFailures() {
        this.heartbeatFailures++;
    }

  }

  /**
   * Creates an {@code ArrayList} instance to hold {@code estimatedSize} elements, <i>plus</i> an
   * unspecified amount of padding; **don't do this**. Instead, use {@code new }{@link
   * ArrayList#ArrayList(int) ArrayList}{@code <>(int)} directly and choose an explicit padding
   * amount.
   *
   * @param estimatedSize an estimate of the eventual {@link List#size()} of the new list

		buf[n-1] = 'x'
		for i := 0; i < b.N; i++ {
			j := Count(buf, buf[n-7:])
			if j != 1 {
				b.Fatal("bad count", j)
			}
		}
		buf[n-1] = '\x00'
	})
}

func BenchmarkCountEasy(b *testing.B) {
	benchBytes(b, indexSizes, func(b *testing.B, n int) {
		buf := bmbuf[0:n]
		buf[n-1] = 'x'
		buf[n-7] = 'x'
		for i := 0; i < b.N; i++ {
			j := Count(buf, buf[n-7:])
			if j != 1 {

        // Then: Should use trans1 (addr2 failed, so tried addr1 next)
        assertSame(trans1, result);

        // Verify fail count incremented for addr2 (was 1, now 2)
        assertEquals(2, poolSpy.failCounts.get("10.0.0.2"));
        // addr1's count should remain unchanged since it succeeded
        assertEquals(5, poolSpy.failCounts.get("10.0.0.1"));
    }

    @Test

java.util.logging.FileHandler.level=INFO
java.util.logging.FileHandler.pattern=${fess.log.path}/server_%g.log
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.FileHandler.count=10

# Suppress warning logs

		t.Fatalf("value differs from expected")
	}

	if lc.Resize(0) != 0 {
		t.Fatalf("evicted count differs from expected")
	}
	if lc.Resize(2) != 0 {
		t.Fatalf("evicted count differs from expected")
	}
	lc.Add("key2", "val2")
	if lc.Resize(1) != 1 {
		t.Fatalf("evicted count differs from expected")
	}
}

func TestLRUEdgeCases(t *testing.T) {
	lc := lru.NewLRU[string, *string](2, nil, 0)

			}

			if qs.QStats.Avg.Count > 0 || qs.QStats.Curr.Count > 0 {
				qt := qs.QStats
				currInQueueBytes.Value = qt.Curr.Bytes
				currInQueueCount.Value = qt.Curr.Count
				avgQueueBytes.Value = qt.Avg.Bytes
				avgQueueCount.Value = qt.Avg.Count
				maxQueueBytes.Value = qt.Max.Bytes
				maxQueueCount.Value = qt.Max.Count
			}
			activeWorkersCount.Value = float64(qs.ActiveWorkers.Curr)

                : this.transportContext.getConfig().getWinsServers()[this.nbnsIndex];
    }

    static class Sem {

        Sem(final int count) {
            this.count = count;
        }

        int count;
    }

    static class QueryThread extends Thread {

        private final Sem sem;
        private final String host, scope;
        private final int type;