*/
private fun doesDoubleColonUseLHS(lhs: PsiElement): Boolean {
    val reference = when (val inner = lhs.unwrapParenthesesLabelsAndAnnotations()) {
        is KtReferenceExpression ->
            inner.mainReference
        is KtDotQualifiedExpression ->
            (inner.selectorExpression as? KtReferenceExpression)?.mainReference ?: return true
        else ->
            return true
    }

 *
 * @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> {

    @SuppressWarnings("unchecked")
    NavigableMap<K, V> innermost =
        new SafeTreeMap<>((Comparator<? super K>) Ordering.natural().nullsFirst());
    TestMap<K, V> inner = new TestMap<>(innermost, mutex);
    NavigableMap<K, V> outer = Synchronized.navigableMap(inner, mutex);
    return outer;
  }

  static class TestEntry<K, V> extends ForwardingMapEntry<K, V> implements Serializable {
    private final Entry<K, V> delegate;

                  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());

  public void testResolveInnerClass() {
    assertEquals(String.class, new Owner<Integer>().new Inner<String>() {}.getTypeArgument());
  }

  @SuppressWarnings("RestrictedApiChecker") // crashes under JDK8, which EP no longer supports
  public void testResolveOwnerClass() {
    assertEquals(Integer.class, new Owner<Integer>().new Inner<String>() {}.getOwnerType());
  }

  private static class Mapping<F, T> {

	}

	dryDB := DB.Session(&gorm.Session{DryRun: true})
	r := dryDB.Distinct("u.id, u.*").Table("user_speaks as s").Joins("inner join users as u on u.id = s.user_id").Where("s.language_code ='US' or s.language_code ='ES'").Find(&User{})
	if !regexp.MustCompile(`SELECT DISTINCT u\.id, u\.\* FROM user_speaks as s inner join users as u`).MatchString(r.Statement.SQL.String()) {
		t.Fatalf("Build Distinct with u.*, but got %v", r.Statement.SQL.String())
	}

            .createTestSuite());
    return suite;
  }

  @Override
  protected <K, V> BiMap<K, V> create() {
    TestBiMap<K, V> inner = new TestBiMap<>(HashBiMap.<K, V>create(), mutex);
    BiMap<K, V> outer = Synchronized.biMap(inner, mutex);
    return outer;
  }

  public static final class SynchronizedHashBiMapGenerator extends TestStringBiMapGenerator {
    @Override

        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

public class SynchronizedMapTest extends TestCase {
  public final Object mutex = new Integer(1); // something Serializable

  protected <K, V> Map<K, V> create() {
    TestMap<K, V> inner = new TestMap<>(new HashMap<K, V>(), mutex);
    Map<K, V> outer = Synchronized.map(inner, mutex);
    return outer;
  }

  static class TestMap<K, V> extends ForwardingMap<K, V> implements Serializable {
    public final Object mutex;

  public void testResolveInnerClass() {
    assertEquals(String.class, new Owner<Integer>().new Inner<String>() {}.getTypeArgument());
  }

  @SuppressWarnings("RestrictedApiChecker") // crashes under JDK8, which EP no longer supports
  public void testResolveOwnerClass() {
    assertEquals(Integer.class, new Owner<Integer>().new Inner<String>() {}.getOwnerType());
  }

  private static class Mapping<F, T> {