assertEquals(ImmutableSet.of(1), testTable.columnKeySet());
  }

  public void testColumnMap() {
    assertEquals(ImmutableMap.of(1, ImmutableMap.of('a', "blah")), testTable.columnMap());
  }

  public void testRow() {
    assertEquals(ImmutableMap.of(), testTable.row('A'));
    assertEquals(ImmutableMap.of(1, "blah"), testTable.row('a'));
  }

  public void testRowKeySet() {

    public void testIsExist() throws Exception {
        assertEquals("1", true, ResourceUtil.isExist("CLMessages.properties"));
        assertEquals("2", false, ResourceUtil.isExist("hoge"));
    }

    /**
     * @throws Exception
     */
    public void testGetExtension() throws Exception {
        assertEquals("1", "xml", ResourceUtil.getExtension("aaa/bbb.xml"));
        assertEquals("2", null, ResourceUtil.getExtension("aaa"));
    }

      assertEquals(ImmutableMap.of(1, "foo", 2, "baz"), testInstance.row('a'));
      assertEquals(ImmutableMap.of(1, "bar"), testInstance.row('b'));
      assertEquals(ImmutableMap.of(), testInstance.row('c'));
    }
  }

  public void testRowKeySet() {
    for (ImmutableTable<Character, Integer, String> testInstance : getTestInstances()) {

    Set<String> all = Sets.union(friends, enemies);
    assertEquals(5, all.size());

    ImmutableSet<String> immut = Sets.union(friends, enemies).immutableCopy();
    HashSet<String> mut = Sets.union(friends, enemies).copyInto(new HashSet<String>());

    enemies.add("Buck");
    assertEquals(6, all.size());
    assertEquals(5, immut.size());
    assertEquals(5, mut.size());
  }

  public void testIntersection() {

          @Override
          public void run() {
            assertEquals(
                "tearDownTwo should have been run before tearDownOne", false, tearDownOne.ran);
          }
        };

    final SimpleTearDown tearDownTwo = new SimpleTearDown(callback);
    stack.addTearDown(tearDownTwo);

    assertEquals(false, tearDownOne.ran);
    assertEquals(false, tearDownTwo.ran);

    stack.runTearDown();

        context.put("project.baseUri", "myBaseUri");
    }

    protected void assertProblemFree(SimpleProblemCollector collector) {
        assertEquals(0, collector.getErrors().size(), "Expected no errors");
        assertEquals(0, collector.getWarnings().size(), "Expected no warnings");
        assertEquals(0, collector.getFatals().size(), "Expected no fatals");
    }

    protected void assertCollectorState(

    if (isAndroid) {
      // Charset.forName("'utf-8'") == UTF-8
      assertEquals("UTF-8", mediaType.charsetName())
    } else {
      assertNull(mediaType.charset())
    }
  }

  @Test fun testDefaultCharset() {
    val noCharset = parse("text/plain")
    assertEquals(
      "UTF-8",
      noCharset.charset(Charsets.UTF_8)!!.name(),
    )
    assertEquals(
      "US-ASCII",
      noCharset.charset(Charsets.US_ASCII)!!.name(),

 * under the License.
 */
package org.apache.maven.artifact.resolver.filter;

import java.util.Arrays;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Tests {@link AndArtifactFilter}.
 *
 */
class AndArtifactFilterTest {

    assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset);
    assertEquals(1, iterable.count);
  }

  public void testCopyOf_hashMultiset() {
    Multiset<String> iterable = HashMultiset.create(asList("a", "b", "a"));
    Multiset<String> multiset = ImmutableMultiset.copyOf(iterable);
    assertEquals(HashMultiset.create(asList("a", "b", "a")), multiset);
  }

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.model;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Tests {@code Scm}.
 *