Method for testing a computer program programmed in an object-oriented scripting language, as well as system, computer program and computer-readable storage medium

Abstract

The invention relates to a method for testing a computer program programmed in an object-oriented scripting language, comprising the following steps: a) providing a computer program part for generating classes; b) providing at least one parent class (2) by means of the computer program part; c) providing a class (9) inheriting from the parent class (2), in which generic types of the parent class (2) are concretized; d) creating an object derived from the inheriting class (9), whereby this object represents a reference to the parent class (2), e) Check whether the parent class (2) with concretized generic types is a base class of the object; and f) if the checked parent class (2) is not a generic base class of the object, an entry is created in an error list and this is then output as an error message.

Description

[0001] One aspect of the invention relates to a method for testing a computer program programmed in an object-oriented scripting language.

[0002] There are object-oriented programming languages that can be used to program a so-called Command Query Responsibility Segregation Pattern (CQRS) as a design pattern for database queries. This design pattern has exactly two software components. For example, read access is performed by a first of the two software components, and write access is performed by a second of the two software components. These programming languages have a compiler that compiles a written program code before the program code is executed. The program code is checked for errors and translated into machine code. The compiler checks at compile time whether all accesses via the two software components within a program are consistent.This means that programs based on compiled code run fail-safe because errors are detected before they are executed.

[0003] With scripting languages that aren't compiled, errors only occur at runtime. However, scripting languages offer other advantages over compiled programming languages.

[0004] Therefore, the object of the invention is to enable advantages of compiled programming languages for scripting languages.

[0005] The problem is solved by the subject matter of the independent patent claims. Advantageous developments of the invention are described by the dependent patent claims, the following description, and the figure.

[0006] One aspect of the invention relates to a method for testing a computer program programmed in an object-oriented scripting language, preferably comprising the following steps: a) providing a computer program part for generating classes; b) providing at least one, in particular generic, parent class by means of the computer program part; c) Providing a class inheriting from the parent class, in which generic types of the parent class are concretized; d) Creating an object derived from the inheriting class, which represents a reference to the parent class, e) Check whether the parent class with concretized generic types is a base class of the object; and f) If the checked parent class is not a generic base class, especially with a specified type, of the object, an entry is created in an error list and this is then output as an error message.

[0007] In particular, the proposed method can be a computer-implemented method. In particular, the method is executed on an electronic computing unit. The tested computer program can be executed on this computing unit or, after transfer, on another computing unit. By executing the computer program, a vehicle can be controlled, in particular autonomously, in particular semi-autonomously. If appropriate, it is a method for operating an electronic computing unit. In particular, the method also improves the operation of a computing unit. In particular because the computing unit can therefore operate with fewer errors and, in particular, therefore also faster and more efficiently. In particular, the execution of a computer program on a computing unit is improved. A method for carrying out the execution of a computer program on a computing unit is therefore also provided.

[0008] In particular, these are scripting languages that do not have built-in type checking and / or interface definition.

[0009] In particular, the procedure is performed to determine whether the concretized types of the parent class and the derived object match. If necessary, this is checked in step e).

[0010] The particularly newly and additionally provided computer program component for generating classes is not necessarily part of the computer program. However, it can, in particular, be added to the computer program. The computer program component can, in particular, also be integrated into the computer program as a library. At least the computer program component now makes it possible to carry out the aforementioned steps and thus improve a conventional computer program programmed in an object-oriented scripting language with regard to error generation and error detection. Thus, it is now possible to utilize such computer programs with their advantages over compiler-based computer programs and still offer the improved analysis capability with regard to error detection that is available with compiler-based computer programs.

[0011] In particular, the computer program to be tested comprises program code for creating the parent class and the inheriting class. The computer program to be tested is provided, in particular, to the electronic processing unit and / or to the computer program part. Optionally, the computer program comprises further program code for generating the object derived from the inheriting class. Alternatively, the further program code is generated automatically, in particular by means of the computer program part, or by a user. In particular, steps e) and / or f) are executed, preferably automatically, by means of a function of the computer program part.

[0012] A parent class is a class whose attributes and methods are inherited by at least one other class, the inheriting class. This means, for example, that these attributes and methods can be implemented and / or used in the inheriting class. It is also possible for multiple inheriting classes to inherit from a single parent class. The parent class can also be referred to as a superclass.

