剪切板

import com.m8test.script.GlobalVariables.*

// 1. 创建协程作用域，这是启动异步任务所必须的
// _coroutines 是全局变量，对应 Coroutines 接口
val scope = _coroutines.newScope(null)

// 2. 准备测试数据
val testContent = "M8Test Clipboard Test: " + System.currentTimeMillis()
_console.log("准备写入剪贴板内容: " + testContent)

// 3. 执行设置剪贴板操作 (setText)
// _clipboard 是全局变量，对应 Clipboard 接口
_clipboard.setText(scope, testContent)
// 4. 处理 setText 的结果 (Deferred<Boolean>)
    .then { currentScope, isSuccess ->
        if (isSuccess) {
            _console.log("写入操作成功，正在准备读取...")

            // 写入成功后，返回一个新的 Deferred<String?> 进行链式调用
            // 这里调用 getText 读取剪贴板
            // Kotlin Lambda 中最后一行是返回值
            _clipboard.getText(currentScope)
        } else {
            _console.error("写入操作失败！")
            // 如果失败，返回一个包含 null 的已完成 Deferred
            currentScope.resolve(null)
        }
    }
// 5. 处理 getText 的结果 (Deferred<String?>)
    .then { currentScope, clipboardText ->
        _console.log("从剪贴板读取到的内容: " + clipboardText)

        // 验证结果
        if (clipboardText == testContent) {
            _console.log("✅ 测试通过：读取内容与写入内容一致。")
        } else {
            _console.error("❌ 测试失败：内容不一致。\n期望: $testContent\n实际: $clipboardText")
        }

        // 链式调用结束，返回一个空的 Deferred
        currentScope.resolve(true)
    }
// 6. 全局异常捕获
    .onError { error ->
        _console.error("测试过程中发生异常: " + error)
    }

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

// 1. 创建协程作用域，这是启动异步任务所必须的
// $coroutines 是全局变量，对应 Coroutines 接口
def scope = $coroutines.newScope(null)

// 2. 准备测试数据
def testContent = "M8Test Clipboard Test: " + System.currentTimeMillis()
$console.log("准备写入剪贴板内容: " + testContent)

// 3. 执行设置剪贴板操作 (setText)
// $clipboard 是全局变量，对应 Clipboard 接口
$clipboard.setText(scope, testContent)
// 4. 处理 setText 的结果 (Deferred<Boolean>)
        .then { currentScope, isSuccess ->
            if (isSuccess) {
                $console.log("写入操作成功，正在准备读取...")

                // 写入成功后，返回一个新的 Deferred<String?> 进行链式调用
                // 这里调用 getText 读取剪贴板
                return $clipboard.getText(currentScope)
            } else {
                $console.error("写入操作失败！")
                // 如果失败，返回一个包含 null 的已完成 Deferred，以便中断后续逻辑或传递失败状态
                return currentScope.resolve(null)
            }
        }
// 5. 处理 getText 的结果 (Deferred<String?>)
        .then { currentScope, clipboardText ->
            $console.log("从剪贴板读取到的内容: " + clipboardText)

            // 验证结果
            if (clipboardText == testContent) {
                $console.log("✅ 测试通过：读取内容与写入内容一致。")
            } else {
                $console.error("❌ 测试失败：内容不一致。\n期望: $testContent\n实际: $clipboardText")
            }

            // 链式调用结束，返回一个空的 Deferred
            return currentScope.resolve(true)
        }
// 6. 全局异常捕获
        .onError { error ->
            $console.error("测试过程中发生异常: " + error)
        }
$script.getThreads().getMain().setBackground(true)

// 1. 创建协程作用域，这是启动异步任务所必须的
// $coroutines 是全局变量，对应 Coroutines 接口
const scope = $coroutines.newScope(null);

// 2. 准备测试数据
const testContent = "M8Test Clipboard Test: " + Packages.java.lang.System.currentTimeMillis();
$console.log("准备写入剪贴板内容: " + testContent);

