assertEquals(Long.valueOf(2), stats.get(EventType.SECURITY_VIOLATION), "Should have 2 security violation events");
    }

    @Test
    @DisplayName("Test concurrent logging")
    void testConcurrentLogging() throws InterruptedException {
        int threadCount = 10;
        int eventsPerThread = 100;
        Thread[] threads = new Thread[threadCount];

        // Should not match with different attributes
        assertFalse(fileInfo.matches(1024L, 1000L, 0x10));
    }

    @Test
    public void testThreadSafety() throws InterruptedException {
        // Test concurrent updates from multiple threads
        Thread[] threads = new Thread[10];

        for (int i = 0; i < threads.length; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {

 * resulting XML document is parsed, the parser API will return this text as the original literal
 * string {@code "Foo<Bar>"}.
 *
 * <p>An {@code Escaper} instance is required to be stateless, and safe when used concurrently by
 * multiple threads.
 *
 * <p>Because, in general, escaping operates on the code points of a string and not on its
 * individual {@code char} values, it is not safe to assume that {@code escape(s)} is equivalent to

// it is no longer referenced, so it must be kept alive (see runtime.KeepAlive)
// until any memory allocated from it is no longer needed.
//
// An Arena must never be used concurrently by multiple goroutines.
type Arena struct {
	a unsafe.Pointer
}

// NewArena allocates a new arena.
func NewArena() *Arena {
	return &Arena{a: runtime_arena_newArena()}
}

      sink.writeUtf8("bb")
    }
    assertThat(cache["k1"]).isNull()
  }

  @Test
  fun `edit discarded after editor detached with concurrent write`() {
    Assumptions.assumeFalse(windows) // Windows can't have two concurrent editors.

    set("k1", "a", "a")

    // Create an editor, then detach it.
    val editor = cache.edit("k1")!!
    editor.newSink(0).buffer().use { sink ->

package org.codelibs.fess.filter;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.net.URLCodec;
import org.codelibs.core.lang.StringUtil;
import org.lastaflute.web.servlet.filter.LastaPrepareFilter;

import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.concurrent.atomic.AtomicReference;
import org.jspecify.annotations.NullUnmarked;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Tester to ensure forwarding wrapper works by delegating calls to the corresponding method with

 */

package com.google.common.collect;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.concurrent.LazyInit;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.stream.Collector;

 * limitations under the License.
 */
package okhttp3.dnsoverhttps

import java.io.IOException
import java.net.InetAddress
import java.net.UnknownHostException
import java.util.concurrent.CountDownLatch
import okhttp3.Call
import okhttp3.Callback
import okhttp3.Dns
import okhttp3.HttpUrl
import okhttp3.MediaType
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient