@MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();
                }));

    interface Transformer {
        /**
         * Interpolate the value read from the xml document
         *
         * @param source    The source value
         * @param fieldName A description of the field being interpolated. The implementation may use this to
         *                  log stuff.
         * @return the interpolated value
         */
        String transform(String source, String fieldName);
    }

	yyyymmdd        = "20060102"
)

type serviceType string

const (
	serviceS3  serviceType = "s3"
	serviceSTS serviceType = "sts"
)

// getCanonicalHeaders generate a list of request headers with their values
func getCanonicalHeaders(signedHeaders http.Header) string {
	var headers []string
	vals := make(http.Header, len(signedHeaders))
	for k, vv := range signedHeaders {
		k = strings.ToLower(k)
		headers = append(headers, k)

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

/**
 * Static utilities for the eight primitive types and {@code void}, and value types for treating
 * them as unsigned or storing them in immutable arrays.
 *
 * <p>This package is a part of the open-source <a href="https://github.com/google/guava">Guava</a>
 * library.
 *

        return null;
    }

    public void setBoostValue(final String value) {
        if (value != null) {
            try {
                boost = Float.parseFloat(value);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Invalid boost value, keeping current: value={}, error={}", value, e.getMessage());
                }
            }
        }
    }

  }

  private static final class MockCallback implements FutureCallback<String> {
    @Nullable private String value = null;
    @Nullable private Throwable failure = null;
    private boolean wasCalled = false;
    private final Object monitor = new Object();

    MockCallback(String expectedValue) {
      this.value = expectedValue;
    }

    MockCallback(Throwable expectedFailure) {
      this.failure = expectedFailure;

            disallow.add(st.nextToken().trim());
        }
        this.disallowCompound = disallow;
    }

    /**
     * Initializes default configuration values.
     * Sets up default values for various configuration parameters if not already specified.
     *
     * @throws CIFSException if there is an error during initialization
     */

                + ", includedPaths=" + includedPaths + ", name=" + name + ", sortOrder=" + sortOrder + ", updatedBy=" + updatedBy
                + ", updatedTime=" + updatedTime + ", value=" + value + ", docMeta=" + docMeta + "]";
    }

        Map<String, ?> getUserData() { return userData }

        Object getUserData(String key) {
            return userData[key]
        }

        void putUserData(String key, Object value) {
            userData[key] = value
        }
    }

    ClassPool instanceScopedPool = new ClassPool()

    JApiClass apiClass = Stub(JApiClass)

    def setup() {
        instanceScopedPool.appendSystemPath()
    }

 * https://github.com/graalvm/native-build-tools/issues/745
 */
class WithArgumentSourceTest {
  @ParameterizedTest
  @ArgumentsSource(FakeArgumentsProvider::class)
  fun passingTest(value: Int) {
    assertThat(value).isGreaterThan(0)
  }
}

internal class FakeArgumentsProvider : ArgumentsProvider {
  override fun provideArguments(
    parameters: ParameterDeclarations?,
    context: ExtensionContext?,