An intelligent evaluation method and system for software testing course experimental teaching

Abstract

This invention discloses an intelligent evaluation method and system for software testing course experiments. It adopts a hybrid C / S and B / S architecture, supports offline and online operation, and is based on a layered architecture design. An experiment resource integration module centrally manages experiment resources and toolchains; an evaluation rule configuration module supports customized scoring rules for different teaching objectives; a test execution evaluation layer automatically executes and analyzes tests; an AI intelligent evaluation module integrates large language models to intelligently analyze and provide feedback on code and reports; a dynamic monitoring module collects experimental process data; and finally, a test report and result feedback module generates a structured report containing automatic scoring and multi-dimensional quality analysis. This invention achieves automated execution and intelligent evaluation of software testing experiments, solving problems such as low evaluation efficiency, inconsistent standards, poor environmental compatibility, and uncontrollable processes, thus improving teaching adaptability and feedback quality.

Description

Technical Field

[0001] This invention relates to the field of software engineering education technology, and in particular to an intelligent evaluation method and system for experimental teaching in software testing courses. Background Technology

[0002] In software engineering education, software testing is a highly practical core course, typically encompassing various experimental types such as unit testing, web automation testing, web interface testing, and performance testing. Currently, universities face the following main technical challenges when conducting software testing experimental teaching:

[0003] Fragmented experimental environment and resource management: Different tests and experiments require different toolchains and operating environments. Students usually use their own independent development environments on their personal computers, resulting in complex experimental environment configurations and inconsistent versions, making it difficult to standardize the experimental process and compare the repeatability of results.

[0004] The evaluation standards are inconsistent and the level of automation is low: the report formats and evaluation indicators generated by various testing tools vary greatly, and there is a lack of mechanisms for standardized processing and unified quantitative evaluation of multi-source heterogeneous test data. Teacher grading relies heavily on manual review of scattered experimental reports, which is inefficient and makes it difficult to ensure the objectivity and consistency of grading standards.

[0005] The lack of teaching process data and process evaluation: Traditional models cannot track key data such as students' code writing, test execution, and coverage changes in real time during the experiment process, resulting in delayed teaching feedback and difficulty in conducting accurate learning situation analysis and personalized guidance for individual students.

[0006] In recent years, although some technical solutions have attempted to improve the above problems, significant limitations still exist:

[0007] Option 1 (Introducing mainstream automated testing tools): For example, using tools such as Selenium and Appium in teaching. This option still belongs to the hybrid mode of "tool assistance + human evaluation". The testing process is fragmented between different tools and lacks unified platform support; the evaluation relies on teachers' subjective interpretation of experimental reports, and the level of automation and intelligence is insufficient; and it is impossible to dynamically monitor the students' experimental operation process.

[0008] Option 2 (Integrated Teaching Platform): For example, the "Nanjing University MoocTest Platform". Although this platform provides functions such as test question bank management and standardized evaluation, its test type coverage is incomplete (such as lacking full support for performance testing and interface testing), its teaching adaptability and universality are insufficient (it is difficult to flexibly adapt to the personalized teaching syllabus and assessment requirements of different universities), and the number of supported programming languages ​​is limited (such as mainly supporting Java and Python).

[0009] Furthermore, with the advancements in code understanding and natural language processing, the application potential of large language models in the fields of software development and testing has attracted attention. However, how to deeply and effectively integrate them into the intelligent evaluation of the entire process of software testing experimental teaching to solve the aforementioned long-standing pain points remains a challenge in the current technological field. Summary of the Invention

[0010] This invention addresses the shortcomings of existing technologies by providing an intelligent evaluation method and system for experimental teaching in software testing courses.

[0011] To achieve the above-mentioned objectives, the technical solution adopted by the present invention is as follows:

[0012] An intelligent assessment system for experimental teaching in software testing courses, the system comprising:

[0013] The desktop deployment module is used to deploy system functions on local clients and supports both offline and online dual-mode operation.

[0014] The experimental resource integration module is used for centralized management and standardized processing of test questions, test cases, experimental scripts, toolchains, and scoring rules for multiple programming languages ​​and test types.

