}
    };
  }

  private static class StringSourceFactory implements CharSourceFactory {

    @Override
    public CharSource createSource(String data) throws IOException {
      return CharSource.wrap(data);
    }

    @Override
    public String getExpected(String data) {
      return data;
    }

    @Override
    public void tearDown() throws IOException {}
  }

    }

    private @Nullable Type captureNullable(@Nullable Type type) {
      if (type == null) {
        return null;
      }
      return capture(type);
    }
  }

  /**
   * Wraps around {@code TypeVariable<?>} to ensure that any two type variables are equal as long as
   * they are declared by the same {@link java.lang.reflect.GenericDeclaration} and have the same
   * name, even if their bounds differ.

import java.util.TimeZone;

import jcifs.Configuration;
import jcifs.DialectVersion;
import jcifs.ResolverType;

/**
 * Configuration implementation that delegates to another configuration instance.
 * Provides a wrapper mechanism for configuration objects with delegation pattern.
 *
 * @author mbechler
 */
public class DelegatingConfiguration implements Configuration {

    private final Configuration delegate;

    /**

	errorCounts := make(map[error]int)
	for _, err := range errs {
		if IsErrIgnored(err, ignoredErrs...) {
			continue
		}
		// Errors due to context cancellation may be wrapped - group them by context.Canceled.
		if errors.Is(err, context.Canceled) {
			errorCounts[context.Canceled]++
			continue
		}
		errorCounts[err]++
	}

	maxCnt := 0

  validation:
    name: "Validation"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - uses: gradle/actions/wrapper-validation@v4
      - name: Validate Renovate
        uses: rinchsan/renovate-config-validator@v0.2.0
        with:
          pattern: '.github/renovate.json'

  checkjdk11:
    permissions:

  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client =
    clientTestRule
      .newClientBuilder()
      .eventListenerFactory(clientTestRule.wrap(listener))
      .build()

  @Test
  fun upgrade() {
    val socketHandler =
      MockSocketHandler()
        .apply {
          receiveRequest("client says hello\n")

        void shouldReturnCorrectBytesConsumed() throws SMBProtocolDecodingException {
            // Given - larger buffer than needed
            byte[] buffer = new byte[100];
            ByteBuffer bb = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN);
            bb.putLong(1000L);
            bb.putLong(500L);
            bb.putInt(8);
            bb.putInt(512);

            // When

        assertNotNull(conn);
        assertTrue(conn instanceof SmbFile, "Connection should be an instance of SmbFile");
        SmbFile file = (SmbFile) conn;
        assertEquals(url, file.getURL(), "Returned SmbFile should wrap the given URL");
        assertSame(mockCtx, file.getContext(), "SmbFile must use the provided CIFSContext");
        verify(mockCtx, atLeastOnce()).getConfig(); // interaction with dependency
    }

    @Test

        // For GCM, last 4 bytes should contain incrementing counter
        ByteBuffer buffer1 = ByteBuffer.wrap(nonce1, 12, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN);
        ByteBuffer buffer2 = ByteBuffer.wrap(nonce2, 12, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN);
        int counter1 = buffer1.getInt();
        int counter2 = buffer2.getInt();

        SmbException ex = assertThrows(SmbException.class, () -> c.hasCapability(1));
        assertTrue(ex.getMessage().contains("Not connected"));
    }

    @Test
    @DisplayName("connectWrapException wraps UnknownHostException and IOException")
    void connectWrapException_wraps_io_and_unkhost() throws Exception {
        // Subclass to control connect() behavior
        SmbTreeConnection c = new SmbTreeConnection(ctx) {