CN107807883B - Unit test method and device for user mode network file system - Google Patents
Unit test method and device for user mode network file system Download PDFInfo
- Publication number
- CN107807883B CN107807883B CN201711027565.9A CN201711027565A CN107807883B CN 107807883 B CN107807883 B CN 107807883B CN 201711027565 A CN201711027565 A CN 201711027565A CN 107807883 B CN107807883 B CN 107807883B
- Authority
- CN
- China
- Prior art keywords
- test
- compiling
- file system
- nfs
- ganesha
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000010998 test method Methods 0.000 title claims abstract description 32
- 238000012360 testing method Methods 0.000 claims abstract description 201
- 238000000034 method Methods 0.000 claims abstract description 24
- 230000001419 dependent effect Effects 0.000 claims abstract description 10
- 230000006870 function Effects 0.000 claims description 62
- 230000002452 interceptive effect Effects 0.000 abstract description 4
- 238000010586 diagram Methods 0.000 description 6
- 238000012423 maintenance Methods 0.000 description 4
- 230000002950 deficient Effects 0.000 description 3
- 230000003993 interaction Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000002093 peripheral effect Effects 0.000 description 2
- 230000008569 process Effects 0.000 description 2
- 230000005540 biological transmission Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000018109 developmental process Effects 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 238000013522 software testing Methods 0.000 description 1
- 230000033772 system development Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3624—Software debugging by performing operations on the source code, e.g. via a compiler
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/3692—Test management for test results analysis
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computer Hardware Design (AREA)
- Quality & Reliability (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
- Debugging And Monitoring (AREA)
Abstract
The invention discloses a unit test method and a unit test device for a user mode network file system, wherein a source code environment and a compiling tool of an NFS-Ganesha user mode network file system are deployed in advance; introducing a CUnit test tool dependent function library and a lib library file into a source code of an NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file; establishing a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code, and compiling a tested code test case; opening a unit test switch, and performing NFS-Ganesha source code external compilation through cmake; after the compilation is completed, unit test results are generated. The method and the device can improve the quality of the service codes of the file system, are more efficient and easy to manage and maintain, and can realize interactive operation.
Description
Technical Field
The invention relates to the technical field of network files, in particular to a unit test method and a unit test device for a user mode network file system.
Background
With the wide application and deep development of big data, cloud computing and mass storage in enterprise information systems, the number of core storage applications of users is increasing, and file data interaction through a network is a commonly adopted mode for people. With the increasingly huge enterprise data and the increasingly high requirements of users on the data transmission performance and stability, the code quality of each module software of the storage server has become a key point of attention of software users and developers. Therefore, it is important to provide a method for testing the code quality of the network file system, which is fast, reliable, and easy to implement and maintain. Software testing is an important means for efficiently monitoring codes and solving defects and faults of functional modules. However, in the prior art, unit tests for the open source code NFS-Ganesha user mode network file system are less, and the code quality needs to be improved.
Nfs (network File system), a kernel-mode network File system, is one of File systems supported by FreeBSD, and allows computers in a network to share resources through a TCP/IP network. The kernel mode means that the CPU can access all data in the memory, including peripheral devices such as a hard disk and a network card, and the CPU can also switch itself from one program to another program. The user state refers to that only limited access to the memory is available, access to peripheral equipment is not allowed, the capacity of occupying the CPU is deprived, and CPU resources can be acquired by other programs. In the application of NFS, a client application of a local NFS can transparently read and write files located on a remote NFS server, just like accessing local files. The NFS-Ganesha is a user-mode network file system, belongs to an open source project, and has better manageability and maintainability compared with a kernel-mode NFS under a system service fault scene, and the user-mode NFS-Ganesha is easy to implement and maintain, so that the NFS-Ganesha has a great application prospect in the current mass large-data distributed object storage.
Currently, the gtest test framework provided by Google corporation has grown to maturity, being generated primarily for the C + + test. However, in the field of Linux kernel system development, particularly in the file system layer, the file system layer is mainly developed by using C codes, because the file system layer depends on the kernel system in the bottom layer and does not have a unit test framework specially aiming at the user mode network file system NFS-Ganesha, the network file system software is relatively deficient in terms of easy maintainability and easy testability, thus causing the shortage of network file system unit test and increasing the code maintenance cost.
Disclosure of Invention
The invention aims to provide a unit test method and a unit test device of a user mode network file system, which are used for solving the problems of deficient test of network system units and higher code maintenance cost in the prior art.
In order to solve the above technical problem, the present invention provides a unit testing method for a user mode network file system, which comprises:
pre-deploying a source code environment and a compiling tool of the NFS-Ganesha user mode network file system;
introducing a CUnit test tool dependent function library and a lib library file into a source code of an NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file to realize automatic compiling and deploying of a unit test suite;
establishing a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code, and compiling a tested code test case;
opening a unit test switch, and performing NFS-Ganesha source code external compilation through cmake to realize automatic compilation of the NFS-Ganesha source code and the unit test module compilation;
after the compilation is completed, unit test results are generated.
Optionally, the source code environment of the NFS-Ganesha user-mode network file system is a CentOS version 7.2 environment, and the compiling tool adopts cmake-2.6.4, make-3.82 and automake-1.13.4 versions.
Optionally, the positions of introducing the Cunit test tool and the switch option are in cmakelists.txt in the NFS-Ganesha source code file, and the positions of introducing the Cunit library function and the lib library file are in units in a cmake subdirectory in the NFS-Ganesha source code file.
Optionally, the writing a test case of the code under test includes:
establishing a test case, and compiling a test function code case;
classifying the test methods with the functions meeting the preset conditions into the same array so as to point to the same test packet;
establishing a plurality of test packets according to different functions or modules;
and establishing a total calling method of the test method to finish the writing of the test case of the tested code.
Optionally, after the generating the unit test result, the method further includes:
and analyzing the unit test result.
The invention also provides a unit testing device of the user mode network file system, which comprises:
the deployment module is used for pre-deploying the source code environment and the compiling tool of the NFS-Ganesha user mode network file system;
the first compiling module is used for introducing a CUnit testing tool dependent function library and a lib library file into a source code of the NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file so as to realize automatic compiling and deploying of the unit testing suite;
the building module is used for building a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code and compiling a tested code test case;
the second compiling module is used for opening the unit test switch and carrying out NFS-Ganesha source code external compiling through cmake so as to realize automatic compiling of the NFS-Ganesha source code and the unit test module compiling;
and the generating module is used for generating a unit test result after the compiling is finished.
Optionally, the source code environment of the NFS-Ganesha user-mode network file system is a CentOS version 7.2 environment, and the compiling tool adopts cmake-2.6.4, make-3.82 and automake-1.13.4 versions.
Optionally, the positions of introducing the Cunit test tool and the switch option are in cmakelists.txt in the NFS-Ganesha source code file, and the positions of introducing the Cunit library function and the lib library file are in units in a cmake subdirectory in the NFS-Ganesha source code file.
Optionally, the establishing module is specifically configured to: establishing a test case, and compiling a test function code case; classifying the test methods with the functions meeting the preset conditions into the same array so as to point to the same test packet; establishing a plurality of test packets according to different functions or modules; and establishing a total calling method of the test method to finish the writing of the test case of the tested code.
Optionally, the method further comprises:
an analysis module for analyzing the unit test result after the unit test result is generated.
The unit test method and the unit test device for the user mode network file system provided by the invention have the advantages that the NFS-Ganesha user mode network file system source code environment and the compiling tool are deployed in advance; introducing a CUnit test tool dependent function library and a lib library file into a source code of an NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file to realize automatic compiling and deploying of a unit test suite; establishing a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code, and compiling a tested code test case; opening a unit test switch, and performing NFS-Ganesha source code external compilation through cmake to realize automatic compilation of the NFS-Ganesha source code and the unit test module compilation; after the compilation is completed, unit test results are generated. The method and the device solve the problem that the NFS-Ganesha code unit of the user mode network file system is tested poorly in the existing unit testing technology, can improve the quality of service codes of the file system, are more efficient and easy to manage and maintain, and can realize interactive operation.
Drawings
In order to more clearly illustrate the embodiments or technical solutions of the present invention, the drawings used in the description of the embodiments or the prior art will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art that other drawings can be obtained based on these drawings without creative efforts.
FIG. 1 is a flowchart of an embodiment of a unit test method for a user mode network file system according to the present invention;
FIG. 2 is a flowchart of an embodiment of writing a test case of a code under test according to the present invention;
FIG. 3 is a schematic diagram of a unit test framework for a user-mode network file system;
FIG. 4 is a schematic diagram of a CUnit cell test framework;
FIG. 5 is a flowchart of another embodiment of a unit test method for a user-mode network file system according to the present invention;
fig. 6 is a block diagram of a unit testing apparatus of a user-mode network file system according to an embodiment of the present invention.
Detailed Description
In order that those skilled in the art will better understand the disclosure, the invention will be described in further detail with reference to the accompanying drawings and specific embodiments. It is to be understood that the described embodiments are merely exemplary of the invention, and not restrictive of the full scope of the invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Fig. 1 shows a flowchart of a specific embodiment of a unit testing method for a user-mode network file system, where the method includes:
step S101: pre-deploying a source code environment and a compiling tool of the NFS-Ganesha user mode network file system;
in this embodiment, the source code environment of the NFS-Ganesha user-mode network file system is a CentOS version 7.2 environment, and the compiling tool adopts cmake-2.6.4, make-3.82, and automake-1.13.4 versions. In addition, this step may also include opening the source community cloneNFS-Ganesha code from GitHub.
Step S102: introducing a CUnit test tool dependent function library and a lib library file into a source code of an NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file to realize automatic compiling and deploying of a unit test suite;
the positions of introducing the Cunit test tool and the switch options are in CMakeLists.txt in an NFS-Ganesha source code file, and the positions of introducing the Cunit library function and the lib library file are in modules in a cmake subdirectory in the NFS-Ganesha source code file.
Step S103: establishing a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code, and compiling a tested code test case;
referring to fig. 2, a flowchart of a specific implementation of writing a test case of a code under test in an embodiment of the present invention may specifically include:
step S1031: establishing a test case, and compiling a test function code case;
step S1032: classifying the test methods with the functions meeting the preset conditions into the same array so as to point to the same test packet;
in particular, functionally similar test methods may be placed in an array to point to the same test package.
Step S1033: establishing a plurality of test packets according to different functions or modules;
step S1034: and establishing a total calling method of the test method to finish the writing of the test case of the tested code.
Step S104: opening a unit test switch, and performing NFS-Ganesha source code external compilation through cmake to realize automatic compilation of the NFS-Ganesha source code and the unit test module compilation;
step S105: after the compilation is completed, unit test results are generated.
The unit test method of the user mode network file system provided by the invention is characterized in that a source code environment and a compiling tool of the NFS-Ganesha user mode network file system are deployed in advance; introducing a CUnit test tool dependent function library and a lib library file into a source code of an NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file to realize automatic compiling and deploying of a unit test suite; establishing a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code, and compiling a tested code test case; opening a unit test switch, and performing NFS-Ganesha source code external compilation through cmake to realize automatic compilation of the NFS-Ganesha source code and the unit test module compilation; after the compilation is completed, unit test results are generated. The method and the device solve the problem that the NFS-Ganesha code unit of the user mode network file system is tested poorly in the existing unit testing technology, can improve the quality of service codes of the file system, are more efficient and easy to manage and maintain, and can realize interactive operation.
On the basis of any of the above embodiments, the unit test method for a user-mode network file system provided by the present invention further includes, after generating the unit test result: and analyzing the unit test result. The analysis of the unit test results may specifically employ a console mode for result analysis.
FIG. 3 is a schematic diagram of a unit test framework of a user-mode network file system, and FIG. 4 is a schematic diagram of a CUnit unit test framework. Referring to fig. 3 and 4, a detailed implementation process of the unit testing method for the user-mode network file system provided by the present invention is further described in detail, and referring to fig. 5, a flowchart of another specific implementation method for the unit testing method for the user-mode network file system provided by the present invention is shown, and the detailed implementation process is as follows:
step S201: deploying a source code environment and a compiling tool of an NFS-Ganesha user mode network file system, and opening a source community clone NFS-Ganesha code from a GitHub;
the source code environment is a CentOS 7.2 version environment, and the compiling tool adopts cmake-2.6.4, make-3.82 and automake-1.13.4 versions.
Step S202: introducing a CUnit test tool dependent function library and a lib library file into a source code of an NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file to realize automatic compiling and deploying of a unit test suite;
the method comprises the steps of introducing a Cunit test tool, introducing switch options in CMakeLists.txt in an NFS-Ganesha source code file, and introducing a Cunit library function and a lib library file in modules in a cmake subdirectory in the NFS-Ganesha source code file.
In CMakeLists.txt under the source code src directory of NFS-Ganesha, a switch option is introduced and set to be in an ON state, and codes are written as follows:
option(USE_CUNIT“Use Cunit test framework”ON)
introducing a CUnit library function and a lib library file, and writing codes as follows:
if(USE_CUNIT)
find_package(cunit REQUIRED)
set(SYSTEM_LIBRARIES)${cunit_LIBRARIES}
${SYSTEM_LIBRARIES}
endif(USE_CUNIT)
step S203: establishing a unit test directory, compiling a unit test CMakeLists.txt file, introducing a tested function code, and compiling a tested code test case;
the test case for the tested code is compiled, and the method comprises the following steps:
establishing a test case, compiling a test function code case, and compiling an init/cleanup function of suite; the Test Registry-CU _ initial _ Registry () is initialized.
Test methods are classified, i.e. test methods of similar function are placed in an array so as to be directed to a test package. Specifically, the Test package (Test Suites) is added to the Test Registry-CU _ add _ suite ().
And creating a test packet, wherein a plurality of test packets can be created according to functions or modules. Add Test Case (Test Case) to the Test packet-CU _ add _ Test ().
And establishing a total calling method of the test method so as to uniformly start the test method. Run the Test program with the appropriate interface, e.g., CU _ Console _ run _ tests (), clear Test registration-CU _ clear _ registration ()
Step S204: and opening the unit test switch, performing NFS-Ganesha source code external compilation through cmake, and realizing automatic compilation of the NFS-Ganesha source code and the unit test module compilation under the condition of not changing the structure of the source code, thereby improving the code maintainability and efficiency.
Step S205: after compiling is completed, a unit test result can be generated.
Step S206: and analyzing the unit test result, and analyzing the result by adopting a console mode.
Specifically, the Console Mode Console Mode supports interaction, such as operations to support running, checking for errors, and the like. Input R to run, input F to check for error cases, and input Q to exit.
The unit testing device of the user mode network file system provided by the embodiment of the invention is introduced below, and the unit testing device of the user mode network file system described below and the unit testing method of the user mode network file system described above can be referred to correspondingly.
Fig. 6 is a block diagram of a unit testing apparatus of a user-mode network file system according to an embodiment of the present invention, where the unit testing apparatus of the user-mode network file system shown in fig. 6 may include:
the deployment module 100 is used for pre-deploying a source code environment and a compiling tool of the NFS-Ganesha user mode network file system;
the first compiling module 200 is used for introducing a CUnit test tool dependent function library and a lib library file into a source code of an NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file so as to realize automatic compiling and deploying of a unit test suite;
the establishing module 300 is used for establishing a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code and compiling a tested code test case;
the second compiling module 400 is used for opening the unit test switch and performing NFS-Ganesha source code external compiling through cmake to realize automatic compiling of the NFS-Ganesha source code and the unit test module compiling;
and a generating module 500, configured to generate a unit test result after the compiling is completed.
As a specific implementation manner, in the unit test device of the user-mode network file system provided by the present invention, the source code environment of the NFS-Ganesha user-mode network file system is a CentOS 7.2 version environment, and the compiling tool adopts cmake-2.6.4, make-3.82, and automake-1.13.4 versions.
The positions of introducing the Cunit test tool and the switch options are in CMakeLists.txt in an NFS-Ganesha source code file, and the positions of introducing the Cunit library function and the lib library file are in units in a cmake subdirectory in the NFS-Ganesha source code file.
On the basis of any of the above embodiments, in the unit test apparatus of the user-mode network file system provided by the present invention, the establishing module is specifically configured to: establishing a test case, and compiling a test function code case; classifying the test methods with the functions meeting the preset conditions into the same array so as to point to the same test packet; establishing a plurality of test packets according to different functions or modules; and establishing a total calling method of the test method to finish the writing of the test case of the tested code.
Further, the present application may further include: an analysis module for analyzing the unit test result after the unit test result is generated.
The unit testing apparatus of the user-mode network file system in this embodiment is used to implement the unit testing method of the user-mode network file system, and therefore specific embodiments of the unit testing apparatus of the user-mode network file system can be found in the foregoing embodiment parts of the unit testing method of the user-mode network file system, for example, the deployment module 100, the first compiling module 200, the establishment module 300, the second compiling module 400, and the generation module 500 are respectively used to implement the steps S101, S102, S103, S104, and S105 in the unit testing method of the user-mode network file system, so that the specific embodiments thereof may refer to descriptions of corresponding embodiments of each part, and are not described herein again.
The unit test for the open source code NFS-Ganesha user mode network file system is less, the code quality needs to be improved continuously, the network file system is developed by C codes, a special unit test frame for the user mode network file system NFS-Ganesha is not provided, and network file system software is relatively deficient in the aspects of easy maintenance and easy testability, so that the shortage of the unit test for the network file system is caused, and the code maintenance cost is increased. The unit test method and the unit test device for the user mode network file system solve the problem of lack of test on the NFS-Ganesha code unit of the user mode network file system in the existing unit test technology, can improve the quality of the service code of the file system, are more efficient and easy to manage and maintain, and can realize interactive operation.
The embodiments are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same or similar parts among the embodiments are referred to each other. The device disclosed by the embodiment corresponds to the method disclosed by the embodiment, so that the description is simple, and the relevant points can be referred to the method part for description.
Those of skill would further appreciate that the various illustrative elements and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both, and that the various illustrative components and steps have been described above generally in terms of their functionality in order to clearly illustrate this interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.
The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may reside in Random Access Memory (RAM), memory, Read Only Memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.
The unit test method and device of the user mode network file system provided by the invention are described in detail above. The principles and embodiments of the present invention are explained herein using specific examples, which are presented only to assist in understanding the method and its core concepts. It should be noted that, for those skilled in the art, it is possible to make various improvements and modifications to the present invention without departing from the principle of the present invention, and those improvements and modifications also fall within the scope of the claims of the present invention.
Claims (8)
1. A unit test method of a user mode network file system is characterized by comprising the following steps:
pre-deploying an NFS-Ganesha user mode network file system source code environment and a compiling tool;
introducing a CUnit test tool dependent function library and a lib library file into a source code of an NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file to realize automatic compiling and deploying of a unit test suite;
establishing a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code, and compiling a tested function code test case;
opening a unit test switch, and performing NFS-Ganesha source code external compilation through cmake to realize automatic compilation of the NFS-Ganesha source code and unit test module compilation;
after compiling is completed, generating a unit test result;
the Cunit testing tool is introduced, the switch option is introduced into CMakeLists.txt in an NFS-Ganesha source code file, the Cunit library function is introduced, and the lib library file is introduced into a cell in a cmake subdirectory in the NFS-Ganesha source code file.
2. The method for unit testing of user-mode network file system of claim 1, wherein the NFS-Ganesha user-mode network file system source code environment is a CentOS version 7.2 environment, and the compilation tool employs cmake-2.6.4, make-3.82, and automake-1.13.4 versions.
3. The unit test method of the user-mode network file system according to claim 1 or 2, wherein the writing of the test cases of the function code under test includes:
establishing a test case, and compiling a test function code case;
classifying the test methods with the functions meeting the preset conditions into the same array so as to point to the same test packet;
establishing a plurality of test packets according to different functions or modules;
and establishing a total calling method of the test method to finish the writing of the test case of the tested function code.
4. The unit test method for a user-mode network file system of claim 3, further comprising, after the generating the unit test result:
and analyzing the unit test result.
5. A unit test apparatus for a user mode network file system, comprising:
the deployment module is used for pre-deploying the source code environment and the compiling tool of the NFS-Ganesha user mode network file system;
the first compiling module is used for introducing a CUnit testing tool dependent function library and a lib library file into a source code of the NFS-Ganesha user mode network file system, and compiling a code introduction switch option, a CUnit library function and a lib library file so as to realize automatic compiling and deploying of the unit testing suite;
the building module is used for building a unit test directory, compiling a unit test CmakeLists text file, introducing a tested function code and compiling a tested function code test case;
the second compiling module is used for opening the unit testing switch and carrying out external compiling on the NFS-Ganesha source code through cmake so as to realize automatic compiling of the NFS-Ganesha source code and compiling of the unit testing module;
the generating module is used for generating a unit test result after compiling is finished;
the Cunit testing tool is introduced, the switch option is introduced into CMakeLists.txt in an NFS-Ganesha source code file, the Cunit library function is introduced, and the lib library file is introduced into a cell in a cmake subdirectory in the NFS-Ganesha source code file.
6. The apparatus for unit testing of user-mode network file system of claim 5, wherein the NFS-Ganesha user-mode network file system source code environment is a CentOS version 7.2 environment, and the compiling tool employs cmake-2.6.4, make-3.82, and automake-1.13.4 versions.
7. The device for unit testing of a user-mode network file system according to claim 5 or 6, wherein the establishing module is specifically configured to: establishing a test case, and compiling a test function code case; classifying the test methods with the functions meeting the preset conditions into the same array so as to point to the same test packet; establishing a plurality of test packets according to different functions or modules; and establishing a total calling method of the test method to finish the writing of the test case of the tested function code.
8. The device for unit testing of a user-mode network file system of claim 7, further comprising:
an analysis module for analyzing the unit test result after the unit test result is generated.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201711027565.9A CN107807883B (en) | 2017-10-27 | 2017-10-27 | Unit test method and device for user mode network file system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201711027565.9A CN107807883B (en) | 2017-10-27 | 2017-10-27 | Unit test method and device for user mode network file system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN107807883A CN107807883A (en) | 2018-03-16 |
| CN107807883B true CN107807883B (en) | 2021-06-29 |
Family
ID=61590961
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201711027565.9A Active CN107807883B (en) | 2017-10-27 | 2017-10-27 | Unit test method and device for user mode network file system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN107807883B (en) |
Families Citing this family (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110928760B (en) * | 2018-09-20 | 2023-10-20 | 杭州海康汽车技术有限公司 | Unit test method and device in embedded system |
| CN109450724B (en) * | 2018-10-19 | 2022-05-27 | 郑州云海信息技术有限公司 | Test method and related device for NFS memory optimization function |
| CN111274144B (en) * | 2020-01-20 | 2023-01-10 | 苏州浪潮智能科技有限公司 | Unit testing method and system based on network file system operation word interface |
| CN112579549A (en) * | 2020-12-14 | 2021-03-30 | 浪潮云信息技术股份公司 | CephFS file protocol sharing system, construction method and implementation method |
| CN112506793B (en) * | 2020-12-18 | 2024-05-28 | 航天信息股份有限公司 | Method and system for testing embedded software unit, readable medium and electronic equipment |
| CN114448823B (en) * | 2022-01-27 | 2023-08-15 | 苏州浪潮智能科技有限公司 | NFS service testing method and system and electronic equipment |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102495796A (en) * | 2011-11-25 | 2012-06-13 | 中国人民解放军总参谋部第五十四研究所 | Software vulnerability test method based on unit testing |
| CN103853589A (en) * | 2014-02-26 | 2014-06-11 | 上海爱数软件有限公司 | Cross-platform system compiling and building method |
| CN104915287A (en) * | 2014-03-11 | 2015-09-16 | 富士施乐实业发展（中国）有限公司 | Method and system for unit testing |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6332211B1 (en) * | 1998-12-28 | 2001-12-18 | International Business Machines Corporation | System and method for developing test cases using a test object library |
-
2017
- 2017-10-27 CN CN201711027565.9A patent/CN107807883B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102495796A (en) * | 2011-11-25 | 2012-06-13 | 中国人民解放军总参谋部第五十四研究所 | Software vulnerability test method based on unit testing |
| CN103853589A (en) * | 2014-02-26 | 2014-06-11 | 上海爱数软件有限公司 | Cross-platform system compiling and building method |
| CN104915287A (en) * | 2014-03-11 | 2015-09-16 | 富士施乐实业发展（中国）有限公司 | Method and system for unit testing |
Also Published As
| Publication number | Publication date |
|---|---|
| CN107807883A (en) | 2018-03-16 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107807883B (en) | Unit test method and device for user mode network file system | |
| US20190065351A1 (en) | System and method for providing a test manager for use with a mainframe rehosting platform | |
| Wang et al. | Using realistic simulation for performance analysis of mapreduce setups | |
| CN110750458A (en) | Big data platform testing method and device, readable storage medium and electronic equipment | |
| CN110554965B (en) | Automated fuzz testing method, related equipment and computer readable storage medium | |
| US10353809B2 (en) | System and method for executing integration tests in multiuser environment | |
| CN114546738B (en) | Universal test method, system, terminal and storage medium for server | |
| WO2023045849A1 (en) | Software package processing method, apparatus, system, and device, and medium | |
| US10552306B2 (en) | Automated test generation for multi-interface and multi-platform enterprise virtualization management environment | |
| US10037268B2 (en) | System and method for determining requirements for testing software | |
| CN105630683B (en) | A kind of cloud testing architecture | |
| CN111897724A (en) | Automatic testing method and device suitable for cloud platform | |
| CN112417461A (en) | Fuzzy test method and system for equipment firmware | |
| US11288170B1 (en) | Log analysis debugging without running on real production environment | |
| US8560895B2 (en) | Distillation and reconstruction of provisioning components | |
| CN111813758A (en) | Distributed analysis method and device for database files, server and storage medium | |
| US9116714B2 (en) | Methods and systems for file processing | |
| WO2015003452A1 (en) | Methods and systems for file processing | |
| Ali et al. | Automated parallel GUI testing as a service for mobile applications | |
| CN111400171B (en) | Interface testing method, system and device and readable storage medium | |
| CN115454856A (en) | Multi-application security detection method, device, medium and electronic equipment | |
| CN113031969B (en) | Equipment deployment inspection method and device, computer equipment and storage medium | |
| CN111309297B (en) | Script development system and method | |
| CN110795330A (en) | Monkey pressure testing method and device | |
| CN114238091A (en) | Resident interactive service cluster testing method and system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |