dateFormat.setTimeZone(DEFAULT_BUILD_TIME_ZONE);
        formattedTimestamp = dateFormat.format(time);
    }

    public String formattedTimestamp() {
        return formattedTimestamp;
    }

     *            {@code null}.
     * @param problems The container used to collect problems that were encountered, must not be {@code null}.
     * @return The profiles that have been activated, never {@code null}.
     */
    List<Profile> getActiveProfiles(
            Collection<Profile> profiles, ProfileActivationContext context, ModelProblemCollector problems);

            oldExtension.setClassLoadingStrategy(extension.getClassLoadingStrategy());
        }
        this.extension = oldExtension;
    }

    public CoreExtension getExtension() {
        return extension;
    }

  public void testRemoveAtIndex_last() {
    runRemoveTest(getNumElements() - 1);
  }

  private void runRemoveTest(int index) {
    assertEquals(
        Platform.format("remove(%d) should return the element at index %d", index, index),
        getList().get(index),
        getList().remove(index));
    List<E> expected = copyToList(createSamplesArray());
    expected.remove(index);
    expectContents(expected);

import org.gradle.testkit.runner.GradleRunner;

public class TestingConventionsTasksIT extends GradleIntegrationTestCase {

    @Override
    public String projectName() {
        return "testingConventions";
    }

    public void testInnerClasses() {
        GradleRunner runner = getGradleRunner().withArguments("clean", ":no_tests_in_inner_classes:testingConventions", "-i", "-s");

        QueryProcessor nullProcessor = new QueryProcessor() {
            @Override
            public QueryBuilder execute(QueryContext context, Query query, float boost) {
                return null;
            }
        };
        ComponentUtil.register(nullProcessor, "queryProcessor");

        BooleanQuery.Builder boolQueryBuilder = new BooleanQuery.Builder();

        byte[] encrypted = storage.encryptCredentials(null);
        assertNull(encrypted, "Encrypting null should return null");

        char[] decrypted = storage.decryptCredentials(null);
        assertNull(decrypted, "Decrypting null should return null");
    }

    @Test
    public void testEncryptDecryptLongPassword() throws Exception {
        // Test with very long password

        request.setRemoteAddr("192.168.1.100");
        request.addHeader("X-Forwarded-For", "203.0.113.50");
        request.addHeader("X-Real-IP", "203.0.113.75");
        // Should return remoteAddr, not the spoofed headers
        assertEquals("192.168.1.100", rateLimitHelper.getClientIp(request));
    }

    @Test
    public void test_blockIp() {
        rateLimitHelper.blockIp("192.168.1.100", 1000L);

                        }
                        break;
                      default:
                        throw new AssertionError();
                    }
                  }
                  return threadSum;
                }
              }));
    }
    threadPool.shutdown();
    assertTrue(threadPool.awaitTermination(300, SECONDS));
    long sum = 0;
    for (Future<Long> f : futures) {

import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.Configuration;

/**
 * Tests for {@link SmbComSetInformationResponse}.
 *
 * Tests focus on the wire format methods which all return 0,
 * and the toString method implementation.
 */
@ExtendWith(MockitoExtension.class)
@DisplayName("SmbComSetInformationResponse tests")
public class SmbComSetInformationResponseTest {

    @Mock