assertThat(e).hasMessageThat().contains(ENDPOINTS_MISMATCH);
  }

  /**
   * Tests that the method {@code putEdge} will silently add the missing nodes to the graph, then
   * add the edge connecting them. We are not using the proxy methods here as we want to test {@code
   * putEdge} when the end-points are not elements of the graph.
   */
  @Test

            // Validate host
            String host = url.getHost();
            if (host == null || host.isEmpty()) {
                throw new SmbException("SMB URL missing host");
            }

            // Validate host format
            if (!isValidHost(host)) {
                throw new SmbException("Invalid host in SMB URL");
            }

        assertTrue(handle.isSMB2());

        reset(transport);
        when(session.getTransport()).thenReturn(transport);
        when(transport.isSMB2()).thenThrow(new SmbException("negotiation missing"));
        assertFalse(handle.isSMB2());
    }

    @Test
    @DisplayName("Null treeConnection throws NPE")
    void constructorNullTreeConnection() {

            if (id == null || id.isEmpty()) {
                throw new InvalidRepositoryException("Repository identifier missing", "");
            }

            String url = repo.getUrl();

            if (url == null || url.isEmpty()) {
                throw new InvalidRepositoryException("URL missing for repository " + id, id);
            }

        assertEquals(NtStatus.NT_STATUS_ACCESS_DENIED, ex.getNtStatus());
    }

    @Test
    @DisplayName("resolveSids(CIFSContext,server,sids,offset,length) resolves missing, caches, and reuses cache")
    void resolveSids_withOffsetAndCache_behavesCorrectly() throws Exception {
        CIFSContext ctx = mock(CIFSContext.class);
        SIDCacheImpl cache = Mockito.spy(new SIDCacheImpl(ctx));

import org.opensearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
import org.opensearch.search.aggregations.bucket.missing.MissingAggregationBuilder;
import org.opensearch.search.aggregations.bucket.range.IpRangeAggregationBuilder;
import org.opensearch.search.aggregations.bucket.sampler.SamplerAggregationBuilder;

    }

    @Nested
    @MockitoSettings(strictness = Strictness.LENIENT)
    class PreauthHashAndEncryption {
        @Test
        @DisplayName("calculatePreauthHash rejects non-SMB2 or missing negotiation")
        void preauthHash_rejectsWhenUnsupported() {
            // Not SMB2
            assertThrows(SmbUnsupportedOperationException.class, () -> transport.calculatePreauthHash(new byte[] { 1 }, 0, 1, null));

        // For now, we test that the method signature is correct and can be called

        AtomicInteger callbackCount = new AtomicInteger(0);

        try {
            // This will likely fail due to missing SearchEngineClient setup,
            // but we can verify the method signature and basic functionality
            SearchEngineUtil.scroll("test_index", hit -> {
                callbackCount.incrementAndGet();

    assertThat(e).hasMessageThat().contains(ERROR_SELF_LOOP);
  }

  /**
   * This test checks an implementation dependent feature. It tests that the method {@code addEdge}
   * will silently add the missing nodes to the graph, then add the edge connecting them. We are not
   * using the proxy methods here as we want to test {@code addEdge} when the end-points are not
   * elements of the graph.
   */
  @Test

    assertThat(e).hasMessageThat().contains(ERROR_SELF_LOOP);
  }

  /**
   * This test checks an implementation dependent feature. It tests that the method {@code addEdge}
   * will silently add the missing nodes to the graph, then add the edge connecting them. We are not
   * using the proxy methods here as we want to test {@code addEdge} when the end-points are not
   * elements of the graph.
   */
  @Test