[0013] A generic class, for example, has at least one type parameter. The at least one type parameter may be a placeholder for data types, such as an integer or a string, or other classes. The at least one type parameter is, in particular, only defined for the inheriting class. In particular, the type parameter can be referred to as a type.

[0014] It is possible that the base class of the object is stored as an attribute of the object, in particular automatically when the object is created. The base class is, in particular, the highest defined class in its class hierarchy. The base class of the object corresponds to the expected parent class, in particular, if the inheriting class and the object were created correctly. An error is, for example, a typo or incorrect specification of the specified generic type parameter. The method according to the invention checks, in particular implicitly, whether a specific data type has been assigned to the generic type parameter.

[0015] Deeper hierarchies are also possible, where there are multiple base classes that build on each other. In this case, the procedure is performed for each class in the hierarchy, which is then optionally treated as a base class in the procedure.

[0016] For example, the scripting language is Python. If necessary, a CQRS design pattern is implemented with the computer program. For example, the parent class is an abstract generic class. In object-oriented programming, abstract classes are classes that have at least one abstract method or at least one abstract attribute. Methods and attributes of a class can be referred to as members of the class. Interfaces are a special case of abstract classes. They normally only have abstract members, which means, for example, they only have abstract methods and abstract attributes. An interface can be understood as a contract that describes which members a class should have. In particular, an abstract member is a member that does not use an implementation, but only a definition, which can be referred to as a signature.For example, a class only becomes an abstract class if it has at least one abstract member. An abstract class can generally also have non-abstract members. However, an interface generally cannot.

[0017] In particular, an abstract generic parent class is provided, in particular, programmed, in particular, added to the computer program. In particular, some interfaces are provided. If a CQRS pattern is implemented, in particular, exactly two interfaces are provided. For this purpose, the computer program part is used. Examples of a member type can be a method, an attribute, a class method, or a static method.

[0018] An object can be derived from the inheriting class and created. This can be referred to as instantiation of the inheriting class. This gives the object a reference to the parent class from which the inheriting class inherits. In particular, a reference is a type of address by which an object can be accessed. In some programming languages, references can be represented directly as memory addresses. In Python, for example, this is not the case. When a class is instantiated, the object in particular is created in the memory of the computing unit, in particular a computer. In particular, this object is then passed on to functions or other classes in the form of a reference so that they can access it. In some cases, the memory address is not sufficient for access; additional information about the object in question is required.For example, it is necessary to pass the corresponding class of the object for access. Then it is possible to address the object correctly via the reference. According to the inventive method, the object represents the reference to the parent class. Because the object's reference points to the parent class, it can be addressed externally via the methods and attributes of the parent class. It is therefore particularly important that members of the parent class are correctly and completely inherited, and in particular implemented, by the members of the inheriting class with regard to their properties. This makes it possible to achieve loose coupling between software components. A software component that uses an object of an inheriting class is only given the bare minimum to use the object. Such a software component can be referred to as a client and the object as a service.A client, which can be another class or a function, can depend on the parent class instead of on a specific class. This allows the implementation to be replaced later with another class that implements the same parent class. This creates loose coupling between classes. This allows the software code to be more modular and thus easier to maintain. Furthermore, the software code is easier to reuse, especially in different contexts.

[0019] This method is particularly advantageous because it enables or facilitates the use of numerous object-oriented patterns (oop patterns). In particular, the concept of using CQRS is fundamentally unknown in the Python programming language. Therefore, it is not yet possible to check in Python whether an implementation is consistent for generic parent classes and / or whether a passed reference is compatible with the generic parent class.

[0020] For example, if an error occurs during validation, an entry is created in an error list. An error is detected, for example, if the parent class, which is the base class of the object, does not correspond to the expected parent class. In this case, the error list, in particular, is output as an error message. Outputting the error list can mean that the error list is displayed to a user, audibly or visually, in particular on a screen. Alternatively or additionally, the error list can be output or made available to an external system. In particular, the error list contains information about which base class of the object does not correspond to which expected parent class.

[0021] In one embodiment, it is checked whether the inheriting parent class is a generic class with a type parameter. In particular, steps c) to f) are executed if the parent class is a generic class.

