mockRequest.setHeader("Origin", "   ");

        corsFilter.doFilter(mockRequest, mockResponse, mockFilterChain);

        assertTrue(mockFilterChain.wasDoFilterCalled());
        assertFalse(corsHandlerFactory.wasGetCalled());
    }

    // Test with valid Origin but no CorsHandler found
    @Test

        return artifact;
    }

    private Artifact createTestArtifact(String directory, String type) throws IOException {
        return createTestArtifact(directory, "1.0", type);
    }

    private Artifact createTestArtifact(String directory, String version, String type) throws IOException {
        File testData = getTestFile(directory);
        FileUtils.deleteDirectory(testData);
        testData.mkdirs();

 */
class BaseConfigurationTest {

    private BaseConfiguration config;

    @BeforeEach
    void setUp() throws CIFSException {
        config = new BaseConfiguration(false);
    }

    @Test
    @DisplayName("Test constructor with initDefaults true")
    void testConstructorWithInitDefaults() throws CIFSException {
        BaseConfiguration configWithDefaults = new BaseConfiguration(true);

    sortedMap.put("two", 2);
    sortedMap.put("three", 3);
    return sortedMap;
  }

  @Override
  protected String getKeyNotInPopulatedMap() throws UnsupportedOperationException {
    return "minus one";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() throws UnsupportedOperationException {
    return -1;
  }

  @J2ktIncompatible // https://youtrack.jetbrains.com/issue/KT-58242/ undefined behavior (crash)

 */
open class DelegatingSSLSocketFactory(
  private val delegate: SSLSocketFactory,
) : SSLSocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): SSLSocket {
    val sslSocket = delegate.createSocket() as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
  ): SSLSocket {

  @Param Impl impl;

  private final Exception exception = new Exception();
  private Facade<?> notDoneFuture;

  @BeforeExperiment
  void setUp() throws Exception {
    notDoneFuture = impl.newFacade();
  }

  @Benchmark
  public long timeComplete_Normal(int reps) throws Exception {
    long r = 0;
    List<Facade<Integer>> list = new ArrayList<>(reps);
    for (int i = 0; i < reps; i++) {

import org.codelibs.core.beans.ParameterizedClassDesc;
import org.junit.Test;

/**
 * @author koichik
 */
public class ParameterizedClassDescFactoryTest {

    /**
     * @throws Exception
     */
    @Test
    public void testFieldType() throws Exception {
        final Map<TypeVariable<?>, Type> map = ParameterizedClassDescFactory.getTypeVariables(Hoge.class);
        final Field field = Hoge.class.getField("foo");

     * @param response The servlet response
     * @param chain The filter chain
     * @throws IOException If an I/O error occurs
     * @throws ServletException If a servlet error occurs
     */
    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain chain)
            throws IOException, ServletException {

    void testDisposeDelegates() throws Exception {
        SpnegoContext ctx = newContext();
        ctx.dispose();
        verify(this.mechContext, times(1)).dispose();
    }

    @Test
    @DisplayName("calculateMIC throws when context not established")
    void testCalculateMICRequiresEstablished() throws Exception {
        SpnegoContext ctx = newContext();

    @BeforeEach
    public void setup() throws Exception {
        this.cfg = new BaseConfiguration(true);
    }

    /**
     * Sub-class of {@link BaseConfiguration} that forces {@code useUnicode()}
     * to return {@code false}. This mimics an ASCII only client
     */
    private static class OffUnicodeConfig extends BaseConfiguration {
        public OffUnicodeConfig() throws Exception {
            super(true);
        }