innerIterator.next();
                        innerCount++;
                    }
                }
                assertEquals(0, innerCount, "Inner iteration should not execute");
            }
            assertEquals(0, outerCount, "Outer iteration should not execute");
        }, "EmptyIterator should work correctly in nested iteration");
    }

    @Test

      } catch (e: Exception) {
        logger.log(Level.SEVERE, "$this connection from ${raw.inetAddress} crashed", e)
      }
    }
  }

  internal inner class SocketHandler(
    private val connectionIndex: Int,
    private val raw: Socket,
    private val firstExchangePeek: MockResponse,
  ) {
    private var nextExchangeIndex = 0

    @Throws(Exception::class)

    }

    @Test
    @DisplayName("reauthenticate propagates transport failures")
    void testReauthenticatePropagates() throws Exception {
        SmbSessionImpl session = newSession();
        // Cause the inner reauthenticate to fail at first transport call
        when(transport.getNegotiateResponse()).thenThrow(new SmbException("fail"));
        assertThrows(CIFSException.class, session::reauthenticate);
    }

                                    .toApiLocation()))
                            : null);
        }
    }

    // -----------------/
    // - Inner Classes -/
    // -----------------/

    /**
     * Class StringFormatter.
     *
     * @version $Revision$ $Date$
     */
    public abstract static class StringFormatter {

import jcifs.SmbResourceLocator;

@ExtendWith(MockitoExtension.class)
class SmbEnumerationUtilTest {

    @Mock
    SmbFilenameFilter fnf;

    @Mock
    SmbFileFilter ff;

    // Utility to create a private inner class instance reflectively
    private static Object newPrivateInner(String simpleName, Class<?>[] paramTypes, Object... args) {
        try {
            Class<?> cls = Class.forName("jcifs.smb.SmbEnumerationUtil$" + simpleName);

        for (final String sid : sessionIdList) {
            // remove config
            ComponentUtil.getCrawlingConfigHelper().remove(sid);
        }

    }

    /**
     * Inner thread class for executing data store crawling operations.
     * Each thread handles crawling for a single data configuration,
     * processing documents and updating the search index.
     *

   * c, d, e]} with a partition size of 3 yields {@code [[a, b, c], [d, e]]} -- an outer list
   * containing two inner lists of three and two elements, all in the original order.
   *
   * <p>The outer list is unmodifiable, but reflects the latest state of the source list. The inner
   * lists are sublist views of the original list, produced on demand using {@link List#subList(int,

	u2 := User{Name: "GenericsJoins_2", Company: Company{Name: "GenericsCompany_2"}}
	u3 := User{Name: "GenericsJoins_3", Company: Company{Name: "GenericsCompany_3"}}
	db.CreateInBatches(ctx, &[]User{u3, u, u2}, 10)

	// Inner JOIN + WHERE
	result, err := db.Joins(clause.Has("Company"), func(db gorm.JoinBuilder, joinTable clause.Table, curTable clause.Table) error {
		db.Where("?.name = ?", joinTable, u.Company.Name)
		return nil
	}).First(ctx)

      (if (isCanceled()) "canceled " else "") +
        (if (forWebSocket) "web socket" else "call") +
        " to " + redactedUrl()
    )

  internal fun redactedUrl(): String = originalRequest.url.redact()

  inner class AsyncCall(
    private val responseCallback: Callback,
  ) : Runnable {
    @Volatile var callsPerHost = AtomicInteger(0)
      private set

    fun reuseCallsPerHostFrom(other: AsyncCall) {

    return (TypeToken<? extends R>) TypeToken.of(getGenericReturnType());
  }

  /**
   * Returns all declared parameters of this {@code Invokable}. Note that if this is a constructor
   * of a non-static inner class, unlike {@link Constructor#getParameterTypes}, the hidden {@code
   * this} parameter of the enclosing class is excluded from the returned parameters.
   */
  @IgnoreJRERequirement