[0015] The AI-powered intelligent evaluation module integrates a large language model to perform semantic understanding and intelligent analysis on test code and experiment reports, and generate feedback that includes quality analysis and improvement suggestions.

[0016] The evaluation rule configuration module is used to customize scoring dimensions, weights, and pass criteria according to different experiment types, teaching objectives, and course outlines, forming configurable evaluation rules.

[0017] The dynamic monitoring module is used to collect students' behavioral data and intermediate results in real time or near real time during the experiment, so as to realize process tracking and analysis.

[0018] The test report and result feedback module is used to generate structured test quality reports and performance reports for different technology stacks based on the evaluation results;

[0019] The system adopts a hybrid architecture combining C / S and B / S, and is based on a layered architecture design, including at least a data layer, a test execution and evaluation layer, a reporting layer, and a user layer. Each module collaborates through standardized data interfaces to jointly realize the automated execution, unified evaluation, and intelligent feedback of software testing experiments.

[0020] Furthermore, the layered architecture includes:

[0021] The data layer is used to store and manage various types of data in the system, including file storage, SQLite database, question bank, experimental rule configuration data, MySQL database, and object storage service.

[0022] The test execution evaluation layer, as the core evaluation engine, includes Java evaluation modules, Python evaluation modules, and C++ evaluation modules divided by programming language, as well as unit testing, web automation testing, web interface testing, performance testing, and code / report AI review modules divided by test type. It is used to schedule and execute test tasks and perform in-depth code analysis.

[0023] The reporting layer is used to format, visualize, and perform multi-dimensional analysis of test execution results, and generate structured reports for Java, Python, and C++ languages, supporting unit testing, web automation testing, web interfaces, performance testing, and code / report AI analysis.

[0024] The user layer provides teacher desktops, student desktops, and a Python test analysis library as human-computer interaction entry points.

[0025] Furthermore, the system's built-in evaluation system supports Java, Python, and C++ programming languages, and supports various experimental types, including unit testing, web automation testing, web interface testing, and performance testing.

[0026] Furthermore, the Java evaluation module integrates JUnit, P3C code style checking tools, and AI source code analysis capabilities; the Python evaluation module integrates UnitTest / Pytest, Flake8 / Radon code analysis tools, and AI source code analysis capabilities; and the C++ evaluation module integrates GTest, clang-tidy code checking tools, and AI source code analysis capabilities.

[0027] Furthermore, the large language model integrated by the AI ​​intelligent evaluation module is one or more of the following: Tongyi Qianwen, Huoshan Doubao, and Tencent Hunyuan series models.

[0028] Furthermore, the system also includes a W service module, which provides online management and viewing functions for courses, teaching classes, question banks, and grades.

[0029] This invention also discloses an intelligent evaluation method for experimental teaching in software testing courses, applied to the aforementioned system, the method comprising:

[0030] The experimental resource integration module enables unified management of various types of software testing experimental resources, building a standardized experimental resource pool.

[0031] The evaluation rule configuration module allows you to receive custom evaluation rules for specific experiment types, programming languages, and teaching requirements.

[0032] The system's test execution evaluation layer automatically executes and analyzes the results of user-submitted test code or scripts according to the custom evaluation rules.

[0033] The AI-powered intelligent evaluation module utilizes a large language model to perform intelligent analysis and quality assessment of test code and experiment report content.

[0034] The dynamic monitoring module collects process data during the experiment execution process;

[0035] The test report and results feedback module integrates automated test results, AI quality assessment results, and process data to generate a structured evaluation report that includes automatic scoring and multi-dimensional quality analysis.

[0036] Furthermore, the process of scheduling, executing, and analyzing test tasks by the test execution evaluation layer adopts either a client-side local execution mode or a server-side centralized execution mode.

[0037] This invention also discloses a method for customizing evaluation rules for software testing experiments, including:

[0038] It provides a rule configuration interface to receive input for different experiment types, teaching objectives and course outlines. The input includes scoring dimensions, weight allocation of each dimension, deduction items and passing criteria.