[0022] It is possible that, if the parent class is not a generic class, properties of the members of the inheriting class are compared with the properties of the members, in particular abstract ones, of the parent class. If there is at least one member, in particular abstract, of the parent class for which no member, in particular non-abstract, of the inheriting class with the same properties is found, an entry is created in the error list and this entry is then output as an error message. It is possible that, in the case of generic classes, this comparison and, if applicable, the corresponding entry in the error list is carried out in addition to steps c) to f). This checks the consistency of the program with regard to correct inheritance and instantiation, thus reducing errors and / or making it more fail-safe.

[0023] In one embodiment, a check is carried out to determine whether the object is an instance of the parent class, which can be referred to, for example, as an instance check. Step e) is executed, in particular, only if the object is an instance of the parent class. Therefore, if, for example, the instance check fails, step e) may not be executed. This can shorten the program's runtime because, for example, the instance check can be executed more quickly than step e).

[0024] In one embodiment, the check to determine whether the object is an instance of the parent class is performed if further checks reveal that the parent class is a generic class. In particular, the instance check is only performed if the parent class is a generic class. This can also shorten the program's runtime.

[0025] In one embodiment, after performing step d), it is checked whether the parent class has composite generic type parameters. If this is the case, steps e) and f), for example, are performed recursively for the composite type parameter. A composite type parameter has multiple elements, such as multiple list elements of a list or elements of a tuple. If necessary, each of the multiple elements is assigned a concrete data type, such as an integer or string, when the inheriting class is created. The multiple elements optionally have different data types. In particular, it is checked for each element whether a concrete data type has been assigned.

[0026] In one embodiment, the method comprises the following further steps: - Checking for all objects referenced by a software component of the computer program whether the respective referenced object represents a reference to the associated parent class; - If there are functions in the computer program which have arguments and / or return values which are generic classes, these are checked according to a method according to one of the preceding claims; and - If at least one checked object referenced by a software component does not represent the reference to the corresponding parent class and / or the check of an argument and / or a return value fails, another error message is issued.

[0027] In particular, the associated parent class is an expected parent class, particularly one specified in the program code and / or in an attribute of the object. In particular, for each function or method of the computer program, it must be checked whether the passed references of the object (passed object references) are instances of the expected parent classes. If they are not, an error message may be issued, particularly to a user and / or made available to an external system.

[0028] This type checking can also be referred to as runtime type checking, as it occurs specifically at runtime and checks the type of the parent class that contains a reference to the object. The type of the parent class refers specifically to the name of the parent class.

[0029] In particular, the check ensures that only objects from the expected class that implement an abstract class, especially an interface, can be passed as arguments to a function or method. In particular, it checks whether a reference can be formally assigned to an expected interface.

[0030] Preferably, it is determined whether there are functions in the computer program that have arguments and / or return values that are generic classes before they are checked.

[0031] This embodiment ensures the consistency of the computer program, making it more fail-safe and less error-prone.

[0032] A further aspect of the invention relates to a method for executing a computer program. Testing of the computer program is performed prior to execution of a main part of the computer program. If an entry is made in the error list or an error message is output, execution of the main part is prevented. If no entry is made in the error list or an error message is output, the main part of the computer program is started, in particular automatically. Additionally or alternatively, the testing method according to the invention is performed at least once during an already started execution of the main part, in particular when an object derived from an inheriting class is created.

[0033] If the main part is not executed due to an error, the error can be identified and corrected. In particular, the error is identified by the method according to the invention and automatically corrected by the external system.

[0034] In computer programs that are programmed in a scripting language, especially without a compiler, and are not tested using the method according to the invention, it is possible that errors only occur during the execution of the main part. This may not be the case until several hours later. The method according to the invention detects errors before the main part is executed. This saves time and energy, since no faulty program is executed for an unnecessarily long time.

[0035] The tested computer program can be used for the control of a vehicle, particularly autonomously, particularly semi-autonomously. The testing according to the invention increases the reliability of the computer program. This increased reliability can ensure safer operation of the vehicle.

[0036] A further aspect of the invention relates to a system for carrying out a method, comprising means for executing the steps of the method according to one of the preceding claims. The system can comprise an electronic test unit and / or at least one electronic computing unit.

