AsyncTest.java

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2025 Apple Inc. and the Swift.org project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Swift.org project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

package com.example.swift;

import com.example.swift.MySwiftClass;
import com.example.swift.MySwiftLibrary;
import org.junit.jupiter.api.Test;
import org.swift.swiftkit.core.SwiftArena;

import java.time.Duration;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import java.util.OptionalLong;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicBoolean;

import static org.junit.jupiter.api.Assertions.*;

public class AsyncTest {
    @Test
    void asyncSum() throws Exception {
        // snippet.asyncUsageJava
        Future<Long> future = MySwiftLibrary.asyncSum(10, 12);

        Long result = future.get();
        assertEquals(22, result);
        // snippet.end
    }

    @Test
    void asyncSleep() throws Exception {
        // snippet.asyncSleepUsageJava
        Future<Void> future = MySwiftLibrary.asyncSleep();
        future.get();
        // snippet.end
    }

    @Test
    void asyncCopy() throws Exception {
        // snippet.asyncCopyUsageJava
        try (var arena = SwiftArena.ofConfined()) {
            MySwiftClass obj = MySwiftClass.init(10, 5, arena);
            Future<MySwiftClass> future = MySwiftLibrary.asyncCopy(obj, arena);

            MySwiftClass result = future.get();

            assertEquals(10, result.getX());
            assertEquals(5, result.getY());
        }
        // snippet.end
    }

    @Test
    void asyncThrows() {
        Future<Void> future = MySwiftLibrary.asyncThrows();

        ExecutionException ex = assertThrows(ExecutionException.class, future::get);

        Throwable cause = ex.getCause();
        assertNotNull(cause);
        assertEquals(Exception.class, cause.getClass());
        assertEquals("swiftError", cause.getMessage());
    }

    @Test
    void asyncOptional() throws Exception {
        Future<OptionalLong> future = MySwiftLibrary.asyncOptional(42);
        assertEquals(OptionalLong.of(42), future.get());
    }

    @Test
    void asyncString() throws Exception {
        Future<String> future = MySwiftLibrary.asyncString("hey");
        assertEquals("hey", future.get());
    }

    @Test
    void asyncSchedule_voidClosure() throws Exception {
        AtomicBoolean called = new AtomicBoolean(false);
        Future<Void> future = MySwiftLibrary.asyncSchedule(() -> {
            called.set(true);
            return CompletableFuture.completedFuture(null);
        });
        future.get();
        assertTrue(called.get(), "Async void closure should have been called");
    }

    @Test
    void asyncCompute_primitiveLongClosure() throws Exception {
        Future<Long> future = MySwiftLibrary.asyncCompute(21, (val) -> {
            return CompletableFuture.completedFuture(val * 2);
        });
        Long result = future.get();
        assertEquals(42L, result);
    }

    @Test
    void asyncCompute_backgroundThreadCompletion() throws Exception {
        Future<Long> future = MySwiftLibrary.asyncCompute(10, (val) -> {
            return CompletableFuture.supplyAsync(() -> {
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                return val + 15;
            });
        });
        Long result = future.get();
        assertEquals(25L, result);
    }

    @Test
    void asyncTransformDouble_primitiveDoubleClosure() throws Exception {
        Future<Double> future = MySwiftLibrary.asyncTransformDouble(3.5, (val) -> {
            return CompletableFuture.completedFuture(val * 2.0);
        });
        Double result = future.get();
        assertEquals(7.0, result, 0.001);
    }

    @Test
    void asyncScheduleThrowing_exceptionPropagates() {
        Future<Void> future = MySwiftLibrary.asyncScheduleThrowing(() -> {
            CompletableFuture<Void> failed = new CompletableFuture<>();
            failed.completeExceptionally(new RuntimeException("Java async failed"));
            return failed;
        });

        assertThrows(ExecutionException.class, future::get);
    }

    @Test
    void asyncFetchOptional_present() throws Exception {
        Future<OptionalLong> future = MySwiftLibrary.asyncFetchOptional(() -> {
            return CompletableFuture.completedFuture(OptionalLong.of(99L));
        });
        assertEquals(OptionalLong.of(99L), future.get());
    }

    @Test
    void asyncFetchOptional_empty() throws Exception {
        Future<OptionalLong> future = MySwiftLibrary.asyncFetchOptional(() -> {
            return CompletableFuture.completedFuture(OptionalLong.empty());
        });
        assertEquals(OptionalLong.empty(), future.get());
    }

    @Test
    void asyncComputeThrowing_success() throws Exception {
        Future<Long> future = MySwiftLibrary.asyncComputeThrowing(10, (val) -> {
            return CompletableFuture.completedFuture(val + 5);
        });
        assertEquals(15L, future.get());
    }

    @Test
    void asyncComputeThrowing_exceptionPropagates() {
        Future<Long> future = MySwiftLibrary.asyncComputeThrowing(10, (val) -> {
            CompletableFuture<Long> failed = new CompletableFuture<>();
            failed.completeExceptionally(new RuntimeException("compute throwing failed"));
            return failed;
        });

        assertThrows(ExecutionException.class, future::get);
    }
}