Property Testing Review

Property Testing Review







In recent years, property-based testing has grown in popularity in the functional world. It gained popularity in Haskell due to the usage of the QuickCheck framework, which gives a fresh approach to software testing. It encompasses the whole scope of example-based testing, from unit tests to integration tests and everything in between. Properties are used while undertaking property-based testing. Before passing the test, it ensures that a function, program, or whatever system is being tested meets a set of requirements. In the vast majority of cases, properties do not need to reveal a lot of information about the output. All that is left is for them to look for differentiating features in the output. Using property-based tests, you may make assertions about your code’s output that are reliant on the input, and these statements can be validated over a wide range of inputs. A kind of generative testing is property-based testing. In contrast to unit tests, you do not supply explicit sample inputs with projected outputs. Another technique would be to offer code characteristics and then use a generative testing engine (such as QuickCheck) to generate randomized inputs to validate that the supplied characteristics are valid. Furthermore, property-based testing allows for a more in-depth understanding of the function being tested. In general, property testers are algorithms that discriminate between inputs that fulfill and those that do not satisfy a specific characteristic.


The goal of this section is to show the rationale for doing this research project. Testing a graph property is a relaxation of the process of determining whether or not a graph has the characteristic. Furthermore, a precise judgment technique is required in order to accept or reject any graph that has the attribute. In order to be valid, a testing method must accept every graph that has the attribute while rejecting only those graphs that do not possess it. We anticipate that the algorithm will only observe a smaller fraction of the network and that it will run quicker than any other accurate judgment approach available. We want to spend time in a manner that is sub-linear or even independent of the size of the graph. There are algorithms for “fixing” the graph (e.g., connectedness) (that is, modifying it so that it will have the property). If the graph is accepted, we may be sure that the number of required edge modifications is not too huge, and that the total cost is not too high. If the graph is too large to scan, make a choice without seeing the whole graph. Exact answers may be NP-hard, therefore approximations are inevitable (even if scanning the network is doable).

Related Work

Property testing is the study of ultra-fast (randomized) procedures for approximation decision making in the context of approximation decision making. When given direct access to objects in a large data collection, these algorithms must determine whether or not the data set has a preset (global) attribute or if the item in question is remote from it. Contrary to expectations, this approximate assessment is based on a small percentage of the data set, which is surprising. It is possible to apply some commonly occurring mathematical aspects to specific desired functionality if you correlate software functions with mathematical functions. Certain properties, on the other hand, are less obvious in applications that are not mathematical in nature. Property testing is a subset of decision problems that focuses on algorithms that are capable of reading just parts of the input to determine the properties of the input. This results in an input that is represented as a function to which the tester has oracle access. As a result of this, the tester must accept functions that possess a specified property (i.e., those that belong to a predefined set) and reject any function that is “distant” from the set of functions that possess the property. Defining distances between functions as the proportion of the domain on which they disagree, and providing the tester with a proximity parameter that determines the threshold for assessing how far apart they are from each other is the goal.


Aspects of property testing are focused with approximations, with the issue of distinguishing between things that contain a specific feature and those that are “far” from possessing that trait. In many cases, objects and functions are represented as functions, and the distance between them may be measured in terms of the fraction of the domain on which they differ. Here, the aim is to investigate (randomized) algorithms that are capable of querying the function with any parameters they choose, and we are looking for methods with very low complexity (i.e., considerably less than the domain size of the function). Ideally, the different strategies for evaluating graph attributes and how they differ from one another will be tested in this report. The methodologies that are employed are determined by the representation. The adjacency-matrix representation is based on random sampling, which is a critical component.

When the method is run, it picks a little subgraph of the graph G at random, discovers the edges connecting the vertices, and determines whether the property is true (or “nearly holds”). After that, the algorithm approves. If this is not the case, it rejects. It is typically self-evident that any graph that has the attribute is acceptable (always, or with high probability). The evidence is based on demonstrating that a graph without the property is more likely to be rejected than one that does. When attempting to establish a claim, this general analytical approach is widely used. Each section of the sample is separated into two halves. For simplicity, let’s pretend that the first sample constrains all of the remaining graph vertices. If the graph does not possess this quality, many vertices (or pairs of vertices) will fail to comply with the restrictions imposed on them. The unmet constraints are shown in the second half of the sample. The incidence-list representation necessitates the development of a new set of techniques. Due to the limited number of edges in graphs, a tiny random sample of vertices will often include no internal edges, resulting in an empty graph. In this case, algorithms use tactics other than pure random sampling to get their results. Some algorithms do exhaustive local search, whereas others do not (such as a breadth-first search until a certain number of vertices is found). A random walk technique makes use of vertices that are picked at random.


The problem is that the vast majority of test engineers write example-based tests that only look at one input situation. Property testing is an excellent addition to your test suite since it repeats a single line hundreds of times with different inputs. Property testing frameworks employ virtually every conceivable input that may harm your code, such as empty lists, negative values, and excessively extended lists or strings. If your code passes a property test, you may be confident that it is ready for production. Property-based tests ensure that specific aspects of a property are always true. They let you to create and test several inputs in a single test, rather than having to write separate tests for each value you want to test. A shopping website, for example, may have an items attribute with a value that must always be more than zero but less than 10. A single property-based test for the items property may be constructed to test for a negative value, numerous values within the range, and a few values more than 10. Another, more complex example is medical software with a heart rate characteristic. If the heart rate is outside the usual range, a warning message should be presented, according to business needs. Because unit tests only investigate a section of the code, many tests would be required to validate each value that is contained inside, outside of, valid, or invalid. Property-based tests, on the other hand, allow for the testing of all necessary inputs that should result in a certain result in a single test, resulting in more efficient test preparation and execution, as well as faster test execution.


The issue of property testing and the problems addressed herein are quite complex. As expected, tis was a team effort. Members of the team were all involved in meeting the goals of the entire project. The first group member dealt with providing discussion materials for familiarity with the concepts. The second and third members focused on collecting only relevant materials and distribution of roles. Other group members were each assigned reference materials to underline key words and highlight what the report would use. We then focused on making the report together beginning from the introduction to the description of roles and the actual report writing. The entire time we were working together to ensure that no group member was left behind. We tried to be cohesive and to solve all emerging issues with speed and understanding.