.createTestSuite());

    return suite;
  }

  public void testCreation_noArgs() {
    Multiset<String> multiset = ImmutableMultiset.of();
    assertTrue(multiset.isEmpty());
  }

  public void testCreation_oneElement() {
    Multiset<String> multiset = ImmutableMultiset.of("a");
    assertEquals(HashMultiset.create(asList("a")), multiset);
  }

    }

    private static boolean isEmpty(Object value) {
      // Put types estimated to be the most frequent first.
      if (value instanceof CharSequence) {
        return ((CharSequence) value).length() == 0;
      } else if (value instanceof Collection) {
        return ((Collection<?>) value).isEmpty();
      } else if (value instanceof Map) {
        return ((Map<?, ?>) value).isEmpty();

            // treat .X as -X for any string qualifier X
            if (!isDigit && !list.isEmpty()) {
                list.add(list = new ListItem());
                stack.push(list);
            }

            list.add(parseItem(isCombination, isDigit, version.substring(startIndex)));
        }

        while (!stack.isEmpty()) {
            list = (ListItem) stack.pop();
            list.normalize();
        }

                }

                return plan;

            } else if (phase != null && !phase.isEmpty()) {
                String forkedLifecycle = mojoDescriptor.getExecuteLifecycle();
                Lifecycle lifecycle;
                if (forkedLifecycle != null && !forkedLifecycle.isEmpty()) {
                    org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle lifecycleOverlay;
                    try {

        List<FileNotifyInformation> notifications = response.getNotifyInformation();

        assertNotNull(notifications);
        assertTrue(notifications.isEmpty());
        assertEquals(0, notifications.size());
    }

    @Test
    @DisplayName("Test NotifyResponse interface with single notification")
    void testNotifyResponseWithSingleNotification() {

      .containsExactlyInAnyOrder(a1, a2)
    assertThat(dispatcher.queuedCalls()).isEmpty()

    // Cancel some calls. That doesn't impact running or queued.
    a2.cancel()
    a3.cancel()
    assertThat(dispatcher.runningCalls())
      .containsExactlyInAnyOrder(a1, a2)
    assertThat(dispatcher.queuedCalls()).isEmpty()

    // Let the calls finish.
    waiting.countDown()
    t1.join()
    t2.join()

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.message;

import static org.codelibs.core.lang.StringUtil.isEmpty;

import java.text.MessageFormat;
import java.util.ResourceBundle;

import org.codelibs.core.io.ResourceBundleUtil;
import org.codelibs.core.misc.DisposableUtil;
import org.codelibs.core.misc.LocaleUtil;

/**

  @Override
  public boolean containsAll(Collection<?> c) {
    assertTrue(Thread.holdsLock(mutex));
    return super.containsAll(c);
  }

  @Override
  public boolean isEmpty() {
    assertTrue(Thread.holdsLock(mutex));
    return super.isEmpty();
  }

  /*
   * We don't assert that the lock is held during calls to iterator(), stream(), and spliterator:

    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.size();
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.isEmpty();
    }

    @Override
    public boolean containsValue(@Nullable Object value) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.containsValue(value);

     */
    private int checkHeaderComment(List<String> commentLines) {
        if (getHeader() == null && layout.isEmpty()) {
            // This is the first comment. Search for blank lines.
            int index = commentLines.size() - 1;
            while (index >= 0 && !commentLines.get(index).isEmpty()) {
                index--;
            }
            setHeader(new ArrayList<String>(commentLines.subList(0, index + 1)));