[0039] The input is converted into evaluation rule configuration information that the system can recognize and stored;

[0040] When the evaluation task is triggered, the corresponding evaluation rule configuration information is dynamically loaded according to the experimental attributes.

[0041] Based on the loaded evaluation rules, the automated scoring process and quality report generation process are driven.

[0042] The present invention also discloses a computer-readable storage medium having a computer program stored thereon, wherein the program, when executed by a processor, implements the steps of the above-described intelligent evaluation method for multiple types of experiments in software testing courses.

[0043] Compared with the prior art, the advantages of the present invention are as follows:

[0044] 1. Significantly improve evaluation efficiency and objectivity: Through configurable evaluation rules, the system automatically analyzes and scores various types of test results, fundamentally solving the problems of low efficiency, inconsistent standards, and delayed feedback in traditional manual evaluation, and ensuring the consistency, fairness, and repeatability of evaluation results.

[0045] 2. Achieve efficient integration of experimental resources and automatic environment adaptation: By unifying and standardizing the management of various types and tools of test experimental resources, and supporting automatic adaptation of experimental environments, the system effectively solves problems such as scattered experimental resources, incompatibility between students' local environments and teaching requirements, and tool version conflicts during the teaching process, ensuring the operability of the experimental process and the consistency of results.

[0046] 3. Supports dynamic monitoring of the experimental process and real-time control of teaching quality: By collecting key behavioral data and intermediate results in real time during the experimental process, dynamic tracking and analysis of students' experimental progress, test behavior and ability development trajectory are realized, enabling teachers to accurately grasp the learning situation and carry out personalized guidance, thereby helping to effectively improve students' practical abilities.

[0047] 4. Supports flexible configuration of assessment rules to adapt to diverse teaching objectives: By providing a flexible function to customize assessment rules, it can be adapted to the personalized requirements of different universities, courses and teaching stages, which significantly improves the adaptability of teaching and the universality of scenarios, and solves the problem that existing solutions are out of touch with actual teaching needs and are difficult to promote and apply on a large scale.

[0048] 5. Deeply integrate artificial intelligence technology to enhance the intelligence level of teaching evaluation: By integrating artificial intelligence technologies such as large language models, not only is automatic scoring achieved, but also deep semantic understanding, intelligent diagnosis and personalized feedback can be performed on test code, experimental reports and so on, generating multi-dimensional quality analysis reports, making the evaluation process closer to engineering practice, and significantly improving the depth, intelligence level and learning effectiveness of teaching feedback. Attached Figure Description

[0049] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the description of the embodiments of the present invention will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0050] Figure 1 This is an operation flowchart of an intelligent evaluation system for experimental teaching in software testing courses, as described in an embodiment of the present invention.

[0051] Figure 2 This is a schematic diagram of the structure of an intelligent evaluation system for experimental teaching in software testing courses, as described in an embodiment of the present invention. Detailed Implementation

[0052] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0053] Example 1: An intelligent evaluation system for experimental teaching in software testing courses

[0054] like Figure 1 and 2 As shown, this system adopts a layered architecture design, mainly consisting of a data layer, a test execution and evaluation layer, a reporting layer, and a user layer from bottom to top, supplemented by web services. The system supports a hybrid deployment mode combining C / S (client / server) and B / S (browser / server) architectures, and supports both offline and online dual-mode operation, specifically divided into two main interaction entry points: the teacher's end and the student's end.

[0055] 1. Data Layer

[0056] The data layer is the data foundation for system operation, responsible for the storage, organization, and access of various types of data, specifically including:

[0057] File storage: Deployed on the desktop client, used to store raw unstructured data such as source code files submitted by students, generated lab reports, and system operation logs.

[0058] SQLite database: Deployed on the teacher's desktop, used to manage structured business data in offline scenarios, including user information, course information, experiment questions, grade records, etc.

[0059] Question Bank Module: As the core teaching resource library, it centrally stores and manages various experimental questions, pre-set test cases, reference answers, and scoring standard templates.

