How to use containADigit method of io.kotest.matchers.string.matchers class

Best Kotest code snippet using io.kotest.matchers.string.matchers.containADigit

StringMatchersTest.kt

Source:StringMatchersTest.kt

...8import io.kotest.matchers.shouldNot9import io.kotest.matchers.string.beBlank10import io.kotest.matchers.string.beEmpty11import io.kotest.matchers.string.contain12import io.kotest.matchers.string.containADigit13import io.kotest.matchers.string.containIgnoringCase14import io.kotest.matchers.string.containOnlyDigits15import io.kotest.matchers.string.containOnlyOnce16import io.kotest.matchers.string.containOnlyWhitespace17import io.kotest.matchers.string.endWith18import io.kotest.matchers.string.haveSameLengthAs19import io.kotest.matchers.string.match20import io.kotest.matchers.string.shouldBeBlank21import io.kotest.matchers.string.shouldBeEmpty22import io.kotest.matchers.string.shouldBeEqualIgnoringCase23import io.kotest.matchers.string.shouldBeInteger24import io.kotest.matchers.string.shouldBeSingleLine25import io.kotest.matchers.string.shouldContain26import io.kotest.matchers.string.shouldContainADigit27import io.kotest.matchers.string.shouldContainIgnoringCase28import io.kotest.matchers.string.shouldContainOnlyDigits29import io.kotest.matchers.string.shouldContainOnlyOnce30import io.kotest.matchers.string.shouldEndWith31import io.kotest.matchers.string.shouldHaveLengthBetween32import io.kotest.matchers.string.shouldHaveLengthIn33import io.kotest.matchers.string.shouldHaveSameLengthAs34import io.kotest.matchers.string.shouldMatch35import io.kotest.matchers.string.shouldNotBeBlank36import io.kotest.matchers.string.shouldNotBeEmpty37import io.kotest.matchers.string.shouldNotBeEqualIgnoringCase38import io.kotest.matchers.string.shouldNotBeSingleLine39import io.kotest.matchers.string.shouldNotContain40import io.kotest.matchers.string.shouldNotContainADigit41import io.kotest.matchers.string.shouldNotContainIgnoringCase42import io.kotest.matchers.string.shouldNotContainOnlyDigits43import io.kotest.matchers.string.shouldNotContainOnlyOnce44import io.kotest.matchers.string.shouldNotEndWith45import io.kotest.matchers.string.shouldNotHaveLengthBetween46import io.kotest.matchers.string.shouldNotHaveLengthIn47import io.kotest.matchers.string.shouldNotHaveSameLengthAs48import io.kotest.matchers.string.shouldNotMatch49class StringMatchersTest : FreeSpec() {50   init {51      "string shouldBe other" - {52         "should support null arguments" {53            val a: String? = "a"54            val b: String? = "a"55            a shouldBe b56         }57         "should report when only line endings differ" {58            forAll(59               row("a\nb", "a\r\nb"),60               row("a\nb\nc", "a\nb\r\nc"),61               row("a\r\nb", "a\nb"),62               row("a\nb", "a\rb"),63               row("a\rb", "a\r\nb")64            ) { expected, actual ->65               shouldThrow<AssertionError> {66                  actual shouldBe expected67               }.let {68                  it.message shouldContain "contents match, but line-breaks differ"69               }70            }71         }72         "should show diff when newline count differs" {73            shouldThrow<AssertionError> {74               "a\nb" shouldBe "a\n\nb"75            }.message shouldBe """76               |(contents match, but line-breaks differ; output has been escaped to show line-breaks)77               |expected:<a\n\nb> but was:<a\nb>78               """.trimMargin()79         }80      }81      "contain only once" {82         "la tour" should containOnlyOnce("tour")83         "la tour tour" shouldNot containOnlyOnce("tour")84         "la tour tour" shouldNotContainOnlyOnce "tour"85         shouldThrow<AssertionError> {86            "la" should containOnlyOnce("tour")87         }.message shouldBe """"la" should contain the substring "tour" exactly once"""88         shouldThrow<AssertionError> {89            null shouldNot containOnlyOnce("tour")90         }.message shouldBe "Expecting actual not to be null"91         shouldThrow<AssertionError> {92            null shouldNotContainOnlyOnce "tour"93         }.message shouldBe "Expecting actual not to be null"94         shouldThrow<AssertionError> {95            null should containOnlyOnce("tour")96         }.message shouldBe "Expecting actual not to be null"97         shouldThrow<AssertionError> {98            null shouldContainOnlyOnce "tour"99         }.message shouldBe "Expecting actual not to be null"100      }101      "contain(regex)" {102         "la tour" should contain("^.*?tour$".toRegex())103         "la tour" shouldNot contain(".*?abc.*?".toRegex())104         "la tour" shouldContain "^.*?tour$".toRegex()105         "la tour" shouldNotContain ".*?abc.*?".toRegex()106         shouldThrow<AssertionError> {107            "la tour" shouldContain ".*?abc.*?".toRegex()108         }.message shouldBe "\"la tour\" should contain regex .*?abc.*?"109         shouldThrow<AssertionError> {110            "la tour" shouldNotContain "^.*?tour$".toRegex()111         }.message shouldBe "\"la tour\" should not contain regex ^.*?tour\$"112         shouldThrow<AssertionError> {113            null shouldNot contain("^.*?tour$".toRegex())114         }.message shouldBe "Expecting actual not to be null"115         shouldThrow<AssertionError> {116            null shouldNotContain "^.*?tour$".toRegex()117         }.message shouldBe "Expecting actual not to be null"118         shouldThrow<AssertionError> {119            null should contain("^.*?tour$".toRegex())120         }.message shouldBe "Expecting actual not to be null"121         shouldThrow<AssertionError> {122            null shouldContain "^.*?tour$".toRegex()123         }.message shouldBe "Expecting actual not to be null"124      }125      "string should beEmpty()" - {126         "should test that a string has length 0" {127            "" should beEmpty()128            "hello" shouldNot beEmpty()129            "hello".shouldNotBeEmpty()130            "".shouldBeEmpty()131            shouldThrow<AssertionError> {132               "hello".shouldBeEmpty()133            }.message shouldBe "\"hello\" should be empty"134            shouldThrow<AssertionError> {135               "".shouldNotBeEmpty()136            }.message shouldBe "<empty string> should not be empty"137         }138         "should fail if value is null" {139            shouldThrow<AssertionError> {140               null shouldNot beEmpty()141            }.message shouldBe "Expecting actual not to be null"142            shouldThrow<AssertionError> {143               null.shouldNotBeEmpty()144            }.message shouldBe "Expecting actual not to be null"145            shouldThrow<AssertionError> {146               null should beEmpty()147            }.message shouldBe "Expecting actual not to be null"148            shouldThrow<AssertionError> {149               null.shouldBeEmpty()150            }.message shouldBe "Expecting actual not to be null"151         }152      }153      "string should containADigit()" - {154         "should test that a string has at least one number" {155            "" shouldNot containADigit()156            "1" should containADigit()157            "a1".shouldContainADigit()158            "a1b" should containADigit()159            "hello" shouldNot containADigit()160            "hello".shouldNotContainADigit()161            shouldThrow<AssertionError> {162               "hello" should containADigit()163            }.message shouldBe "\"hello\" should contain at least one digit"164         }165         "should fail if value is null" {166            shouldThrow<AssertionError> {167               null shouldNot containADigit()168            }.message shouldBe "Expecting actual not to be null"169            shouldThrow<AssertionError> {170               null.shouldNotContainADigit()171            }.message shouldBe "Expecting actual not to be null"172            shouldThrow<AssertionError> {173               null should containADigit()174            }.message shouldBe "Expecting actual not to be null"175            shouldThrow<AssertionError> {176               null.shouldContainADigit()177            }.message shouldBe "Expecting actual not to be null"178         }179      }180      "string should beBlank()" - {181         "should test that a string has only whitespace" {182            "" should beBlank()183            "" should containOnlyWhitespace()184            "     \t     " should beBlank()185            "hello" shouldNot beBlank()186            "hello".shouldNotBeBlank()187            "   ".shouldBeBlank()...

matchers.kt

Source:matchers.kt

...17    value.toCharArray().all { it in '0'..'9' },18    "${value.show().value} should contain only digits",19    "${value.show().value} should not contain only digits")20}21fun String?.shouldContainADigit() = this should containADigit()22fun String?.shouldNotContainADigit() = this shouldNot containADigit()23fun containADigit() = neverNullMatcher<String> { value ->24  MatcherResult(25    value.toCharArray().any { it in '0'..'9' },26    "${value.show().value} should contain at least one digit",27    "${value.show().value} should not contain any digits")28}29infix fun String?.shouldContainOnlyOnce(substr: String) = this should containOnlyOnce(substr)30infix fun String?.shouldNotContainOnlyOnce(substr: String) = this shouldNot containOnlyOnce(substr)31fun containOnlyOnce(substring: String) = neverNullMatcher<String> { value ->32  MatcherResult(33    value.indexOf(substring) >= 0 && value.indexOf(substring) == value.lastIndexOf(substring),34    "${value.show().value} should contain the substring ${substring.show().value} exactly once",35    "${value.show().value} should not contain the substring ${substring.show().value} exactly once"36  )37}...

SpdxDeclaredLicenseMappingTest.kt

Source:SpdxDeclaredLicenseMappingTest.kt

...23import io.kotest.matchers.ints.shouldBeGreaterThanOrEqual24import io.kotest.matchers.nulls.beNull25import io.kotest.matchers.should26import io.kotest.matchers.shouldBe27import io.kotest.matchers.string.containADigit28import io.kotest.matchers.string.shouldContain29import org.ossreviewtoolkit.utils.common.titlecase30class SpdxDeclaredLicenseMappingTest : WordSpec({31    "The list" should {32        "not contain any duplicate keys with respect to capitalization" {33            val keys = SpdxDeclaredLicenseMapping.rawMapping.keys.toMutableList()34            val uniqueKeys = SpdxDeclaredLicenseMapping.mapping.keys35            // Remove keys one by one as calling "-" would remove all occurrences of a key.36            uniqueKeys.forEach { uniqueKey -> keys.remove(uniqueKey) }37            keys should beEmpty()38        }39        "not contain any deprecated values" {40            SpdxDeclaredLicenseMapping.rawMapping.values.forAll {41                it.isValid(SpdxExpression.Strictness.ALLOW_CURRENT) shouldBe true42            }43        }44        "not associate licenses without a version to *-only" {45            val keysWithImpliedVersion = listOf(46                // See http://www.gwtproject.org/terms.html#licenses which explicitly mentions "GNU Lesser General47                // Public License v. 2.1".48                "GWT Terms",49                "http://www.gwtproject.org/terms.html",50                // This forwards to http://www.gnu.org/licenses/lgpl-3.0.html which has a version in the URL.51                "http://www.gnu.org/copyleft/lesser.html"52            )53            SpdxDeclaredLicenseMapping.rawMapping.asSequence().forAll { (key, license) ->54                if (key !in keysWithImpliedVersion && license.licenses().any { it.endsWith("-only") }) {55                    key should containADigit()56                }57            }58        }59    }60    "The mapping" should {61        "not contain single ID strings" {62            val licenseIdMapping = SpdxDeclaredLicenseMapping.mapping.filter { (_, expression) ->63                expression is SpdxLicenseIdExpression64            }65            licenseIdMapping.keys.forAll { declaredLicense ->66                @Suppress("SwallowedException")67                try {68                    val tokens = getTokensByTypeForExpression(declaredLicense)69                    tokens.size shouldBeGreaterThanOrEqual 2...

SpdxSimpleLicenseMappingTest.kt

Source:SpdxSimpleLicenseMappingTest.kt

...24import io.kotest.matchers.collections.shouldHaveAtMostSize25import io.kotest.matchers.nulls.beNull26import io.kotest.matchers.should27import io.kotest.matchers.shouldBe28import io.kotest.matchers.string.containADigit29import org.ossreviewtoolkit.utils.common.titlecase30class SpdxSimpleLicenseMappingTest : WordSpec({31    "The raw map" should {32        "not contain any duplicate keys with respect to capitalization" {33            val keys = SpdxSimpleLicenseMapping.customLicenseIdsMap.keys.toMutableList()34            val uniqueKeys = SpdxSimpleLicenseMapping.customLicenseIds.keys35            // Remove keys one by one as calling "-" would remove all occurrences of a key.36            uniqueKeys.forEach { uniqueKey -> keys.remove(uniqueKey) }37            keys should beEmpty()38        }39        "not contain any deprecated values" {40            SpdxSimpleLicenseMapping.customLicenseIdsMap.values.forAll {41                it.deprecated shouldBe false42            }43        }44        "not associate licenses without a version to *-only" {45            SpdxSimpleLicenseMapping.customLicenseIdsMap.asSequence().forAll { (key, license) ->46                if (license.id.endsWith("-only")) key should containADigit()47            }48        }49    }50    "The mapping" should {51        "contain only single ID strings" {52            SpdxSimpleLicenseMapping.mapping.keys.forAll { declaredLicense ->53                val tokens = getTokensByTypeForExpression(declaredLicense)54                val types = tokens.map { (type, _) -> type }55                tokens shouldHaveAtLeastSize 156                tokens shouldHaveAtMostSize 257                tokens.joinToString("") { (_, text) -> text } shouldBe declaredLicense58                types.first() shouldBe SpdxExpressionLexer.IDSTRING59                types.getOrElse(1) { SpdxExpressionLexer.PLUS } shouldBe SpdxExpressionLexer.PLUS60            }...

containADigit

Using AI Code Generation

1    import io.kotest.matchers.string.matchers.containADigit2    import io.kotest.matchers.should3    import io.kotest.matchers.shouldNot4    import io.kotest.matchers.string.shouldBeEmpty5    import io.kotest.matchers.string.shouldBeLowerCase6    import io.kotest.matchers.string.shouldBeUpperCase7    import io.kotest.matchers.string.shouldContain8    import io.kotest.matchers.string.shouldContainOnlyDigits9    import io.kotest.matchers.string.shouldEndWith10    import io.kotest.matchers.string.shouldHaveLength11    import io.kotest.matchers.string.shouldHaveLineCount12    import io.kotest.matchers.string.shouldHaveSameLengthAs13    import io.kotest.matchers.string.shouldHaveSubstring14    import io.kotest.matchers.string.shouldInclude15    import io.kotest.matchers.string.shouldNotBeEmpty16    import io.kotest.matchers.string.shouldNotBeLowerCase17    import io.kotest.matchers.string.shouldNotBeUpperCase18    import io.kotest.matchers.string.shouldNotContain19    import io.kotest.matchers.string.shouldNotContainOnlyDigits20    import io.kotest.matchers.string.shouldNotEndWith21    import io.kotest.matchers.string.shouldNotHaveLength22    import io.kotest.matchers.string.shouldNotHaveLineCount23    import io.kotest.matchers.string.shouldNotHaveSameLengthAs24    import io.kotest.matchers.string.shouldNotHaveSubstring25    import io.kotest.matchers.string.shouldNotInclude26    import io.kotest.matchers.string.shouldNotMatch27    import io.kotest.matchers.string.shouldNotStartWith28    import io.kotest.matchers.string.shouldStartWith29    import io.kotest.matchers.string.shouldMatch30    import io.kotest.matchers.string.shouldNotBeBlank31    import io.kotest.matchers.string.shouldNotBeNullOrBlank32    import io.kotest.matchers.string.shouldNotBeNullOrEmpty33    import io.kotest.matchers.string.shouldNotContainAnyOf34    import io.kotest.matchers.string.shouldNotContainNoneOf35    import io.kotest.matchers.string.shouldNotContainOnlyOnce36    import io.kotest.matchers.string.shouldNotContainOnlyOnceIgnoringCase37    import io

containADigit

Using AI Code Generation

1        "containADigit" should {2            "contain a digit" {3                "hello123".should(containADigit())4            }5            "not contain a digit" {6                "hello".shouldNot(containADigit())7            }8        }9        "containADigit" should {10            "contain a digit" {11                "hello123" should containADigit()12            }13            "not contain a digit" {14                "hello" shouldNot containADigit()15            }16        }17        "containADigit" should {18            "contain a digit" {19                "hello123" should containADigit()20            }21            "not contain a digit" {22                "hello" shouldNot containADigit()23            }24        }25        "containADigit" should {26            "contain a digit" {27                "hello123" should containADigit()28            }29            "not contain a digit" {30                "hello" shouldNot containADigit()31            }32        }33        "containADigit" should {34            "contain a digit" {35                "hello123" should containADigit()36            }37            "not contain a digit" {38                "hello" shouldNot containADigit()39            }40        }41        "containADigit" should {42            "contain a digit" {43                "hello123" should containADigit()44            }45            "not contain a digit" {46                "hello" shouldNot containADigit()47            }48        }49        "containADigit" should {50            "contain a digit" {51                "hello123" should containADigit()52            }53            "not contain a digit" {54                "hello" shouldNot containADigit()55            }56        }

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.