Java AI测试案例

wen java案例 2026-07-30 2

本文目录导读：

Java AI测试案例

AI功能单元测试
AI服务集成测试
AI性能测试
AI模型准确性测试
AI异常处理测试
测试配置文件
测试资源配置

我来为您提供Java AI测试的完整案例，涵盖单元测试、集成测试和性能测试。

AI功能单元测试

文本分类模型测试

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import static org.junit.jupiter.api.Assertions.*;
public class TextClassifierTest {
    private TextClassifier classifier;
    @BeforeEach
    void setUp() {
        classifier = new TextClassifier();
        classifier.loadModel("models/text-classifier.h5");
    }
    @Test
    void testPositiveSentiment() {
        String input = "这个产品非常好用，我很满意";
        String result = classifier.predict(input);
        assertEquals("positive", result);
    }
    @Test
    void testNegativeSentiment() {
        String input = "质量太差了，完全不值得购买";
        String result = classifier.predict(input);
        assertEquals("negative", result);
    }
    @Test
    void testEmptyInput() {
        assertThrows(IllegalArgumentException.class, () -> {
            classifier.predict("");
        });
    }
    @Test
    void testNullInput() {
        assertThrows(NullPointerException.class, () -> {
            classifier.predict(null);
        });
    }
}

图像识别测试

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.*;
public class ImageRecognizerTest {
    private ImageRecognizer recognizer;
    @BeforeEach
    void setUp() {
        recognizer = new ImageRecognizer();
        recognizer.loadModel("models/object-detection.pt");
    }
    @Test
    void testRecognizeCat() throws Exception {
        BufferedImage catImage = ImageIO.read(
            new File("test-images/cat.jpg"));
        List<RecognitionResult> results = recognizer.recognize(catImage);
        assertFalse(results.isEmpty());
        assertTrue(results.stream()
            .anyMatch(r -> r.getLabel().equals("cat") && 
                          r.getConfidence() > 0.8));
    }
    @ParameterizedTest
    @ValueSource(strings = {"dog.jpg", "car.jpg", "person.jpg"})
    void testMultipleImages(String imageFile) throws Exception {
        BufferedImage image = ImageIO.read(
            new File("test-images/" + imageFile));
        List<RecognitionResult> results = recognizer.recognize(image);
        assertNotNull(results);
        assertTrue(results.size() > 0);
        results.forEach(result -> {
            assertNotNull(result.getLabel());
            assertTrue(result.getConfidence() >= 0 && 
                      result.getConfidence() <= 1);
        });
    }
}

AI服务集成测试

REST API 测试

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.*;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class AIServiceIntegrationTest {
    @Autowired
    private TestRestTemplate restTemplate;
    @Test
    void testPredictionEndpoint() {
        // 准备请求体
        PredictionRequest request = new PredictionRequest();
        request.setInput("这是一个测试文本");
        request.setModelType("sentiment");
        // 发送POST请求
        ResponseEntity<PredictionResponse> response = restTemplate.postForEntity(
            "/api/v1/predict",
            request,
            PredictionResponse.class
        );
        // 验证响应
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody()).isNotNull();
        assertThat(response.getBody().getPrediction()).isNotNull();
        assertThat(response.getBody().getConfidence()).isGreaterThan(0);
    }
    @Test
    void testBatchPrediction() {
        // 批量预测测试
        BatchRequest batchRequest = new BatchRequest();
        batchRequest.setInputs(Arrays.asList(
            "文本1", "文本2", "文本3"
        ));
        ResponseEntity<BatchResponse> response = restTemplate.postForEntity(
            "/api/v1/predict/batch",
            batchRequest,
            BatchResponse.class
        );
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
        assertThat(response.getBody().getResults()).hasSize(3);
    }
}

AI性能测试

并发性能测试

import org.junit.jupiter.api.Test;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import static org.junit.jupiter.api.Assertions.*;
public class AIPerformanceTest {
    @Test
    void testConcurrentPredictions() throws Exception {
        AIService aiService = new AIService();
        int threadCount = 10;
        int tasksPerThread = 100;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        AtomicInteger successCount = new AtomicInteger(0);
        AtomicInteger failureCount = new AtomicInteger(0);
        long startTime = System.currentTimeMillis();
        // 创建并发任务
        List<Callable<Void>> tasks = new ArrayList<>();
        for (int i = 0; i < threadCount; i++) {
            tasks.add(() -> {
                for (int j = 0; j < tasksPerThread; j++) {
                    try {
                        String result = aiService.predict("测试文本 " + j);
                        if (result != null) {
                            successCount.incrementAndGet();
                        }
                    } catch (Exception e) {
                        failureCount.incrementAndGet();
                    }
                }
                return null;
            });
        }
        // 执行所有任务
        List<Future<Void>> futures = executor.invokeAll(tasks);
        // 等待完成
        for (Future<Void> future : futures) {
            future.get();
        }
        long endTime = System.currentTimeMillis();
        long duration = endTime - startTime;
        // 验证性能指标
        int totalTasks = threadCount * tasksPerThread;
        assertTrue(successCount.get() > totalTasks * 0.95); // 成功率>95%
        assertTrue(duration < 30000); // 总时间<30秒
        // 计算吞吐量
        double throughput = (double) totalTasks / (duration / 1000.0);
        System.out.println("吞吐量: " + throughput + " 请求/秒");
        executor.shutdown();
    }
}