[0060] Experiment rule configuration module: This is the core configuration center, defining and storing evaluation rules for different programming languages ​​(such as Java, Python, C++) and different test types (such as unit testing, interface testing, performance testing, and web automation testing) in the form of configuration files or database tables. The rules include scoring dimensions (such as pass rate, coverage, and code style), the weight of each dimension, deduction details, and pass thresholds.

[0061] MySQL database: Used in online scenarios to store and manage more complex business data, such as user permissions across classes, detailed grade statistics and analysis, operation logs, system notifications, etc.

[0062] Object storage services (such as MinIO) are used to store and manage large-scale unstructured data, such as batch-generated test reports, exported grade documents, and teaching resource packages.

[0063] 2. Test Execution Evaluation Layer

[0064] This layer is the core evaluation engine of the system, responsible for the scheduling, execution, and in-depth analysis of specific test tasks. It consists of several highly specialized sub-modules:

[0065] Java Evaluation Module: Activated when the experimental project is detected to be written in Java. This module calls the JUnit framework to execute unit tests, calculates test pass rate and code coverage; integrates the Alibaba P3C plugin for Java code style checks; and can send the test source code to the integrated AI analysis engine (based on a large language model) for semantic-level quality analysis.

[0066] Python Evaluation Module: Used for Python language experiments. This module calls the UnitTest or PyTest framework to execute tests and calculate coverage; it integrates the Flake8 tool for code style checking and the Radon tool for code complexity analysis; it also supports AI source code analysis.

[0067] C++ Evaluation Module: Used for C++ language experiments. This module calls the GoogleTest (GTest) framework to execute tests; integrates the clang-tidy tool for static code analysis and code style checks; and supports AI source code analysis.

[0068] Web Interface Testing Module: Designed for interface testing experiments. This module can parse and execute interface test scripts or configurations based on tools such as Apifox, automatically send requests, assert responses, and parse the returned results to generate structured data.

[0069] Performance Testing Module: This module is designed for performance testing experiments. It primarily integrates Apache JMeter, enabling it to parse JMeter scripts (.jmx files), execute stress tests, and comprehensively analyze key performance indicators such as throughput, response time, and error rate.

[0070] AI-powered report review module: This module is specifically designed for processing text-based lab reports. It combines the lab report text submitted by students with pre-defined, experiment-specific "assignment review prompts" and submits it to an integrated large language model (such as Tongyi Qianwen, Huoshan Doubao, Tencent Hunyuan, etc.). The model reviews the report content for completeness, logic, and depth of analysis, and generates comments and scoring suggestions.

[0071] 3. Reporting Level

[0072] The reporting layer is responsible for summarizing, formatting, and visualizing the output results of the test execution and evaluation layer, generating structured reports tailored to different users and scenarios.

[0073] Project Report Generation: Automatically generates specialized reports for different languages ​​and technology stacks. For example, for Java projects, it generates a comprehensive report including JUnit test details, code coverage charts, a P3C specification violation list, an AI quality analysis summary, and the final quality score. The same applies to Python and C++ projects, generating reports corresponding to their respective toolchains.

[0074] General Report Processing: Generates specialized test result analysis reports for web interface testing and performance testing. It also supports combining and formatting the above-mentioned reports, or AI evaluation results, and outputting them as standardized experimental report documents in common formats such as docx, pdf, and excel.

[0075] 4. User layer

[0076] The user layer is the interface through which the system interacts with end users (teachers and students):

[0077] Teacher Desktop: A feature-rich client application. Teachers can use this terminal to manage courses and classes, maintain the experimental question bank, define and publish experimental tasks, flexibly configure assessment rules, view automatic scoring results and perform manual review, access comprehensive experimental analysis reports for classes or individuals, and manage and export grades.

[0078] Student Desktop: The client application used by students. Through this terminal, students receive experimental tasks, code and debug locally, submit test code or scripts, trigger local or remote automated tests and evaluations, view test execution progress and feedback in real time, view detailed experimental reports and quality analyses, and check their personal grades.

