assertIntact(mmHeap);
  }

  public void testSmall() {
    MinMaxPriorityQueue<Integer> mmHeap = MinMaxPriorityQueue.create();
    mmHeap.add(1);
    mmHeap.add(4);
    mmHeap.add(2);
    mmHeap.add(3);
    assertEquals(4, (int) mmHeap.pollLast());
    assertEquals(3, (int) mmHeap.peekLast());
    assertEquals(3, (int) mmHeap.pollLast());
    assertEquals(1, (int) mmHeap.peek());

        String key = "key";
        String value1 = "a";
        String value2 = "b";
        String value3 = "c";
        settings.array().add(key, value1);
        settings.array().add(key, value2);
        settings.array().add(key, value3);
        assertEquals(3, settings.array().get(key).length);
        assertEquals(value1, settings.array().get(key)[0]);

	ADD	R0->28, R1           // 401e81e0
	ADD	R0@>28, R1           // 601e81e0
	ADD.S	R0<<28, R1           // 001e91e0
	ADD.S	R0>>28, R1           // 201e91e0
	ADD.S	R0->28, R1           // 401e91e0
	ADD.S	R0@>28, R1           // 601e91e0
	ADD	R0<<R1, R2, R3       // 103182e0
	ADD	R0>>R1, R2, R3       // 303182e0
	ADD	R0->R1, R2, R3       // 503182e0
	ADD	R0@>R1, R2, R3       // 703182e0

  }

  public void testIteratorRemove_actualMap() {
    // Override to avoid using mocks.
    multiset = ConcurrentHashMultiset.create();

    multiset.add(KEY);
    multiset.add(KEY + "_2");
    multiset.add(KEY);

    int mutations = 0;
    for (Iterator<String> it = multiset.iterator(); it.hasNext(); ) {
      it.next();
      it.remove();
      mutations++;
    }

    }

    @Subscribe
    @Override
    public void annotatedIn1And2AndClass(Object o) {
      annotatedIn1And2AndClassEvents.add(o);
    }

    @Subscribe
    @Override
    public void declaredIn2AnnotatedInClass(Object o) {
      declaredIn2AnnotatedInClassEvents.add(o);
    }

    @Override
    public void annotatedIn2(Object o) {
      annotatedIn2Events.add(o);
    }

    assertSame(c, ImmutableMultiset.copyOf(c));
  }

  public void testBuilderAdd() {
    ImmutableMultiset<String> multiset =
        new ImmutableMultiset.Builder<String>().add("a").add("b").add("a").add("c").build();
    assertEquals(HashMultiset.create(asList("a", "b", "a", "c")), multiset);
  }

  public void testBuilderAddAll() {
    List<String> a = asList("a", "b");

                    if (StringUtil.isNotEmpty(role)) {
                        roleSet.add(role);
                    }
                }
            }
        } else {
            final String[] roles = rolesStr.split(roleSeparator);
            for (final String role : roles) {
                if (StringUtil.isNotEmpty(role)) {
                    roleSet.add(role);
                }
            }
        }
    }

            stream(form.ex_q).of(stream -> stream.filter(StringUtil::isNotBlank).distinct()
                    .forEach(q -> pagingQueryList.add("ex_q=" + LaFunctions.u(q))));
        }
        if (StringUtil.isNotBlank(form.sort)) {
            pagingQueryList.add("sort=" + LaFunctions.u(form.sort));
        }
        if (form.lang != null) {
            final Set<String> langSet = new HashSet<>();

        if (!exList.contains(e)) {
            exList.add(e);
        }

        List<MetadataGraphEdge> inList = incidentEdges.computeIfAbsent(vTo, k -> new ArrayList<>());

        if (!inList.contains(e)) {
            inList.add(e);
        }

        return this;
    }

        this.javaVersion = javaVersion;
        primitiveTypes.add("boolean");
        primitiveTypes.add("byte");
        primitiveTypes.add("short");
        primitiveTypes.add("int");
        primitiveTypes.add("long");
        primitiveTypes.add("char");
        primitiveTypes.add("float");
        primitiveTypes.add("double");
        primitiveTypes.add("void");
    }