@SuppressWarnings("unchecked")
  protected <E> NavigableSet<E> create() {
    TestSet<E> inner =
        new TestSet<>(new TreeSet<E>((Comparator<E>) Ordering.natural().nullsFirst()), MUTEX);
    NavigableSet<E> outer = Synchronized.navigableSet(inner, MUTEX);
    return outer;
  }

  static class TestSet<E> extends SynchronizedSetTest.TestSet<E> implements NavigableSet<E> {

 *
 * @author Kurt Alfred Kluever
 */
public class SynchronizedQueueTest extends TestCase {

  protected Queue<String> create() {
    TestQueue<String> inner = new TestQueue<>();
    Queue<String> outer = Synchronized.queue(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestQueue<E> implements Queue<E> {

            new TestStringSetGenerator() {
              @Override
              protected Set<String> create(String[] elements) {
                TestSet<String> inner = new TestSet<>(new HashSet<String>(), MUTEX);
                Set<String> outer = Synchronized.set(inner, inner.mutex);
                Collections.addAll(outer, elements);
                return outer;
              }
            })
        .named("Synchronized.set")

            new TestStringSetGenerator() {
              @Override
              protected Set<String> create(String[] elements) {
                TestSet<String> inner = new TestSet<>(new HashSet<String>(), null);
                Set<String> outer = Synchronized.set(inner, null);
                inner.mutex = outer;
                Collections.addAll(outer, elements);
                return outer;
              }
            })

    }

    def resolvesUnqualifiedNameToInnerClass() {
        when:
        def name = typeNameResolver.resolve('Inner', classMetaData)

        then:
        name == 'org.gradle.SomeClass.Inner'
        _ * classMetaData.innerClassNames >> ['org.gradle.SomeClass.Inner']
        _ * classMetaData.className >> 'org.gradle.SomeClass'
    }

    def resolvesQualifiedNameToInnerClass() {

                  protected SetMultimap<String, String> create(Entry<String, String>[] entries) {
                    TestMultimap<String, String> inner = new TestMultimap<>();
                    SetMultimap<String, String> outer =
                        Synchronized.setMultimap(inner, inner.mutex);
                    for (Entry<String, String> entry : entries) {
                      outer.put(entry.getKey(), entry.getValue());

 *
 * @author Kurt Alfred Kluever
 */
public class SynchronizedDequeTest extends TestCase {

  protected Deque<String> create() {
    TestDeque<String> inner = new TestDeque<>();
    Deque<String> outer = Synchronized.deque(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {

 *
 * @author Kurt Alfred Kluever
 */
public class SynchronizedDequeTest extends TestCase {

  protected Deque<String> create() {
    TestDeque<String> inner = new TestDeque<>();
    Deque<String> outer = Synchronized.deque(inner, inner.mutex);
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {

                  protected SetMultimap<String, String> create(Entry<String, String>[] entries) {
                    TestMultimap<String, String> inner = new TestMultimap<>();
                    SetMultimap<String, String> outer =
                        Synchronized.setMultimap(inner, inner.mutex);
                    for (Entry<String, String> entry : entries) {
                      outer.put(entry.getKey(), entry.getValue());

        self.app = app
        self.max_content_size = max_content_size

    def receive_wrapper(self, receive):
        received = 0

        async def inner():
            nonlocal received
            message = await receive()
            if message["type"] != "http.request":
                return message  # pragma: no cover