}

    @Override
    public String toString() {
      return sourceFormat + ".converterTo(" + targetFormat + ")";
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0L;
  }

  abstract String normalizeWord(String word);

  String normalizeFirstWord(String word) {
    return normalizeWord(word);
  }

        Tuple3<String, String, String> task = thumbnailGenerator.createTask("", docMap);
        assertNull(task);
    }

    public void test_createTask_withNullDocMap() {
        // Test task creation with null document map
        String path = "/path/to/document.pdf";

        Tuple3<String, String, String> task = thumbnailGenerator.createTask(path, null);
        assertNull(task);
    }

  private static final class FloatConverter extends Converter<String, Float>
      implements Serializable {
    static final Converter<String, Float> INSTANCE = new FloatConverter();

    @Override
    protected Float doForward(String value) {
      return Float.valueOf(value);
    }

    @Override
    protected String doBackward(Float value) {
      return value.toString();
    }

    @Override

            // Verify state is maintained through multiple toString calls
            String firstToString = notification.toString();
            String secondToString = notification.toString();
            assertEquals(firstToString, secondToString);

            // Verify state is maintained after write operation
            notification.writeBytesWireFormat(new byte[64], 0);
            String thirdToString = notification.toString();

        final Map<String, String> ret = newHashMap();
        for (final Enumeration<String> e = bundle.getKeys(); e.hasMoreElements();) {
            final String key = e.nextElement();
            final String value = bundle.getString(key);
            ret.put(key, value);
        }
        return ret;
    }

    /**
     * Converts the resource bundle to a {@link Map} and returns it.
     *

        }
    }
}

class FunctionalTest(
    model: CIBuildModel,
    id: String,
    name: String,
    description: String,
    val testCoverage: TestCoverage,
    stage: Stage,
    parallelizationMethod: ParallelizationMethod = ParallelizationMethod.None,
    subprojects: List<String> = listOf(),
    extraParameters: String = "",
    extraBuildSteps: BuildSteps.() -> Unit = {},

  private static final class DoubleConverter extends Converter<String, Double>
      implements Serializable {
    static final Converter<String, Double> INSTANCE = new DoubleConverter();

    @Override
    protected Double doForward(String value) {
      return Double.valueOf(value);
    }

    @Override
    protected String doBackward(Double value) {
      return value.toString();
    }

    @Override

   * and returns {@code null} if non-ASCII digits are present in the string.
   *
   * <p>Note that strings prefixed with ASCII {@code '+'} are rejected, even though {@link
   * Integer#parseInt(String)} accepts them.
   *
   * @param string the string representation of an integer value
   * @return the integer value represented by {@code string}, or {@code null} if {@code string} has
   *     a length of zero or cannot be parsed as an integer value

/** An ordering that uses the natural order of the string representation of the values. */
@GwtCompatible
final class UsingToStringOrdering extends Ordering<Object> implements Serializable {
  static final UsingToStringOrdering INSTANCE = new UsingToStringOrdering();

  @Override
  public int compare(Object left, Object right) {
    return left.toString().compareTo(right.toString());
  }

        super("ECL0072", asArray(getSql(cause), getRealMessage(cause), Integer.toString(cause.getErrorCode()), cause.getSQLState()), cause);
    }

    /**
     * Returns the <code>SQL</code>.
     *
     * @param cause the underlying exception
     * @return the <code>SQL</code>
     */
    protected static String getSql(final SQLException cause) {
        if (cause instanceof ClSQLException) {