// 3. 执行设置剪贴板操作 (setText)
// $clipboard 是全局变量，对应 Clipboard 接口
$clipboard.setText(scope, testContent)
    // 4. 处理 setText 的结果 (Deferred<Boolean>)
    .then((currentScope, isSuccess) => {
        if (isSuccess == true) {
            $console.log("写入操作成功，正在准备读取...");

            // 写入成功后，返回一个新的 Deferred<String?> 进行链式调用
            // 这里调用 getText 读取剪贴板
            return $clipboard.getText(currentScope);
        } else {
            $console.error("写入操作失败！");
            // 如果失败，返回一个包含 null 的已完成 Deferred，以便中断后续逻辑或传递失败状态
            return currentScope.resolve(null);
        }
    })
    // 5. 处理 getText 的结果 (Deferred<String?>)
    .then((currentScope, clipboardText) => {
        $console.log("从剪贴板读取到的内容: " + clipboardText);

        // 验证结果
        if (clipboardText == testContent) {
            $console.log("✅ 测试通过：读取内容与写入内容一致。");
        } else {
            $console.error("❌ 测试失败：内容不一致。\n期望: " + testContent + "\n实际: " + clipboardText);
        }

        // 链式调用结束，返回一个空的 Deferred
        return currentScope.resolve(true);
    })
    // 6. 全局异常捕获
    .onError(error => {
        $console.error("测试过程中发生异常: " + error);
    });

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

-- 1. 创建协程作用域，这是启动异步任务所必须的
-- _coroutines 是全局变量，对应 Coroutines 接口
local scope = _coroutines:newScope(nil)

-- 2. 准备测试数据
local testContent = "M8Test Clipboard Test: " .. os.time() * 1000 -- os.time() is in seconds
_console:log("准备写入剪贴板内容: " .. testContent)

-- 3. 执行设置剪贴板操作 (setText)
-- _clipboard 是全局变量，对应 Clipboard 接口
_clipboard:setText(scope, testContent)
-- 4. 处理 setText 的结果 (Deferred<Boolean>)
    :_then(function(currentScope, isSuccess)
        if isSuccess then
            _console:log("写入操作成功，正在准备读取...")

            -- 写入成功后，返回一个新的 Deferred<String?> 进行链式调用
            -- 这里调用 getText 读取剪贴板
            return _clipboard:getText(currentScope)
        else
            _console:error("写入操作失败！")
            -- 如果失败，返回一个包含 nil 的已完成 Deferred，以便中断后续逻辑或传递失败状态
            return currentScope:resolve(nil)
        end
    end)
-- 5. 处理 getText 的结果 (Deferred<String?>)
    :_then(function(currentScope, clipboardText)
        _console:log("从剪贴板读取到的内容: " .. tostring(clipboardText))

        -- 验证结果
        if clipboardText == testContent then
            _console:log("✅ 测试通过：读取内容与写入内容一致。")
        else
            _console:error("❌ 测试失败：内容不一致。\n期望: " .. testContent .. "\n实际: " .. tostring(clipboardText))
        end

        -- 链式调用结束，返回一个空的 Deferred
        return currentScope:resolve(true)
    end)
-- 6. 全局异常捕获
    :onError(function(error)
        _console:error("测试过程中发生异常: " .. tostring(error))
    end)
_script:getThreads():getMain():setBackground(true)

<?php
// 通过 use 导入java类, 通过"m8test_java\全类名"的方式
use m8test_java\java\lang\System;

