吐司(Toast)

import com.m8test.script.GlobalVariables.*

// 1. 创建协程作用域
// _coroutines 是全局对象，用于管理协程
val scope = _coroutines.newScope(null)

_console.log("🚀 开始测试 Toaster 接口...")

// 2. 测试显示短 Toast (showShort)
// _toaster 是全局变量，对应 Toaster 接口
_toaster.showShort(scope, "M8Test: 短提示 (Short)")
    .then { currentScope, _ ->
        // showShort 的 Deferred 完成表示请求已提交到主线程
        _console.log("✅ 短 Toast 请求已发送")

        // 为了便于观察，我们延迟 2.5 秒后再发送下一个 Toast
        // currentScope.delay(毫秒) 返回一个 Deferred<Unit>
        currentScope.delay(2500)
    }
    .then { currentScope, _ ->
        // 3. 延时结束后，测试显示长 Toast (showLong)
        _console.log("⏳ 延时结束，准备发送长 Toast")

        // 返回新的 Deferred 以继续链式调用
        _toaster.showLong(currentScope, "M8Test: 长提示 (Long)\n这条消息会停留较长时间")
    }
    .then { currentScope, _ ->
        _console.log("✅ 长 Toast 请求已发送")
        _console.log("🎉 Toaster 接口测试流程执行完毕")

        // 链式调用结束，返回一个空的 Deferred
        currentScope.resolve(null)
    }
    .onError { error ->
        // 4. 捕获并打印可能的异常
        _console.error("❌ 测试过程中发生错误: " + error)
    }

_script.getThreads().getMain().setBackground(true)

// 1. 创建协程作用域
// $coroutines 是全局对象，用于管理协程
def scope = $coroutines.newScope(null)

$console.log("🚀 开始测试 Toaster 接口...")

// 2. 测试显示短 Toast (showShort)
// $toaster 是全局变量，对应 Toaster 接口
$toaster.showShort(scope, "M8Test: 短提示 (Short)")
        .then { currentScope, _ ->
            // showShort 的 Deferred 完成表示请求已提交到主线程
            $console.log("✅ 短 Toast 请求已发送")

            // 为了便于观察，我们延迟 2.5 秒后再发送下一个 Toast
            // currentScope.delay(毫秒) 返回一个 Deferred<Unit>
            return currentScope.delay(2500)
        }
        .then { currentScope, _ ->
            // 3. 延时结束后，测试显示长 Toast (showLong)
            $console.log("⏳ 延时结束，准备发送长 Toast")

            // 返回新的 Deferred 以继续链式调用
            return $toaster.showLong(currentScope, "M8Test: 长提示 (Long)\n这条消息会停留较长时间")
        }
        .then { currentScope, _ ->
            $console.log("✅ 长 Toast 请求已发送")
            $console.log("🎉 Toaster 接口测试流程执行完毕")

            // 链式调用结束，返回一个空的 Deferred
            return currentScope.resolve(null)
        }
        .onError { error ->
            // 4. 捕获并打印可能的异常
            $console.error("❌ 测试过程中发生错误: " + error)
        }
$script.getThreads().getMain().setBackground(true)

// 1. 创建协程作用域
// $coroutines 是全局对象，用于管理协程
const scope = $coroutines.newScope(null);

$console.log("🚀 开始测试 Toaster 接口...");

// 2. 测试显示短 Toast (showShort)
// $toaster 是全局变量，对应 Toaster 接口
$toaster.showShort(scope, "M8Test: 短提示 (Short)")
    .then((currentScope, _) => {
        // showShort 的 Deferred 完成表示请求已提交到主线程
        $console.log("✅ 短 Toast 请求已发送");

        // 为了便于观察，我们延迟 2.5 秒后再发送下一个 Toast
        // currentScope.delay(毫秒) 返回一个 Deferred<Unit>
        return currentScope.delay(2500);
    })
    .then((currentScope, _) => {
        // 3. 延时结束后，测试显示长 Toast (showLong)
        $console.log("⏳ 延时结束，准备发送长 Toast");

        // 返回新的 Deferred 以继续链式调用
        return $toaster.showLong(currentScope, "M8Test: 长提示 (Long)\n这条消息会停留较长时间");
    })
    .then((currentScope, _) => {
        $console.log("✅ 长 Toast 请求已发送");
        $console.log("🎉 Toaster 接口测试流程执行完毕");

        // 链式调用结束，返回一个空的 Deferred
        return currentScope.resolve(null);
    })
    .onError(error => {
        // 4. 捕获并打印可能的异常
        $console.error("❌ 测试过程中发生错误: " + error);
    });

