private final String name;
    private final List<Class<?>> parameterTypes;

    MethodIdentifier(Method method) {
      this.name = method.getName();
      this.parameterTypes = Arrays.asList(method.getParameterTypes());
    }

    @Override
    public int hashCode() {
      return Objects.hash(name, parameterTypes);
    }

    @Override
    public boolean equals(@Nullable Object o) {

                }
            }
        });
    }

    private static List<String> ps() {
        return run(determinePsCommand()).assertZeroExit().stdout.lines().collect(Collectors.toList());
    }

    private static String[] determinePsCommand() {
        if (isWindows()) {

          Object writeReplace() {
            return super.writeReplace();
          }
        };
    ImmutableRangeMap<K, V> outer = this;
    return new ImmutableRangeMap<K, V>(subRanges, values.subList(lowerIndex, upperIndex)) {
      @Override
      public ImmutableRangeMap<K, V> subRangeMap(Range<K> subRange) {
        if (range.isConnected(subRange)) {
          return outer.subRangeMap(subRange.intersection(range));

Lkotlin/collections/AbstractList$IteratorImpl;
Lkotlin/collections/AbstractList$ListIteratorImpl$$ExternalSyntheticOutline0;
Lkotlin/collections/AbstractList$ListIteratorImpl;
Lkotlin/collections/AbstractList$SubList;
Lkotlin/collections/AbstractList;
Lkotlin/collections/AbstractMutableList;
Lkotlin/collections/ArrayAsCollection;
Lkotlin/collections/ArrayDeque;
Lkotlin/collections/ArraysKt__ArraysKt;

      client
        .newBuilder()
        .protocols(Arrays.asList(Protocol.HTTP_1_1))
        .build()
    assertContent("A", getResponse(newRequest("/")))
  }

  @Test
  fun setProtocolsWithoutHttp11() {
    assertFailsWith<IllegalArgumentException> {
      OkHttpClient
        .Builder()
        .protocols(Arrays.asList(Protocol.HTTP_2))
    }
  }

  @Test

            InputLocationTracker tracker,
            String... validValues) {
        if (string == null || string.length() <= 0) {
            return true;
        }

        List<String> values = Arrays.asList(validValues);

        if (values.contains(string)) {
            return true;
        }

        addViolation(
                problems,
                severity,
                version,

      "take plan 1",
      "plan 0 cancel",
      "plan 0 TCP connect canceled",
    )
  }

  private fun assertEvents(vararg expected: String) {
    val actual = generateSequence { routePlanner.events.poll() }.toList()
    assertThat(actual).containsExactly(*expected)
  }

  private val Int.ms: Long
    get() = this * 1_000_000L

        upper = middle - 1;
      } else if (c > 0) {
        lower = middle + 1;
      } else {
        return lower
            + presentBehavior.resultIndex(
                comparator, key, list.subList(lower, upper + 1), middle - lower);
      }
    }
    return absentBehavior.resultIndex(lower);
  }

                CollectionFeature.ALLOWS_NULL_QUERIES)
            .createTestSuite());

    suite.addTest(
        ListTestSuiteBuilder.using(new ImmutableSetAsListGenerator())
            .named("ImmutableSet.asList")
            .withFeatures(
                CollectionSize.ANY,
                CollectionFeature.REJECTS_DUPLICATES_AT_CREATION,
                CollectionFeature.SERIALIZABLE,

			}); err != nil {
				return err
			}
		}
	}

	return nil
}

// GetTables returns tables
func (m Migrator) GetTables() (tableList []string, err error) {
	err = m.DB.Raw("SELECT TABLE_NAME FROM information_schema.tables where TABLE_SCHEMA=?", m.CurrentDatabase()).
		Scan(&tableList).Error
	return
}

// CreateTable create table in database for values