new Runnable() {
        @Override
        public void run() {}
      };

  boolean called = false;

  private void assertSingleCallWithCorrectParameters(
      Runnable command, long initialDelay, long delay, TimeUnit unit) {
    assertFalse(called); // only called once.
    called = true;
    assertEquals(INITIAL_DELAY, initialDelay);
    assertEquals(DELAY, delay);
    assertEquals(UNIT, unit);

      new Runnable() {
        @Override
        public void run() {}
      };

  boolean called = false;

  private void assertSingleCallWithCorrectParameters(
      Runnable command, long initialDelay, long delay, TimeUnit unit) {
    assertFalse(called); // only called once.
    called = true;
    assertEquals(INITIAL_DELAY, initialDelay);
    assertEquals(DELAY, delay);
    assertEquals(UNIT, unit);

    secondFuture.cancel(true);
    assertThat(secondCallable.called).isFalse();
    assertThat(thirdCallable.called).isFalse();
    firstFuture.set(null);
    assertThat(secondCallable.called).isFalse();
    assertThat(thirdCallable.called).isTrue();
  }

  public void testCancellationMultipleThreads() throws Exception {

                result.append("Not listening on called name");
                break;
            case NOT_LISTENING_CALLING:
                result.append("Not listening for calling name");
                break;
            case CALLED_NOT_PRESENT:
                result.append("Called name not present");
                break;
            case NO_RESOURCES:
                result.append("Called name present, but insufficient resources");

        verify(smbTransport).unwrap(SmbTransport.class); // Verify that the method was called
    }

    @Test
    void testClose() throws Exception {
        // Act
        smbTransport.close();

        // Assert
        verify(smbTransport).close(); // Verify that the close method was called
    }

    @Test
    void testGetRemoteAddress() {
        // Arrange

 * supertype of `Function<A, B>` turns out to be massively more useful to callers in practice: They
 * want their output to be non-null in operations like `stream.map(myConverter)`, and we can
 * guarantee that as long as we also require the input type to be non-null[*] (which is a
 * requirement that existing callers already fulfill).
 *
 * Disclaimer: Part of the reason that callers are so well adapted to `Function<A, B>` may be that

		callMethod(db, func(value interface{}, tx *gorm.DB) (called bool) {
			if db.Statement.Schema.BeforeSave {
				if i, ok := value.(BeforeSaveInterface); ok {
					called = true
					db.AddError(i.BeforeSave(tx))
				}
			}

			if db.Statement.Schema.BeforeUpdate {
				if i, ok := value.(BeforeUpdateInterface); ok {
					called = true
					db.AddError(i.BeforeUpdate(tx))
				}
			}

        return new BiMapEntry(entry);
      }

      @Override
      public void remove() {
        if (entry == null) {
          throw new IllegalStateException("no calls to next() since the last call to remove()");
        }
        V value = entry.getValue();
        iterator.remove();
        removeFromInverseMap(value);
        entry = null;
      }
    };
  }

  @WeakOuter

object HttpMethod {
  @JvmStatic // Despite being 'internal', this method is called by popular 3rd party SDKs.
  fun invalidatesCache(method: String): Boolean =
    (
      method == "POST" ||
        method == "PATCH" ||
        method == "PUT" ||
        method == "DELETE" ||
        method == "MOVE"
    )

  @JvmStatic // Despite being 'internal', this method is called by popular 3rd party SDKs.

    }

    @ParameterizedTest(name = "session error {1} -\\u003e {2}")
    @CsvSource({ "-1,Connection refused", "0x80,Not listening on called name", "0x81,Not listening for calling name",
            "0x82,Called name not present", "0x83,Called name present, but insufficient resources", "0x8F,Unspecified error",
            "999,Unknown error code: 999" })
    @DisplayName("getErrorString for SSN service errors")