1. Introduction<\/h2>\n
First of all, lets start with the question. What is property based testing? The way which provides the solution for the above scenarios i.e. to test with random parameter values is known as property based testing. We will use the following tools and technologies for this example and show how this works.<\/p>\n Create a new Maven project for JUnit quickcheck example.<\/p>\n Click Fill in the details and click on Finish button.<\/p>\n <\/span> Open pom.xml<\/em><\/span><\/p>\n In our example we are using some matchers to work with. For that purpose, we are using Java Hamcrest<\/a> (highlighted above) library. To run the class with the quickcheck, we need to annotate the class with QuickCheck.java<\/em><\/span><\/p>\n Line 14: Run with In the following sections we will be explaining each and every case defined in this class. For the sake of reading and knowledge, we have used the We will start by testing with very simple test case where we put In this method, we have used Output<\/strong><\/p>\n Now we want to assume something before running our test cases. Like in above example, we want to generate only positive values. In that case we will use the Now, this test will pass, as we have already checked the generated values should be greater than 0. In this case, we are using the Output<\/strong><\/p>\n It is cleared from output, cases that pass the We can also test our cases by allowing the parameters to be in some range. In this case, we are passing the Output<\/strong><\/p>\n As seen in this output, only numbers between 0 and 100 are generated. The primary difference between This test case will pass, only if the parameter satisfies the condition. For each property, junit-quickcheck uses a unique value as a Here every time test case runs, it will start generating number from Output<\/strong><\/p>\n When a property is disproved for a given set of values, junit-quickcheck will attempt to find “smaller” sets of values that also disprove the property, and will report the smallest such set.<\/p>\n For the details of how to use it, users are advised to visit junit-quickcheck<\/a> library.<\/p>\n In conclusion, JUnit Quickcheck example demonstrates the way to test our code by passing the random values to parameters during running. This method of testing is known as property based testing. Users have learnt the use of junit-quickcheck<\/a> library for implementing the property based testing in Java.<\/p>\n This is a JUnit Quickcheck Example<\/p>\n
\nIn Java, we can achieve this by using the junit-quickcheck<\/a> library. This library will provides the way to test our cases with the property based testing.<\/p>\n2. Tools Used<\/h2>\n
\n
3. Project Setup<\/h2>\n
\nYou may skip project creation and jump directly to the beginning of the example<\/strong><\/a> below.<\/div>\nFile -> New -> Maven Project<\/code>.
\nFill in the details as shown and click on Next button.<\/p>\n![\"JUnit](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/02\/junit-quickcheck-1.jpg\")
<\/a>![\"JUnit](\"http:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2017\/02\/junit-quickcheck-2.jpg\")
<\/a>
\nWith the click on Finish button, setup is done. Now we will start with the JUnit quickcheck example.<\/p>\n4. JUnit Quickcheck Example<\/h2>\n
pom.xml<\/code> and add the following lines to the file.<\/p>\n<dependencies>\n <dependency>\n <groupId>junit<\/groupId>\n <artifactId>junit<\/artifactId>\n <version>4.12<\/version>\n <\/dependency>\n\n <!-- For matchers used in example -->\n <dependency>\n <groupId>org.hamcrest<\/groupId>\n <artifactId>java-hamcrest<\/artifactId>\n <version>2.0.0.0<\/version>\n <\/dependency>\n\n <!-- Core junit-quickcheck -->\n <dependency>\n <groupId>com.pholser<\/groupId>\n <artifactId>junit-quickcheck-core<\/artifactId>\n <version>0.7<\/version>\n <\/dependency>\n\n <!-- consists of generators for basic Java types, such as primitives, arrays,\n and collections -->\n <dependency>\n <groupId>com.pholser<\/groupId>\n <artifactId>junit-quickcheck-generators<\/artifactId>\n <version>0.7<\/version>\n <\/dependency>\n<\/dependencies>\n<\/pre>\n
@RunWith(JUnitQuickcheck.class)<\/code> annotationpackage junitquickcheck;\n\nimport static org.hamcrest.Matchers.greaterThan;\nimport static org.junit.Assert.assertTrue;\nimport static org.junit.Assume.assumeThat;\n\nimport org.junit.runner.RunWith;\n\nimport com.pholser.junit.quickcheck.Property;\nimport com.pholser.junit.quickcheck.When;\nimport com.pholser.junit.quickcheck.generator.InRange;\nimport com.pholser.junit.quickcheck.runner.JUnitQuickcheck;\n\n@RunWith(JUnitQuickcheck.class)\npublic class QuickCheck {\n\n\t@Property(trials = 5)\n\tpublic void simple(int num) {\n\t\tSystem.out.println(\"simple:\" + num);\n\t\tassertTrue(num > 0);\n\t}\n\n\t@Property(trials = 5)\n\tpublic void assume(int num) {\n\t\tSystem.out.print(\" | Before:\" + num);\n\t\tassumeThat(num, greaterThan(0));\n\t\tSystem.out.println(\" | Afer:\" + num);\n\t\tassertTrue(num > 0);\n\t}\n\n\t@Property(trials = 5)\n\tpublic void inRange(@InRange(minInt = 0, maxInt = 100) int num) {\n\t\tSystem.out.println(\"InRange: \" + num);\n\t\tassertTrue(num > 0);\n\t}\n\n\t@Property(trials = 5)\n\tpublic void when(@When(satisfies = \"#_ > 1000 && #_ < 100000\") int num) {\n\t\tSystem.out.println(\"when: \" + num);\n\t\tassertTrue(num > 0);\n\t}\n\t\n\t@Property(trials = 5)\n\tpublic void seed(@When(seed = 1L) int num) {\n\t\tSystem.out.println(\"seed: \" + num);\n\t\tassertTrue(num > 0);\n\t}\n\n}\n\n<\/pre>\n @RunWith(JUnitQuickcheck.class)<\/code> annotation usage
\nLine 17: @Property<\/code> annotation usage
\nLine 26: assumeThat()<\/code> method usage
\nLine 32: @InRange<\/code> annotation usage
\nLine 38: @When<\/code> annotation usage
\nLine 44: seed<\/code> usage<\/p>\nprintln<\/code> statements in the class.<\/p>\n4.1 Simple Unit Test<\/h3>\n
@Property<\/code> annotation on a method.<\/p>\n ...\n @Property(trials=5)\n public void simple(int num) {\n System.out.println(\"simple:\" + num);\n assertTrue(num>0);\n }\n ...\n<\/pre>\n@Property<\/code> annotation with trials<\/code> as attribute to it. By default junit-quickcheck library uses 100 random generated values. But we can increase or decrease accordingly as to suit the test cases.
\nThis test will run with 5 random numbers.
\nThe test may or may not pass, due the random numbers generated. In our case it was failed as some values are negative and 0 as well. See the output of above case.<\/p>\nsimple:-257806626\nsimple:257806626\nsimple:0\n<\/pre>\n
4.2 Using Assume Class<\/h3>\n
Assume<\/code> class from JUnit. The assumeThat()<\/code> method will assume the values to be passed before any other values to be tested.<\/p>\n ...\n @Property(trials = 5)\n public void assume(int num) {\n System.out.print(\" | Before:\" + num);\n assumeThat(num, greaterThan(0));\n System.out.println(\" | Afer:\" + num);\n assertTrue(num > 0);\n }\n ...\n<\/pre>\ngreaterThan()<\/code> method of Hamcrest library.[ulp id=’ODQaBEw1BIbHApZq’]<\/p>\n | Before:1773769579 | After:1773769579\n | Before:-733573616 | Before:-111086781 \n | Before:559050708 | After:559050708\n | Before:-940357482\n<\/pre>\n
assumeThat<\/code> will only go through the case for testing. Others will be ignored safely.<\/p>\n4.3 @InRange Annotation<\/h3>\n
\nFor this scenario, we will be using @InRange<\/code> annotation.<\/p>\n ...\n @Property(trials=5)\n public void inRange(@InRange(minInt = 0, maxInt = 100) int num) {\n System.out.println(\"InRange: \" + num);\n assertTrue(num>0);\n }\n ...\n<\/pre>\n@InRange<\/code> annotation to set the minimum and maximum value to be generated.<\/p>\nInRange: 91\nInRange: 49\nInRange: 57\nInRange: 57\nInRange: 88\n<\/pre>\n
assumeThat()<\/code> and @InRange<\/code> is that, in assumeThat()<\/code> case all numbers are generated and then values are tested. Whereas in case of @InRange<\/code>, values are generated accordingly and then passed to test.<\/p>\n4.4 @When Annotation<\/h3>\n
@When<\/code> is used in case where we wan to have a constraint. We will be using @When<\/code> annotation with satisfies<\/code> attribute which is an OGNL<\/a> expression for this example to work.<\/p>\n ...\n @Property(trials = 5)\n public void when(@When(satisfies = \"#_ > 1000 && #_ < 100000\") int num) {\n System.out.println(\"when: \" + num);\n assertTrue(num > 0);\n }\n ...\n<\/pre>\njunit-quickcheck<\/code> generates values for a property parameter with a constraint expression until the ratio of constraint failures constraint passes is greater than the discardRatio specified by @When<\/code>. Exceeding the discard ratio raises an exception and thus fails the property. In most cases this test fails, so you need to increase your trials to more, may be around 2000.<\/p>\n4.5 Using Seed<\/h3>\n
seed<\/code> for the source of randomness for generating values. We can fix the seed<\/code> to some specific value with @When<\/code> annotation . You may want to fix the seed<\/code> when a property fails, so that you can test the property over and over again with the same set of generated values that caused the failure.<\/p>\n ...\n @Property(trials = 5)\n public void when(@When(seed = 1L) int num) {\n System.out.println(\"seed: \" + num);\n assertTrue(num > 0);\n }\n ...\n<\/pre>\nseed<\/code> value only.<\/p>\nseed: 1715954472\nseed: -397543022\nseed: 397543022\nseed: 0\n<\/pre>\n
4.6 Shrinking<\/h3>\n
4.6.1 Various parameters used with shrinking process<\/h4>\n
\n
shrink<\/code> attribute of a @Property<\/code> annotation to false. Example: @Property(shrink = false)<\/code><\/li>\nshrink<\/code> attempts made for a given property, set the maxShrinks<\/code> attribute of that @Property<\/code>. Example: @Property(maxShrinks = 5)<\/code><\/li>\nshrink<\/code> search “tree” for a given property, set the maxShrinkDepth<\/code> attribute of that @Property<\/code>. Example: @Property(maxShrinkDepth = 3)<\/code><\/li>\n<\/ul>\n5. Conclusion<\/h2>\n
6. Download<\/h2>\n