Subscriber that = (Subscriber) obj;
      // Use == so that different equal instances will still receive events.
      // We only guard against the case that the same object is registered
      // multiple times
      return target == that.target && method.equals(that.method);
    }
    return false;
  }

  /**
   * Checks whether {@code method} is thread-safe, as indicated by the presence of the {@link

 *
 *
 * A context holds the client configuration, shared services as well as the active credentials.
 *
 * Usually you will want to create one context per client configuration and then
 * multiple sub-contexts using different credentials (if necessary).
 *
 * {@link #withDefaultCredentials()}, {@link #withAnonymousCredentials()}, {@link #withCredentials(Credentials)}
 * allow to create such sub-contexts.
 *
 *

        // Test final release
        session.release();
        assertFalse(session.isInUse(), "Session should not be in use after all releases");

        // Test multiple releases (should not throw)
        assertThrows(RuntimeException.class, () -> session.release(), "Additional release should throw RuntimeCIFSException");
    }

    /**
     * Test tree creation and cleanup
     */

        CommonServerMessageBlockResponse out = tree.send(request);

        // Assert
        assertSame(response, out);
        verify(tree).send(request);
    }

    @Test
    @DisplayName("send with multiple params returns the stubbed response")
    void send_withParams_returnsResponse() throws Exception {
        // Arrange

        assertEquals(20, bytesRead);
        assertEquals(0x0010, response.getAttributes());
        // getLastWriteTime returns lastWriteTime (from readUTime) + serverTimeZoneOffset
        // readUTime multiplies the seconds value by 1000, and writeUTime divides milliseconds by 1000
        // So the round-trip should preserve the milliseconds value
        assertEquals(sampleTimeMillis + serverTimeZoneOffset, response.getLastWriteTime());

            // Then
            assertTrue(testHandler instanceof jcifs.smb1.http.Handler);
            assertEquals(443, testHandler.getDefaultPort());
        }

        @Test
        @DisplayName("Should handle multiple instances")
        void testMultipleInstances() {
            // When
            Handler handler1 = new Handler();
            Handler handler2 = new Handler();
            Handler handler3 = new Handler();

    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo("string includes multiple certificates")
    }
    try {
      decode(pkcs8Pem + certificatePem + pkcs8Pem)
      fail<Any>()
    } catch (expected: IllegalArgumentException) {
      assertThat(expected.message).isEqualTo("string includes multiple private keys")
    }
  }

  @Test
  fun decodeWrongType() {
    try {
      decode(

    }

    @Test
    @DisplayName("Test multiple encodes produce same result")
    void testMultipleEncodesProduceSameResult() {
        // Setup
        String pipeName = "RepeatedEncode";
        long timeout = 3000L;
        FsctlPipeWaitRequest request = new FsctlPipeWaitRequest(pipeName, timeout);

        // Encode multiple times
        byte[] buffer1 = new byte[100];

    }
  }

  @J2ktIncompatible
  @GwtIncompatible // multiply
  public void testTimes() {
    for (int a : TEST_INTS) {
      for (int b : TEST_INTS) {
        UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
        UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);
        int expected =
            force32(aUnsigned.bigIntegerValue().multiply(bUnsigned.bigIntegerValue()).intValue());

   * stream.collect(MoreCollectors.onlyElement())}.
   *
   * @throws NoSuchElementException if the iterable is empty
   * @throws IllegalArgumentException if the iterable contains multiple elements
   */
  @ParametricNullness
  public static <T extends @Nullable Object> T getOnlyElement(Iterable<T> iterable) {
    return Iterators.getOnlyElement(iterable.iterator());
  }

  /**