public void setUp() {
    // precalculate some random strings of ascii characters.
    StringBuilder sb = new StringBuilder();
    Random random = new Random(0xdeadbeef); // for unpredictable but reproducible behavior
    sb.ensureCapacity(size);
    for (int k = 0; k < size; k++) {
      // [9-127) includes all ascii non-control characters
      sb.append((char) (random.nextInt(127 - 9) + 9));
    }
    data = sb.toString();
  }

   *       expression involving {@code view} will throw)
   *   <li>{@code hashCode()} does not throw
   *   <li>if {@code node} is re-added to the graph after having been removed, {@code view}'s
   *       behavior is undefined
   * </ul>
   *
   * @throws IllegalArgumentException if {@code node} is not an element of this graph
   * @since 24.0
   */
  Set<EndpointPair<N>> incidentEdges(N node);

import java.io.InputStream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Test class for SMB file locking operations.
 * This class is used to test concurrent file access and locking behavior.
 */
public class TestLocking implements Runnable {

    private static final Logger logger = LoggerFactory.getLogger(TestLocking.class);

    /**
     * Default constructor for TestLocking
     */

     * Tests the isCredentialTypeCorrect method with a null byte array.
     * This test is indirect as the constructor would throw an exception.
     * We can't instantiate the class with null, so we can't directly test this method's behavior with null.
     * However, the constructor logic `!isCredentialTypeCorrect()` covers this.
     * If `new PacCredentialType(null)` throws, it implies `isCredentialTypeCorrect()` returned false for null.
     */
    @Test

   * E} is an {@link Enum} type, use {@link EnumSet#noneOf} instead. Otherwise, strongly consider
   * using a {@code LinkedHashSet} instead, at the cost of increased memory footprint, to get
   * deterministic iteration behavior.
   *
   * <p><b>Note:</b> this method is now unnecessary and should be treated as deprecated. Instead,
   * use the {@code HashSet} constructor directly, taking advantage of <a

 * not wrapped in {@code ExecutionException}. For just a normal failure, use {@link
 * SettableFuture}).
 *
 * <p>Useful for testing the behavior of Future utilities against odd futures.
 *
 * @author Anthony Zana
 */
@GwtCompatible
@NullUnmarked
final class UncheckedThrowingFuture<V> extends AbstractFuture<V> {

    public void overriddenNotAnnotatedInSubclass(Object o) {
      super.overriddenNotAnnotatedInSubclass(o);
    }

    @Subscribe
    @Override
    // We are testing how we treat an override with the same behavior and annotations.
    @SuppressWarnings("RedundantOverride")
    public void overriddenAndAnnotatedInSubclass(Object o) {
      super.overriddenAndAnnotatedInSubclass(o);
    }

    @Override

   */
  public HashCode hash() {
    return hasher.hash();
  }

  // Overriding close() because FilterOutputStream's close() method pre-JDK8 has bad behavior:
  // it silently ignores any exception thrown by flush(). Instead, just close the delegate stream.
  // It should flush itself if necessary.
  @Override
  public void close() throws IOException {
    out.close();
  }

 * array. If any method encounters the end of the array prematurely, it throws {@link
 * IllegalStateException} to signify <i>programmer error</i>. This behavior is a technical violation
 * of the supertype's contract, which specifies a checked exception.
 *
 * @author Kevin Bourrillion
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible

  public void shutdown() {
    synchronized (lock) {
      shutdown = true;
      if (runningTasks == 0) {
        lock.notifyAll();
      }
    }
  }

  // See newDirectExecutorService javadoc for unusual behavior of this method.
  @Override
  public List<Runnable> shutdownNow() {
    shutdown();
    return ImmutableList.of();
  }

  @Override
  public boolean isTerminated() {
    synchronized (lock) {