assertNotNull(decrypted);
        // With dummy data, we can't verify the content, just that it decrypts without error
        // and returns a result of the expected size.
        assertEquals(data.length - 24, decrypted.length);
    }

    /**
     * Test decrypt with an unsupported encryption type.
     */
    @Test
    void testDecryptUnsupportedType() {

    /**
     * Verifies that the provided CRUD mode matches the expected mode.
     * Throws a validation error if the modes do not match.
     *
     * @param crudMode the actual CRUD mode
     * @param expectedMode the expected CRUD mode
     */
    protected void verifyCrudMode(final int crudMode, final int expectedMode) {
        if (crudMode != expectedMode) {

   */
  void writeTo(ByteBuffer buffer) {
    checkNotNull(buffer);
    checkArgument(
        buffer.remaining() >= BYTES,
        "Expected at least Stats.BYTES = %s remaining , got %s",
        BYTES,
        buffer.remaining());
    buffer
        .putLong(count)
        .putDouble(mean)
        .putDouble(sumOfSquaresOfDeltas)

 * code shouldn't use these, they're necessary for clients migrating from OkHttp 3.x and this test
 * ensures the symbols remain available and with the expected parameter and return types.
 */
@Suppress(
  "DEPRECATION_ERROR",
  "UNUSED_VALUE",
  "UNUSED_VARIABLE",
  "VARIABLE_WITH_REDUNDANT_INITIALIZER",
)
class KotlinDeprecationErrorTest {

		}

		*data = append((*data)[0:], b[3:]...)
		return nil
	} else if s, ok := value.(string); ok {
		*data = []byte(s[3:])
		return nil
	}

	return errors.New("Bytes expected")
}

func (data EncryptedData) Value() (driver.Value, error) {
	if len(data) > 0 && data[0] == 'x' {
		// needed to test failures
		return nil, errors.New("Should not start with 'x'")
	}

        void testMaskSecretValueWithCredentials(String input, String expected) {
            // When
            String result = Strings.maskSecretValue(input);

            // Then
            assertEquals(expected, result, "Should mask password in SMB URL");
        }

        @ParameterizedTest

	}

	// 4. List groups and members and verify
	groups, err := s.adm.ListGroups(ctx)
	if err != nil {
		c.Fatalf("group list err: %v", err)
	}
	expected := []string{group}
	if !slices.Equal(groups, expected) {
		c.Fatalf("expected group listing: %v, got: %v", expected, groups)
	}
	groupInfo, err := s.adm.GetGroupDescription(ctx, group)
	if err != nil {
		c.Fatalf("group desc err: %v", err)
	}

        }
    }

    /**
     * Tests the unwrap functionality.
     */
    @Nested
    public class UnwrapFunctionalityTest {

        /**
         * Verifies that unwrap returns the expected underlying object.
         */
        @Test
        public void testUnwrap() {
            when(smbPipeHandle.unwrap(SmbPipeHandleInternal.class)).thenReturn(mockSmbPipeHandleInternal);

import jcifs.CIFSException;
import jcifs.Credentials;

/**
 * Tests for SmbRenewableCredentials interface.
 *
 * Since this file is an interface with a single method, we provide small
 * helper implementations to exercise expected interaction patterns and edge cases.
 */
@ExtendWith(MockitoExtension.class)
public class SmbRenewableCredentialsTest {

    // Simple base class to satisfy the extended CredentialsInternal contract

      try {
        // 1.8, 9, 10, 11, 12 etc
        val version = jvmVersion.toInt()
        if (version >= 9) return null
      } catch (_: NumberFormatException) {
        // expected on >= JDK 9
      }

      // Find Jetty's ALPN extension for OpenJDK.
      try {
        val alpnClassName = "org.eclipse.jetty.alpn.ALPN"
        val alpnClass = Class.forName(alpnClassName, true, null)