[0079] Python Test Analysis Library: Provided as a Python library (package), it encapsulates core test analysis capabilities. Advanced users (such as teaching assistants and researchers) or third-party systems can use it via API calls for secondary development or integration.

[0080] 5. Web services

[0081] To enable online data synchronization, management, and cross-platform access, the system provides web services:

[0082] Web backend: Developed using frameworks such as Spring Boot, providing RESTful APIs that cover all online business logic, including user authentication and authorization, course management, question bank synchronization, grade inquiry, data statistics, and message notifications.

[0083] Web front-end: Developed based on the Vue.js framework, it provides teachers and students with a lightweight browser-based interface that supports online access to course information, experiment schedules, personal grades, announcements, and notifications.

[0084] System workflow overview:

[0085] Teacher-side configuration and publishing: Teachers access the experimental resource management module through the system's teacher desktop (user level) to create or batch import teaching resources such as experimental questions and test cases. Based on this, teachers utilize the evaluation rule configuration module to set detailed evaluation strategies for experimental tasks, including key parameters such as applicable programming languages, test types, scoring dimensions, weight allocation, and pass / fail criteria.

[0086] After configuration, teachers will publish the experimental tasks to the designated teaching classes. The system will automatically digitally sign the published experimental data to ensure its integrity and immutability. Student-side task reception: Students receive the published experimental tasks through the student desktop client (user level) and complete the writing and debugging of test code or experimental reports in their local development environment.

[0087] Automated execution and intelligent evaluation on the student side: After students complete the experimental tasks, the execution of local test scripts / code is automatically triggered on the student's desktop, and test run logs and result data are collected. The system, through the test execution evaluation layer, calls the corresponding professional evaluation module (such as the Java evaluation module) to carry out automated testing based on the task information, and obtains quantitative test indicator data (such as: test pass rate, code coverage, and other quantitative indicators).

[0088] Subsequently, the system objectively scores students based on the evaluation rules preset by the teachers; at the same time, the AI ​​intelligent evaluation module performs semantic and structural intelligent analysis on students' code implementations or experimental reports, and outputs optimization suggestions and risk warnings.

[0089] Throughout the evaluation process, the dynamic monitoring module collects experimental operation behavior, running results, and encrypted score information in real time to ensure that the entire process is traceable and auditable.

[0090] Report generation and result feedback: The test report and result feedback module gathers automated test results from the test execution evaluation layer, analysis conclusions from the AI ​​intelligent evaluation module, and process data collected by the dynamic monitoring module. It performs comprehensive analysis and formatting to generate a structured evaluation report containing detailed scores, quality analysis, and improvement suggestions, which is then saved to the student's end.

[0091] Grade Summary and Management: Teachers import student lab results (including test scripts / code, test result data, test reports, and test lab scores) via their desktop (offline) or web service (online). They also compile, analyze, and export the overall class grades, completing the teaching management loop.

[0092] Example 2: Implementation of the method for customizing evaluation rules

[0093] The customizable evaluation rule configuration function of this invention is mainly implemented through the "Test Experiment Rule Formulation Module" on the teacher's desktop. The specific implementation steps are as follows:

[0094] 1. Rule Definition: Teachers create evaluation rules for a specific experiment type (such as "Java Unit Testing") through a graphical interface or configuration file. The interface provides forms for teachers to fill out or select:

[0095] Basic attributes: associated experiment title, experiment parameters, and experiment result indicators.

[0096] Scoring dimensions and weights: For example, unit testing: test case pass rate (weight 40%), code coverage (weight 20%), code style check (weight 20%); performance testing: number of concurrent users, response time, parameterization settings, transaction configuration; web interface testing: number of test scenarios, test pass rate, response time, etc. Detailed deduction items can be set for each dimension, such as "deduct 5 points for each serious code style warning."

[0097] Passing criteria: Set a passing score for the total score (e.g., 60 points), or a minimum requirement for a certain dimension (e.g., the pass rate must reach 100%).

