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

      "allowedVersions": "<2.0.0",
      "description": "JDK 11 requirement"
    },
    {
      "matchPackageNames": ["gradle"],
      "allowedVersions": "<8.0",
      "description": "Recent release, not compatible with pinned AGP and Kotlin versions yet. Wait for AGP 8?"
    },
    {
      "matchPackageNames": ["com.android.tools.build:gradle"],
      "allowedVersions": "<7.4",

      <organization>ASF</organization>
      <roles>
        <role>PMC Member</role>
      </roles>
      <timezone>-5</timezone>
    </developer>
    <developer>
      <id>kenney</id>
      <name>Kenney Westerhof</name>
      <email>kenney@apache.org</email>
      <organization>Neonics</organization>
      <roles>
        <role>PMC Member</role>
      </roles>
      <timezone>+1</timezone>
    </developer>

 */
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
    }

      <id>trygvis</id>
      <email>******@****.***</email>
      <roles>
        <role>Developer</role>
      </roles>
    </developer>
    <developer>
      <name>Kenney Westerhof</name>
      <id>kenney</id>
      <email>kenney@codehaus.org</email>
      <roles>
        <role>Developer</role>
      </roles>
    </developer>
    <developer>
      <name>Carlos Sanchez</name>
      <id>carlos</id>

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    /**
     * @return name of size the element must be higher or equal to
     */
    String minKey() default StringUtil.EMPTY;

    /**
     * @return name of size the element must be lower or equal to
     */
    String maxKey() default StringUtil.EMPTY;

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