return 1;
      case 1:
        return n;
      default:
        if (n < factorials.length) {
          return factorials[n] / (factorials[k] * factorials[n - k]);
        } else if (k >= biggestBinomials.length || n > biggestBinomials[k]) {
          return Long.MAX_VALUE;
        } else if (k < biggestSimpleBinomials.length && n <= biggestSimpleBinomials[k]) {
          // guaranteed not to overflow
          long result = n--;

        // The provider's toString might not contain the exact class name
        // Just verify it's not null and contains some meaningful info
        assertTrue("toString should not be empty", toString.length() > 0);
    }

    public void test_hook_withNullAssistantDirector() {
        // When & Then - Should not throw exception
        try {
            curtainBeforeHook.hook(null);
        } catch (Exception e) {

        // Test that stack trace is properly captured
        ThemeException exception = new ThemeException("Stack trace test");

        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Verify that this test method appears in the stack trace
        boolean foundTestMethod = false;
        for (StackTraceElement element : exception.getStackTrace()) {

        Metadata metadata = null;

        File metadataFile = new File(
                localRepository.getBasedir(), localRepository.pathOfLocalRepositoryMetadata(this, remoteRepository));

        if (metadataFile.length() == 0) {
            if (!metadataFile.delete()) {
                // sleep for 10ms just in case this is windows holding a file lock
                try {
                    Thread.sleep(10);

        });
        return failureUrl;
    }

    /**
     * Extracts and returns the stack trace from a throwable as a string.
     * The stack trace is abbreviated if it exceeds the configured maximum length.
     *
     * @param t the throwable to extract the stack trace from
     * @return the stack trace as a string, or empty string if extraction fails
     */
    private String getStackTrace(final Throwable t) {

        String[] excludes = { "long_exclude_" + "c".repeat(50) };

        String result = popularWordHelper.getCacheKey(seed, tags, roles, fields, excludes);

        assertNotNull(result);
        assertTrue(result.length() > 100);
        assertTrue(result.contains(seed));
    }

    public void test_getCacheKey_manyItems() {
        String seed = "test_seed";
        String[] tags = new String[20];

        // Then
        // getWinsServers() returns InetAddress[], not String
        InetAddress[] winsServers = testConfig.getWinsServers();
        assertNotNull(winsServers);
        assertEquals(1, winsServers.length);
        assertEquals("192.168.1.1", winsServers[0].getHostAddress());

        // getBroadcastAddress() returns InetAddress, not String
        InetAddress broadcastAddr = testConfig.getBroadcastAddress();

   * exception.
   *
   * <p>When the underlying delegate throws an exception then this memoizing supplier will keep
   * delegating calls until it returns valid data.
   *
   * @param duration the length of time after a value is created that it should stop being returned
   *     by subsequent {@code get()} calls
   * @param unit the unit that {@code duration} is expressed in

      }
    }
  }

  private static Object[] arbitraryParameters(Method method) {
    Class<?>[] parameterTypes = method.getParameterTypes();
    Object[] params = new Object[parameterTypes.length];
    for (int i = 0; i < parameterTypes.length; i++) {
      params[i] = PARAMETER_VALUES.get(parameterTypes[i]);
    }
    return params;
  }

  private static final ImmutableSet<String> NOT_WORKING_ON_MOCKS =

      }
    }
  }

  private static Object[] arbitraryParameters(Method method) {
    Class<?>[] parameterTypes = method.getParameterTypes();
    Object[] params = new Object[parameterTypes.length];
    for (int i = 0; i < parameterTypes.length; i++) {
      params[i] = PARAMETER_VALUES.get(parameterTypes[i]);
    }
    return params;
  }

  private static final ImmutableSet<String> NOT_WORKING_ON_MOCKS =