[0098] AI review prompts: Configure exclusive prompts for the lab report review module to guide the AI ​​model to review from specific perspectives (such as whether the test case design methodology is sufficiently discussed, and whether the result analysis is in-depth).

[0099] 2. Rule Storage: Configured rules are serialized into structured data (such as JSON or XML format) and stored in the "Experimental Rule Configuration" module of the data layer. Test rules also require numerical signatures upon release to prevent data tampering.

[0100] 3. Rule Loading and Application: When a student submits the code for this experiment, the system loads the corresponding rule configuration file from the "Experiment Rule Configuration" based on the experiment ID. The test execution evaluation layer and the report AI review module drive the entire automated evaluation process based on these rules: calling the specified tools to execute the test, calculating the scores of each dimension according to weights, calling the AI ​​model and passing in the specified prompts to review the report, and finally summarizing to generate the total score and report.

[0101] Optional implementation methods

[0102] 1. Alternative to the test execution mode: The above embodiments primarily rely on local execution on the client side. In another implementation, a centralized server-side execution mode can be adopted. Specifically, students submit code to the server via a web frontend or a lightweight client. The server cluster maintains standardized execution environments (Docker containers) corresponding to each evaluation module. Upon receiving a task, it schedules the corresponding container to execute the test, analysis, and AI evaluation, and finally returns the results. This approach facilitates unified execution of test scripts, but it consumes significant server resources.

[0103] 2. Alternatives to Large Language Models: This invention does not limit the large language models used in the AI ​​intelligent evaluation module. In actual deployment, different models can be selected and integrated according to actual needs. For example, cloud API services (such as OpenAI's GPT-4 and Baidu's Wenxin Yiyan) can be integrated, or open-source models (such as ChatGLM and a slightly modified version of Llama's code) can be deployed locally. The system decouples itself from the backend of different large language models by defining a unified model call interface; only the model service behind the interface needs to be changed.

[0104] Example 3: A storage medium is provided, specifically a computer-readable storage medium (Memory). This computer-readable storage medium is a memory device in a terminal device used to store programs and data. It is understood that the computer-readable storage medium here can include both the built-in storage medium in the terminal device and extended storage media supported by the terminal device. The computer-readable storage medium provides storage space that stores the terminal's operating system. Furthermore, this storage space also stores one or more instructions suitable for loading and execution by a processor. These instructions can be one or more computer programs (including program code). It should be noted that the computer-readable storage medium here can be high-speed RAM or non-volatile memory, such as at least one disk storage device.

[0105] One or more instructions stored in a computer-readable storage medium can be loaded and executed by a processor to implement the corresponding steps of the intelligent evaluation method for experimental teaching of software testing courses in the above embodiments; one or more instructions in the computer-readable storage medium are loaded and executed by a processor.

[0106] The steps include:

[0107] The experimental resource integration module enables unified management of various types of software testing experimental resources, building a standardized experimental resource pool.

[0108] The evaluation rule configuration module allows you to receive custom evaluation rules for specific experiment types, programming languages, and teaching requirements.

[0109] The system's test execution evaluation layer automatically executes and analyzes the results of user-submitted test code or scripts according to the custom evaluation rules.

[0110] The AI-powered intelligent evaluation module utilizes a large language model to perform intelligent analysis and quality assessment of test code and experiment report content.

[0111] The dynamic monitoring module collects process data during the experiment execution process;

[0112] The test report and results feedback module integrates automated test results, AI quality assessment results, and process data to generate a structured evaluation report that includes automatic scoring and multi-dimensional quality analysis.

[0113] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. This computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0114] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0115] The above-described embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

Claims