$script.getThreads().getMain().setBackground(true);

-- 1. 创建协程作用域
-- _coroutines 是全局对象，用于管理协程
local scope = _coroutines:newScope(nil)

_console:log("🚀 开始测试 Toaster 接口...")

-- 2. 测试显示短 Toast (showShort)
-- _toaster 是全局变量，对应 Toaster 接口
_toaster:showShort(scope, "M8Test: 短提示 (Short)")
    :thenDo(function(currentScope, _)
        -- showShort 的 Deferred 完成表示请求已提交到主线程
        _console:log("✅ 短 Toast 请求已发送")

        -- 为了便于观察，我们延迟 2.5 秒后再发送下一个 Toast
        -- currentScope.delay(毫秒) 返回一个 Deferred<Unit>
        return currentScope:delay(2500)
    end)
    :thenDo(function(currentScope, _)
        -- 3. 延时结束后，测试显示长 Toast (showLong)
        _console:log("⏳ 延时结束，准备发送长 Toast")

        -- 返回新的 Deferred 以继续链式调用
        return _toaster:showLong(currentScope, "M8Test: 长提示 (Long)\n这条消息会停留较长时间")
    end)
    :thenDo(function(currentScope, _)
        _console:log("✅ 长 Toast 请求已发送")
        _console:log("🎉 Toaster 接口测试流程执行完毕")

        -- 链式调用结束，返回一个空的 Deferred
        return currentScope:resolve(nil)
    end)
    :onError(function(error)
        -- 4. 捕获并打印可能的异常
        _console:error("❌ 测试过程中发生错误: " .. tostring(error))
    end)
_script:getThreads():getMain():setBackground(true)

<?php
/** @var m8test_java\com\m8test\script\core\api\coroutines\Coroutines $coroutines */
global $coroutines;
/** @var m8test_java\com\m8test\script\core\api\ui\Toaster $toaster */
global $toaster;
/** @var m8test_java\com\m8test\script\core\api\console\Console $console */
global $console;
/** @var m8test_java\com\m8test\script\core\api\engine\Script $script */
global $script;

// 1. 创建协程作用域
// $coroutines 是全局对象，用于管理协程
$scope = $coroutines->newScope(function ($context) {
    $context->setDispatcher(function ($dispatchers) {
        return $dispatchers->getScriptMain();
    });
});

$console->log(javaString("🚀 开始测试 Toaster 接口..."));

// 2. 测试显示短 Toast (showShort)
// $toaster 是全局变量，对应 Toaster 接口
$toaster->showShort($scope, javaString("M8Test: 短提示 (Short)"))
    ->then(function ($currentScope, $_) {
        global $console;
        // showShort 的 Deferred 完成表示请求已提交到主线程
        $console->log(javaString("✅ 短 Toast 请求已发送"));

        // 为了便于观察，我们延迟 2.5 秒后再发送下一个 Toast
        // currentScope.delay(毫秒) 返回一个 Deferred<Unit>
        return $currentScope->delay(2500);
    })
    ->then(function ($currentScope, $_) {
        global $console, $toaster;
        // 3. 延时结束后，测试显示长 Toast (showLong)
        $console->log(javaString("⏳ 延时结束，准备发送长 Toast"));

        // 返回新的 Deferred 以继续链式调用
        return $toaster->showLong($currentScope, javaString("M8Test: 长提示 (Long)\n这条消息会停留较长时间"));
    })
    ->then(function ($currentScope, $_) {
        global $console;
        $console->log(javaString("✅ 长 Toast 请求已发送"));
        $console->log(javaString("🎉 Toaster 接口测试流程执行完毕"));

        // 链式调用结束，返回一个空的 Deferred
        return $currentScope->resolve(null);
    })
    ->onError(function ($error) {
        // 4. 捕获并打印可能的异常
        global $console;
        $console->error(javaString("❌ 测试过程中发生错误: "), $error);
    });
