String[] empty = ObjectArrays.newArray(String.class, 0);
    assertEquals(String[].class, empty.getClass());
    assertThat(empty).isEmpty();
  }

  @GwtIncompatible // ObjectArrays.newArray(Class, int)
  public void testNewArray_fromClass_Nonempty() {
    String[] array = ObjectArrays.newArray(String.class, 2);
    assertEquals(String[].class, array.getClass());
    assertThat(array).hasLength(2);

        DocList docList = new DocList();

        assertEquals(0, docList.getContentSize());
        assertEquals(0, docList.getProcessingTime());

        docList.addContentSize(1000);
        docList.addProcessingTime(999);
        assertEquals(1000, docList.getContentSize());
        assertEquals(999, docList.getProcessingTime());

        docList.clear();
        assertEquals(0, docList.getContentSize());

        if (list.contains(key)) {
          assertEquals(list.indexOf(key), answer);
          return;
        }
        break;
      case LAST_PRESENT:
        if (list.contains(key)) {
          assertEquals(list.lastIndexOf(key), answer);
          return;
        }
        break;
      case ANY_PRESENT:
        if (list.contains(key)) {
          assertEquals(key, list.get(answer));
          return;
        }

      assertFalse(name, domain.isTopDomainUnderRegistrySuffix());
    }
  }

  public void testParent() {
    assertEquals("com", InternetDomainName.from("google.com").parent().toString());
    assertEquals("uk", InternetDomainName.from("co.uk").parent().toString());
    assertEquals("google.com", InternetDomainName.from("www.google.com").parent().toString());

    try {
      InternetDomainName.from("com").parent();

     */
    public void testFromWindowsMapping() throws Exception {
        assertNull(StringConversionUtil.fromWindowsMapping(null));
        assertEquals("", StringConversionUtil.fromWindowsMapping(""));
        assertEquals("abc 123", StringConversionUtil.fromWindowsMapping("abc 123"));
        assertEquals("abc\uFF5E\u2225\uFF0D\uFFE0\uFFE1\uFFE2",
                StringConversionUtil.fromWindowsMapping("abc\u301C\u2016\u2212\u00A2\u00A3\u00AC"));
    }

import static org.codehaus.plexus.testing.PlexusExtension.getBasedir;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;

/**
 * Test cases for the project {@code ModelResolver} implementation.
 *

            }
          }
        };

    assertEquals(0, (int) iter.peek());
    assertEquals(0, (int) iter.peek());
    assertTrue(iter.hasNext());
    assertEquals(0, (int) iter.peek());
    assertEquals(0, (int) iter.next());

    assertEquals(1, (int) iter.peek());
    assertEquals(1, (int) iter.next());

    try {
      iter.peek();

            Object[] array = s.toArray();
            for (int i = 0; i < 2; i++) {
                assertEquals(values[i], array[i]);
            }
        });
    }

    public void test_ofNull() {
        assertEquals(0, (int) StreamUtil.stream().get(s -> s.toArray().length));
        Object[] o = {};
        assertEquals(0, (int) StreamUtil.stream(o).get(s -> s.toArray().length));

            return NO_CHARS;
          }
        };
    EscaperAsserts.assertBasic(escaper);
    assertEquals("<tab>Fish <and> Chips<newline>", escaper.escape("\tFish & Chips\n"));

    // Verify that everything else is left unescaped.
    String safeChars = "\0\u0100\uD800\uDC00\uFFFF";
    assertEquals(safeChars, escaper.escape(safeChars));

    // Ensure that Unicode escapers behave correctly wrt badly formed input.

  }

  public void testOrderedPermutationSetSizeOverflow() {
    // 12 elements won't overflow
    assertEquals(
        479001600 /*12!*/,
        Collections2.orderedPermutations(newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
            .size());
    // 13 elements overflow an int
    assertEquals(
        Integer.MAX_VALUE,