*            The algorithm. Must not be {@literal null} or an empty string.
     * @param text
     *            The string to be hashed.
     * @return The hashed string.
     */
    public static String digest(final String algorithm, final String text) {
        assertArgumentNotEmpty("algorithm", algorithm);

        if (text == null) {
            return null;
        }

        final MessageDigest msgDigest = getInstance(algorithm);

        private String reading;

        public TestAnalyzeToken(String term, int position, int startOffset, int endOffset, int positionIncrement, String type,
                java.util.Map<String, Object> attributes) {
            super(term, position, startOffset, endOffset, positionIncrement, type, attributes);
        }

        public String getReading() {
            return reading;
        }

        assertEquals(expectedNode, resolvedNode, "Resolution node");
    }

    protected Artifact createArtifact(String id, String version) throws InvalidVersionSpecificationException {
        return createArtifact(id, version, Artifact.SCOPE_COMPILE);
    }

    protected Artifact createArtifact(String id, String version, String scope)
            throws InvalidVersionSpecificationException {

	"fmt"
	"sort"
	"strconv"
	"strings"
)

type Index struct {
	Name    string
	Class   string // UNIQUE | FULLTEXT | SPATIAL
	Type    string // btree, hash, gist, spgist, gin, and brin
	Where   string
	Comment string
	Option  string        // WITH PARSER parser_name
	Fields  []IndexOption // Note: IndexOption's Field maybe the same
}

type IndexOption struct {
	*Field
	Expression string
	Sort       string // DESC, ASC

     */
    String findTool(String toolName);

    /**
     * Let the toolchain decide if it matches requirements defined
     * in the toolchain plugin configuration.
     *
     * @param requirements key value pair, may not be {@code null}
     * @return {@code true} if the requirements match, otherwise {@code false}
     */
    boolean matchesRequirements(Map<String, String> requirements);

      override fun getRuntimeClasspathConfigurationName(): String = jvmMainSourceSet.runtimeClasspathConfigurationName + "ForFakeMain"

      override fun getRuntimeOnlyConfigurationName(): String = jvmMainSourceSet.runtimeOnlyConfigurationName + "ForFakeMain"

      override fun getTaskName(
        verb: String?,
        target: String?,

  // Extending CharEscaper (instead of Escaper) makes Escapers.compose() easier.
  private static final Escaper NULL_ESCAPER =
      new CharEscaper() {
        @Override
        public String escape(String string) {
          return checkNotNull(string);
        }

        @Override
        protected char @Nullable [] escape(char c) {
          // TODO: Fix tests not to call this directly and make it throw an error.
          return null;

	return checkBucketAndObjectNames(ctx, bucket, object)
}

// Checks on DeleteObject arguments, bucket and object.
func checkDelObjArgs(ctx context.Context, bucket, object string) error {
	return checkBucketAndObjectNames(ctx, bucket, object)
}

// Checks bucket and object name validity, returns nil if both are valid.
func checkBucketAndObjectNames(ctx context.Context, bucket, object string) error {

        FloatBuffer.class,
        DoubleBuffer.class,
        String[].class,
        Object[].class,
        int[].class);
  }

  public void testStringArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    String[] a1 = generator.generateFresh(String[].class);
    String[] a2 = generator.generateFresh(String[].class);
    assertFalse(a1[0].equals(a2[0]));
  }

      };
    }
  }

  @Override
  protected Map<String, String> makeEmptyMap() {
    Map<String, Integer> underlying = new HashMap<>();
    return transformValues(
        new UnmodifiableIteratorMap<String, Integer>(underlying), Functions.toStringFunction());
  }

  @Override
  protected Map<String, String> makePopulatedMap() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);