1. An intelligent evaluation system for experimental teaching in software testing courses, characterized in that, The system includes: The desktop deployment module is used to deploy system functions on local clients and supports both offline and online dual-mode operation. The experimental resource integration module is used for centralized management and standardized processing of test questions, test cases, experimental scripts, toolchains, and scoring rules for multiple programming languages ​​and test types. The AI-powered intelligent evaluation module integrates a large language model to perform semantic understanding and intelligent analysis on test code and experiment reports, and generate feedback that includes quality analysis and improvement suggestions. The evaluation rule configuration module is used to customize scoring dimensions, weights, and pass criteria according to different experiment types, teaching objectives, and course outlines, forming configurable evaluation rules. The dynamic monitoring module is used to collect students' behavioral data and intermediate results in real time or near real time during the experiment, so as to realize process tracking and analysis. The test report and result feedback module is used to generate structured test quality reports and performance reports for different technology stacks based on the evaluation results; The system adopts a hybrid architecture combining C / S and B / S, and is based on a layered architecture design, including at least a data layer, a test execution and evaluation layer, a reporting layer, and a user layer. Each module collaborates through standardized data interfaces to jointly realize the automated execution, unified evaluation, and intelligent feedback of software testing experiments.

2. The system according to claim 1, characterized in that, The layered architecture includes: The data layer is used to store and manage various types of data in the system, including file storage, SQLite database, question bank, experimental rule configuration, MySQL database, and object storage service. The test execution and evaluation layer, as the core evaluation engine, includes Java evaluation modules, Python evaluation modules, and C++ evaluation modules categorized by programming language, as well as unit testing, web automation testing, web interface testing, performance testing, and test script / report AI analysis modules categorized by test type. These modules are used for automatic execution of test cases, test data collection, and AI-powered in-depth code / report analysis. The reporting layer is used to format, visualize, and perform multi-dimensional analysis of test execution results, and generate structured reports for unit testing, web automation testing, web interface testing, and performance testing. The user layer provides teacher desktops, student desktops, and a Python test analysis library as human-computer interaction entry points.

3. The system according to claim 1 or 2, characterized in that, The system's built-in evaluation system supports Java, Python, and C++ programming languages, and supports various experimental types such as unit testing, web automation testing, interface testing, and performance testing.

4. The system according to claim 2, characterized in that, The Java evaluation module integrates JUnit, P3C code style checking tools, and AI source code analysis capabilities; the Python evaluation module integrates UnitTest / Pytest, Flake8 / Radon code analysis tools, and AI source code analysis capabilities; and the C++ evaluation module integrates GTest, clang-tidy code checking tools, and AI source code analysis capabilities.

5. The system according to claim 1, characterized in that, The large language model integrated into the AI ​​intelligent evaluation module is one or more of the following: Tongyi Qianwen, Huoshan Doubao, and Tencent Hunyuan series models.

6. The system according to claim 1, characterized in that, The system also includes a web service module, which provides online management and viewing functions for courses, teaching classes, question banks, and grades.

7. An intelligent assessment method for experimental teaching in software testing courses, characterized in that, Applied to the system as described in any one of claims 1-6, the method comprises: The experimental resource integration module enables unified management of various types of software testing experimental resources, building a standardized experimental resource pool. The evaluation rule configuration module allows you to receive custom evaluation rules for specific experiment types, programming languages, and teaching requirements. The system's test execution evaluation layer automatically executes and analyzes the results of user-submitted test code or scripts according to the custom evaluation rules. The AI-powered intelligent evaluation module utilizes a large language model to perform intelligent analysis and quality assessment of test code and experiment report content. The dynamic monitoring module collects process data during the experiment execution process; The test report and results feedback module integrates automated test results, AI quality assessment results, and process data to generate a structured evaluation report that includes automatic scoring and multi-dimensional quality analysis.

8. The method according to claim 7, characterized in that, The test execution evaluation layer schedules, executes, and analyzes test tasks, using either a client-side local execution mode or a server-side centralized execution mode.

9. A method for customizing evaluation rules for software testing experiments, characterized in that, include: It provides a rule configuration interface to receive input for different experiment types, teaching objectives and course outlines. The input includes scoring dimensions, weight allocation of each dimension, deduction items and passing criteria. The input is converted into evaluation rule configuration information that the system can recognize and stored; When the evaluation task is triggered, the corresponding evaluation rule configuration information is dynamically loaded according to the experimental attributes. Based on the loaded evaluation rules, the automated scoring process and quality report generation process are driven.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the steps of the method as described in claim 7.

Images