/** @var m8test_java\com\m8test\script\core\api\coroutines\Coroutines $coroutines */
global $coroutines;
/** @var m8test_java\com\m8test\script\core\api\device\Clipboard $clipboard */
global $clipboard;
/** @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 是全局变量，对应 Coroutines 接口
// 1. 创建协程作用域，并指定其调度器为脚本主线程
$scope = $coroutines->newScope(function ($context) {
    $context->setDispatcher(function ($dispatchers) {
        return $dispatchers->getScriptMain();
    });
});

// 2. 准备测试数据
$testContent = javaString("M8Test Clipboard Test: ") . System::currentTimeMillis();
$console->log(javaString("准备写入剪贴板内容: "), $testContent);

// 3. 执行设置剪贴板操作 (setText)
// $clipboard 是全局变量，对应 Clipboard 接口
$clipboard->setText($scope, $testContent)
// 4. 处理 setText 的结果 (Deferred<Boolean>)
    ->then(function ($currentScope, $isSuccess) use ($testContent, $clipboard) {
        global $console;
        if ($isSuccess) {
            $console->log(javaString("写入操作成功，正在准备读取..."));
            // 写入成功后，返回一个新的 Deferred<String> 进行链式调用
            // 这里调用 getText 读取剪贴板
            return $clipboard->getText($currentScope);
        } else {
            $console->error(javaString("写入操作失败！"));
            // 如果失败，返回一个包含 null 的已完成 Deferred，以便中断后续逻辑或传递失败状态
            return $currentScope->resolve(null);
        }
    })
    // 5. 处理 getText 的结果 (Deferred<String>)
    ->then(function ($currentScope, $clipboardText) use ($testContent) {
        global $console;
        $console->log(javaString("从剪贴板读取到的内容: "), $clipboardText);

        // 验证结果
        if ($clipboardText == $testContent) {
            $console->log(javaString("✅ 测试通过：读取内容与写入内容一致。"));
        } else {
            $console->error(javaString("❌ 测试失败：内容不一致。\n期望: ") . $testContent . javaString("\n实际: ") . $clipboardText);
        }

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

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

# 1. 创建协程作用域，这是启动异步任务所必须的
# $coroutines 是全局变量，对应 Coroutines 接口
scope = _coroutines.newScope(lambda it: it.setDispatcher(lambda d: d.getScriptMain()))

# 2. 准备测试数据
# System.currentTimeMillis() is Java, time.time() * 1000 is a Python equivalent
import time

testContent = "M8Test Clipboard Test: " + str(int(time.time() * 1000))
_console.log("准备写入剪贴板内容: " + testContent)

# 3. 执行设置剪贴板操作 (setText)
# $clipboard 是全局变量，对应 Clipboard 接口
_clipboard.setText(scope, testContent).then(
    # 4. 处理 setText 的结果 (Deferred<Boolean>)
    # 使用Python条件表达式处理 if/else 逻辑
    lambda currentScope, isSuccess:
    (
        _console.log("写入操作成功，正在准备读取..."),
        # 写入成功后，返回一个新的 Deferred<String?> 进行链式调用
        # 这里调用 getText 读取剪贴板
        _clipboard.getText(currentScope)
    )[-1] if isSuccess else (
        _console.error("写入操作失败！"),
        # 如果失败，返回一个包含 null 的已完成 Deferred
        currentScope.resolve(None)
    )[-1]
).then(
    # 5. 处理 getText 的结果 (Deferred<String?>)
    lambda currentScope, clipboardText: (
        _console.log("从剪贴板读取到的内容: " + str(clipboardText)),

        # 验证结果
        (
            _console.log("✅ 测试通过：读取内容与写入内容一致。") if clipboardText == testContent
            else _console.error(f"❌ 测试失败：内容不一致。\n期望: {testContent}\n实际: {clipboardText}")
        ),

        # 链式调用结束，返回一个空的 Deferred
        currentScope.resolve(True)
    )[-1]
).onError(
    # 6. 全局异常捕获
    lambda error: _console.error("测试过程中发生异常: ", error.stackTraceToString())
)

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

# encoding: utf-8
# 1. 创建协程作用域，这是启动异步任务所必须的
# $coroutines 是全局变量，对应 Coroutines 接口
scope = $coroutines.newScope(nil)

# 2. 准备测试数据
# 调用 Java 静态方法需要使用 M8testJava::Java::Lang::System::N__currentTimeMillis()
testContent = "M8Test Clipboard Test: " + M8testJava::Java::Lang::System::N__currentTimeMillis().to_s
$console.log("准备写入剪贴板内容: " + testContent)

# 3. 执行设置剪贴板操作 (setText)
# $clipboard 是全局变量，对应 Clipboard 接口
# 这里将 proc 改为了 block 形式，直接跟在方法后面
$clipboard.setText(scope, testContent)
          .then { |currentScope, isSuccess|
            if isSuccess
              $console.log("写入操作成功，正在准备读取...")

              # 写入成功后，返回一个新的 Deferred<String?> 进行链式调用
              # 这里调用 getText 读取剪贴板
              # Ruby Block 中最后一行表达式即为返回值，不要使用 return
              $clipboard.getText(currentScope)
            else
              $console.error("写入操作失败！")
              # 如果失败，返回一个包含 nil 的已完成 Deferred，以便中断后续逻辑或传递失败状态
              currentScope.resolve(nil)
            end
          }
          .then { |currentScope, clipboardText|
            # 处理 getText 的结果 (Deferred<String?>)
            $console.log("从剪贴板读取到的内容: " + clipboardText.to_s)

            # 验证结果
            if clipboardText.to_s == testContent
              $console.log("✅ 测试通过：读取内容与写入内容一致。")
            else
              $console.error("❌ 测试失败：内容不一致。\n期望: #{testContent}\n实际: #{clipboardText}")
            end

            # 链式调用结束，返回一个空的 Deferred
            currentScope.resolve(true)
          }
          .onError { |error|
            # 6. 全局异常捕获
            $console.error("测试过程中发生异常: " + error.to_s)
          }

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

09 December 2025