[0037] A further aspect of the invention relates to a computer program which is tested according to a method according to the above-mentioned aspect, in particular is loadable into a memory unit and is executable by a processor.

[0038] A further aspect of the invention relates to a computer-readable storage medium comprising instructions which, when executed by a computer, cause the computer to carry out the steps of the method according to the above-mentioned aspect or an advantageous embodiment thereof.

[0039] Further embodiments of the system according to the invention, the computer program according to the invention, and the storage medium according to the invention follow directly from the various embodiments of the method according to the invention, and vice versa. In particular, individual features and corresponding explanations as well as advantages relating to the various embodiments of the method according to the invention can be transferred analogously to corresponding embodiments of the system according to the invention, the computer program according to the invention, and the storage medium according to the invention. In particular, the system according to the invention, the computer program according to the invention, and the storage medium according to the invention are designed or programmed to carry out a method according to the invention. In particular, the system according to the invention, the computer program according to the invention, and the storage medium according to the invention carry out the method according to the invention.

[0040] The invention also includes combinations of the features of the described embodiments.

[0041] Exemplary embodiments of the invention are described below. Shown are: Fig. 1 a class diagram of an embodiment of a computer diagram.

[0042] The exemplary embodiments explained below are preferred exemplary embodiments of the invention. In the exemplary embodiments, the described components each represent individual, independently considered features of the invention, which also further develop the invention independently of one another and are thus also to be considered as components of the invention, either individually or in a combination other than that shown. Furthermore, the described exemplary embodiments can also be supplemented by further features of the invention already described.

[0043] In Fig.1 shows an exemplary class diagram 1 of an embodiment of a computer program. The class diagram 1 shows, by way of example, a parent class 2 "Parent Class," which may be provided in the computer program, and an inheriting class 9 "Inheriting Class." Parent class 2 has, in particular, a type parameter 17 "T." Parent class 2 "Parent Class" can also have an attribute 3 called "Attribute" and a method 4 called "Operation." In this exemplary embodiment, attribute 3 is of the data type String 5. Attribute 3 can, in particular, be a character string. Method 4 "Operation" expects a transfer parameter 6 "Value" of the data type String 7. A return value of method 4 "Operation" is, for example, of a Boolean data type 8.

[0044] The inheriting class 9 "inheriting class" implements the parent class 2. This means that the inheriting class 9 also has an attribute 10 "attribute" and a method 11 "operation". The generic type parameter "T" 17 is specified in the inheriting class 9. In particular, a concrete data type 18, for example "string", is specified instead of the generic type "T" 17. If necessary, the inheriting class 9 has further attributes and methods. If necessary, it also inherits from another parent class. In particular, the inheriting class 9 has at least all attributes and methods of the parent class 2. In particular, the methods and attributes of the inheriting class are all non-abstract and, in particular, do not have generic data types.

[0045] According to one embodiment of the method for testing a computer program programmed in an object-oriented scripting language, a computer program part is provided for generating classes. The scripting language is, for example, Python, and the computer program part is, in particular, a Python library. For example, parent class 2 can be created with the computer program part as follows: from typing import TypeVar, Generic T = TypeVar("T") class GenericClass(Generic[T]): def method(value: T): ...

[0046] For example, the inheriting class 9 is created as follows: class SpecificClass(GenericClass[str]): def method(value: str): ...

[0047] For example, "[str]" specifies the type parameter "T" 17 as a string, a concretized data type 18. The concretized data type 18 can also be referred to as a concretized type. In the example code, the parent class 2 is referred to as "GenericClass" and the inheriting class 9 as "SpecificClass." An object "obj" of the inheriting class 9 can then be created, in particular using the following example code: obj = SpecificClass()

[0048] If appropriate, the object "obj" has an attribute "_orig_bases_", in particular an automatically generated one, which contains a base class of the object "obj". It is preferably checked whether the parent class 2 with the specified generic types, in particular the specified data type 14, corresponds to the expected base class, in particular stored in "_orig_bases_". If the checked parent class 2 is not a generic base class of the object, an entry is created in an error list and then output as an error message. For example, the check is performed by calling the following test function: def test_realization(): instance = SpecificClass() assert is_generic_instance(instance, GenericClass[str])

