}
  }

  public static final class LongsAsListHeadSubListGenerator extends TestLongListGenerator {
    @Override
    protected List<Long> create(Long[] elements) {
      Long[] suffix = {Long.MIN_VALUE, Long.MAX_VALUE};
      Long[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class LongsAsListTailSubListGenerator extends TestLongListGenerator {
    @Override

                    signature.append(typeNameResolver.resolve(typeMatcher.group(1), classMetaData));
                    String suffix = typeMatcher.group(2);
                    if (suffix.equals("...")) {
                        suffix = "[]";
                    }
                    signature.append(suffix);
                }
            }
            signature.append(")");
            methodSignature = signature.toString();

  }

  public static final class FloatsAsListHeadSubListGenerator extends TestFloatListGenerator {
    @Override
    protected List<Float> create(Float[] elements) {
      Float[] suffix = {Float.MIN_VALUE, Float.MAX_VALUE};
      Float[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class FloatsAsListTailSubListGenerator extends TestFloatListGenerator {
    @Override

  }

  public static final class FloatsAsListHeadSubListGenerator extends TestFloatListGenerator {
    @Override
    protected List<Float> create(Float[] elements) {
      Float[] suffix = {Float.MIN_VALUE, Float.MAX_VALUE};
      Float[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class FloatsAsListTailSubListGenerator extends TestFloatListGenerator {
    @Override

  public static final class IntsAsListHeadSubListGenerator extends TestIntegerListGenerator {
    @Override
    protected List<Integer> create(Integer[] elements) {
      Integer[] suffix = {Integer.MIN_VALUE, Integer.MAX_VALUE};
      Integer[] all = concat(elements, suffix);
      return asList(all).subList(0, elements.length);
    }
  }

  public static final class IntsAsListTailSubListGenerator extends TestIntegerListGenerator {

  @Test
  public void testWildcardAndExclusion() {
    // *.ck is a public suffix
    assertThat(PublicSuffixPatterns.TRIE.findSuffixIndex(ImmutableList.of("foo", "ck")))
        .isEqualTo(0);
    assertThat(PublicSuffixPatterns.TRIE.findSuffixIndex(ImmutableList.of("bar", "foo", "ck")))
        .isEqualTo(1);

    // !www.ck is an exception, so ck is the suffix

    }

    buffer.write(deflatedBytes, deflatedBytes.size)
  }

  @Throws(IOException::class)
  override fun close() = deflaterSink.close()

  private fun Buffer.endsWith(suffix: ByteString): Boolean = rangeEquals(size - suffix.size, suffix)

    #  This property is valid only when generateProcedureParameterBean is valid.
    #
    #; targetProcedureCatalogList = list:{FOO_CATALOG ; prefix:FOO_ ; suffix:_FOO ; contain:_FOO_}
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o targetProcedureSchemaList: (NotRequired - Default list:{})

     * @param suffix The suffix string to be used in generating the file's name.
     * @param directory The directory in which the file is to be created, or null if the default temporary-file directory is to be used.
     * @return The created temporary file.
     */
    protected File createTempFile(final String prefix, final String suffix, final File directory) {
        try {

          "testEqualsAndSerializable",
          "testEqualsAndSerialization",
          "testEquality");

  private static final Chopper TEST_SUFFIX =
      suffix("Test").or(suffix("Tests")).or(suffix("TestCase")).or(suffix("TestSuite"));

  private final Logger logger = Logger.getLogger(getClass().getName());
  private final ClassSanityTester tester = new ClassSanityTester();