模型加载性能测试

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
public class ModelLoadingTest {
    @Test
    void testModelLoadingTime() {
        ModelLoader loader = new ModelLoader();
        long startTime = System.currentTimeMillis();
        Model model = loader.loadModel("models/large-model.h5");
        long endTime = System.currentTimeMillis();
        long loadTime = endTime - startTime;
        // 验证加载时间
        assertNotNull(model);
        assertTrue(loadTime < 10000, 
            "模型加载时间超过10秒: " + loadTime + "ms");
    }
    @Test
    void testModelMemoryUsage() {
        Runtime runtime = Runtime.getRuntime();
        long beforeMemory = runtime.totalMemory() - runtime.freeMemory();
        Model model = new ModelLoader().loadModel("models/memory-test.h5");
        long afterMemory = runtime.totalMemory() - runtime.freeMemory();
        long memoryUsed = afterMemory - beforeMemory;
        // 验证内存使用
        assertNotNull(model);
        assertTrue(memoryUsed < 500 * 1024 * 1024, 
            "模型内存使用超过500MB: " + memoryUsed / (1024*1024) + "MB");
    }
}

AI模型准确性测试

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
public class ModelAccuracyTest {
    private AIService aiService;
    private TestDataLoader testDataLoader;
    @BeforeEach
    void setUp() {
        aiService = new AIService();
        testDataLoader = new TestDataLoader();
    }
    @ParameterizedTest
    @CsvSource({
        "positive, 这个产品真不错",
        "negative, 太失望了，质量很差",
        "neutral, 今天天气不错"
    })
    void testSentimentAccuracy(String expected, String input) {
        String result = aiService.predictSentiment(input);
        assertEquals(expected, result);
    }
    @Test
    void testModelAccuracyOnTestSet() {
        // 加载测试数据集
        List<TestData> testData = testDataLoader.loadTestData("test-data.csv");
        int correctPredictions = 0;
        int totalPredictions = testData.size();
        // 进行批量测试
        for (TestData data : testData) {
            String prediction = aiService.predict(data.getInput());
            if (prediction.equals(data.getExpected())) {
                correctPredictions++;
            }
        }
        // 计算准确率
        double accuracy = (double) correctPredictions / totalPredictions;
        // 验证准确率不低于阈值
        assertTrue(accuracy >= 0.85, 
            "模型准确率不足85%: " + (accuracy * 100) + "%");
    }
}

AI异常处理测试

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
public class AIExceptionHandlingTest {
    private AIService aiService;
    @Test
    void testInvalidModelType() {
        assertThrows(IllegalArgumentException.class, () -> {
            aiService.predictWithModel("invalid-model", "测试文本");
        });
    }
    @Test
    void testModelNotLoaded() {
        AIService service = new AIService(); // 不加载模型
        assertThrows(ModelNotLoadedException.class, () -> {
            service.predict("测试文本");
        });
    }
    @Test
    void testInputValidation() {
        // 测试超长输入
        String longInput = "a".repeat(10001);
        assertThrows(InputTooLongException.class, () -> {
            aiService.predict(longInput);
        });
        // 测试特殊字符
        assertThrows(InvalidInputException.class, () -> {
            aiService.predict("<script>alert('xss')</script>");
        });
    }
    @Test
    void testServiceUnavailable() {
        // 模拟服务不可用
        aiService.setAvailable(false);
        assertThrows(ServiceUnavailableException.class, () -> {
            aiService.predict("测试");
        });
    }
}

测试配置文件

# application-test.yml
ai:
  model:
    path: "models/test-models/"
    timeout: 5000
    max-input-length: 10000
  service:
    enabled: true
    cache-size: 100
    batch-size: 32
testing:
  accuracy-threshold: 0.85
  performance:
    max-load-time: 10000
    max-response-time: 1000
    min-throughput: 100

测试资源配置

<!-- pom.xml -->
<dependencies>
    <!-- 测试框架 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.9.2</version>
        <scope>test</scope>
    </dependency>
    <!-- Mock测试 -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>5.1.1</version>
        <scope>test</scope>
    </dependency>
    <!-- 集成测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- 性能测试 -->
    <dependency>
        <groupId>io.gatling</groupId>
        <artifactId>gatling-core</artifactId>
        <version>3.9.3</version>
        <scope>test</scope>
    </dependency>
</dependencies>

这些测试案例覆盖了Java AI应用的各个方面,包括：

功能测试：验证AI功能正确性
集成测试：测试系统组件交互
性能测试：评估系统性能指标
准确性测试：验证模型预测准确性
异常测试：确保鲁棒性

可以根据实际项目需求调整和扩展这些测试案例。