[0049] In this sample test function code, the object is called "instance" instead of "obj." An attribute "_orig_bases_," which contains the base class of the object "instance," is also automatically created for "instance." The object's name can be arbitrary. It is sufficient, in particular, that only a single object is created for an inheriting class 9, for example.

[0050] If such an object is created which is derived from the inheriting class 9, then it is preferably checked for all abstract members of the parent class 2 whether there is a non-abstract member in the inheriting class 9 which has the same properties.

[0051] For example, parent class 2 has attribute 3 "Attribute." The inheriting class 9 also has attribute 10 called "Attribute." Therefore, the member's Name property matches. Both attributes are attributes and not methods. Therefore, these members also match in terms of type. In particular, the data type of attributes 5 and 12 is also compared. Both attributes are of the data type String 5 and 12. Therefore, this property also matches. Comparing method 4 "Operation" of parent class 2 with method 11 "Operation" of the inheriting class 9, it can be seen that they match in terms of the Name property. Comparing their parameters, it can be seen that they have the same name "Value" 6 and 13 and are of the same data type "String" 7 and 14.The return value of the member “Operation” of the parent class 2 is a Boolean data type 8 and the return value of the member “Operation” of the inheriting class 9 is also a Boolean data type 15. For example, the generic data type “T” 17 can be seen to have been specified as “String” 18.

[0052] Since for all abstract members 3, 4 of parent class 2, a non-abstract member 10, 11 of the inheriting class 9 can be found that matches with respect to all compared properties or all generic type parameters have been specified, it can be assumed that the inheriting class 9 has correctly inherited from parent class 2. To ensure that the members of the correct inheriting class 9 are compared with respect to the members of the correct parent class 2, a connection between parent class 2 and inheriting class 9 can be verified by checking for the object to be created whether it was derived from both the inheriting class 9 and the parent class 2.

[0053] This procedure is particularly advantageous when performed before executing a main part, especially in the context of a unit test. This can shorten the time until an error is detected. An error occurs in particular when not all abstract members are implemented in the inheriting class 9, or when the member in the inheriting class 9 does not match the abstract member in terms of its properties.

[0054] For example, a software component "client" 16 accesses parent class 2 when it accesses an object that is an instance of a class inheriting from parent class 2. To ensure that the object is an instance of a class 9 inheriting from parent class 2, this is checked in one embodiment. In addition, if necessary, it is checked whether there are arguments or return values that are generic classes. If this is the case, the corresponding argument or return value can be checked for correctness, for example, using the test function already described. If this check fails, an entry is created in the error list. In particular, a program interruption and output of the error list are then triggered. This can also be referred to, for example, as a "WrongTypeError - Exception."

[0055] For example, at runtime, the program checks whether there are arguments or return values that are generic classes. If there are functions in the computer program that have arguments and / or return values that are generic classes, these are checked according to the method according to the invention or an embodiment thereof. A function decorator @typechecked is preferably used for this purpose.

[0056] To ensure fast runtime checking, it's best to check which arguments or return values are or contain generic classes, especially at the time of function definition. For this purpose, the @typechecked function decorator can be used, for example, as follows: @typechecked def function1 (argument: GenericClass[str]): ...

[0057] The function decorator @typechecked preferably stores the position and type of these arguments or return values and can then access the stored data when the function is called and thus very quickly perform a check of the corresponding arguments or return values.

[0058] To shorten the time until an error is detected, in one embodiment, this check is also performed before executing the main part. In particular, the check is performed in a unit test and / or in a composition root at the beginning of the computer program's execution when constructors are called. In this embodiment, it is referred to as an error if a software component, in particular according to a program code, accesses an object via an interface that does not belong to the object, in particular does not reference the object.

[0059] If such an error and / or an error as described above is detected in one embodiment, an error message is output. If necessary, execution of the main part is prevented. The error message can be output to a user and / or made available to an external system. In particular, the external system can automatically correct the error.

[0060] For example, the computer program, particularly the one being tested, can be used for web applications that contain artificial intelligence (AI) algorithms and / or are used by specialist departments. In particular, the computer program being tested can be used in a vehicle, for example, for in-vehicle applications.