$script->getThreads()->getMain()->setBackground(true);

# 导入所需的全局变量
from m8test_java.com.m8test.script.GlobalVariables import _coroutines
from m8test_java.com.m8test.script.GlobalVariables import _console
from m8test_java.com.m8test.script.GlobalVariables import _toaster
from m8test_java.com.m8test.script.GlobalVariables import _script

# 1. 创建协程作用域
# $coroutines 是全局对象，用于管理协程
scope = _coroutines.newScope(lambda it: it.setDispatcher(lambda d: d.getScriptMain()))

_console.log("🚀 开始测试 Toaster 接口...")

# 2. 测试显示短 Toast (showShort)
# $toaster 是全局变量，对应 Toaster 接口
_toaster.showShort(scope, "M8Test: 短提示 (Short)").then(lambda currentScope, _: (
    # showShort 的 Deferred 完成表示请求已提交到主线程
    _console.log("✅ 短 Toast 请求已发送"),
    # 为了便于观察，我们延迟 2.5 秒后再发送下一个 Toast
    # currentScope.delay(毫秒) 返回一个 Deferred<Unit>
    currentScope.delay(2500)
)[-1]).then(lambda currentScope, _: (
    # 3. 延时结束后，测试显示长 Toast (showLong)
    _console.log("⏳ 延时结束，准备发送长 Toast"),
    # 返回新的 Deferred 以继续链式调用
    _toaster.showLong(currentScope, "M8Test: 长提示 (Long)\n这条消息会停留较长时间")
)[-1]).then(lambda currentScope, _: (
    _console.log("✅ 长 Toast 请求已发送"),
    _console.log("🎉 Toaster 接口测试流程执行完毕"),
    # 链式调用结束，返回一个空的 Deferred
    currentScope.resolve(None)
)[-1]).onError(lambda error: (
    # 4. 捕获并打印可能的异常
    _console.error("❌ 测试过程中发生错误: " + str(error))
))

_script.getThreads().getMain().setBackground(True)

# encoding: utf-8
# 1. 创建协程作用域
# $coroutines 是全局对象，用于管理协程
scope = $coroutines.newScope(nil)

$console.log("🚀 开始测试 Toaster 接口...")

# 2. 测试显示短 Toast (showShort)
# $toaster 是全局变量，对应 Toaster 接口
$toaster.showShort(scope, "M8Test: 短提示 (Short)")
        .then { |currentScope, _|
          # showShort 的 Deferred 完成表示请求已提交到主线程
          $console.log("✅ 短 Toast 请求已发送")

          # 为了便于观察，我们延迟 2.5 秒后再发送下一个 Toast
          # currentScope.delay(毫秒) 返回一个 Deferred<Unit>
          # Ruby Block 中最后一行表达式即为返回值
          currentScope.delay(2500)
        }
        .then { |currentScope, _|
          # 3. 延时结束后，测试显示长 Toast (showLong)
          $console.log("⏳ 延时结束，准备发送长 Toast")

          # 返回新的 Deferred 以继续链式调用
          $toaster.showLong(currentScope, "M8Test: 长提示 (Long)\n这条消息会停留较长时间")
        }
        .then { |currentScope, _|
          $console.log("✅ 长 Toast 请求已发送")
          $console.log("🎉 Toaster 接口测试流程执行完毕")

          # 链式调用结束，返回一个空的 Deferred
          currentScope.resolve(nil)
        }
        .onError { |error|
          # 4. 捕获并打印可能的异常
          $console.error("❌ 测试过程中发生错误: " + error.to_s)
        }

$script.getThreads().getMain().setBackground(true)

09 December 2025