[0061] Furthermore, the following can apply when implementing the procedure: For example, a function “is_generic_instance(obj, Type)” is created, which performs the following checks: 1) In particular, determine whether "Type" is a generic class. This is the case, for example, if the "_origin_" attribute is present. 2a) If "Type" is not a generic class, only the "isinstance(obj, Type)" check is performed. Further checks may not be necessary. 2b) If “Type” is a generic class, the check “isinstance(obj, Type._origin_)” is performed to ensure that “obj” is at least already an instance of the generic class. 2c) If the test under 2b) was successful, all generic base types of "obj," for example, are checked to see if any of them are identical to "Type." The generic base types are available, in particular, in the "_orig_bases_" attribute. If at least one of the base types is identical to Type, then the test may be passed. Otherwise, the test may be failed, and it is thus known that "obj" is not an instance of the specific generic class "Type."

[0062] In one embodiment, the function may also check complex, composite generic types (for example, lists, sets, tuples, and dictionaries containing specific generic types), for example by checking for such a complex type between step 2b) and step 2c) and then performing a recursive check of the type argument of the complex type.

[0063] Using the illustrated embodiments, it is possible, for example, to implement extended patterns such as Command-Query-Responsibility-Separation (CQRS), in which different classes are derived from generic command and query classes. List of reference symbols 1 class diagram 2 parent class 3 Class member 4 Class member 5 Data type 6 Transfer parameters 7 Data type 8 Data type 9 inheriting class 10 class member 11 class member 12 Data type 13 Transfer parameters 14 Data type 15 Data type 16 Software component 17 generic data type 18 concretized generic data type

Claims

[1] Method for testing a computer program programmed in an object-oriented scripting language, comprising the following steps: a) providing a computer program part for generating classes; b) providing at least one parent class (2) by means of the computer program part; c) providing a class (9) inheriting from the parent class (2), in which generic types (17) of the parent class (2) are concretized; d) creating an object derived from the inheriting class (9), whereby this object represents a reference to the parent class (2), e) Check whether the parent class (2) with concretized generic types (18) is a base class of the object; and f) if the checked parent class (2) is not a generic base class of the object, an entry is created in an error list and this is then output as an error message. [2] Method according to claim 1, wherein it is checked whether the parent class (2) is a generic class with a type parameter and steps c) to f) are carried out in particular if the parent class (2) is a generic class. [3] Method according to claim 1 or 2, wherein it is checked whether the object is an instance of the parent class (2) and steps e) and f) are carried out in particular if the object is an instance of the parent class (2). [4] Method according to claims 2 and 3, wherein the method according to claim 3 is executed when the check according to claim 2 shows that the parent class (2) is a generic class. [5] Method according to claim 1 or 2, wherein after performing step d) it is checked whether the parent class (2) has composite generic type parameters and if so, steps e) and f) are performed recursively for the composite type parameter. [6] Method according to one of the preceding claims, comprising the following further steps: - checking for all objects referenced by a software component (16) of the computer program whether the respective referenced object represents a reference to the associated parent class (2); - If there are functions in the computer program which have arguments and / or return values which are generic classes, these are checked according to a method according to one of the preceding claims; and - If at least one checked object referenced by a software component (16) does not represent the reference to the associated parent class (2) and / or the check of an argument and / or a return value fails, a further error message is output. [7] Method for executing a computer program, - in which testing of the computer program is carried out before execution of a main part of the computer program according to one of the preceding claims 1 to 6, and - if an entry is made in the error list or an error message is displayed, the execution of the main part is prevented, and - if no entry is made in the error list or an error message is displayed, the main part of the computer program is started, in particular automatically, and / or - the method according to one of the preceding claims 1 to 6 is carried out at least once when the execution of the main part has already started, in particular when an object derived from an inheriting class (9) is created. [8] System for carrying out a method, comprising an electronic test unit and / or at least one electronic computing unit for carrying out the steps of the method according to one of the preceding claims. [9] A computer program which is tested according to a method according to any one of claims 1 to 6 and which is loadable into a memory unit and executable by a processor. [10] A computer-readable storage medium comprising instructions which, when executed by a computer, cause the computer to carry out the steps of the method according to any one of claims 1 to 7.

Images