├── .gitignore ├── .sbt-depts-scalafmt.conf ├── .scalafmt.conf ├── LICENSE ├── ReadMe.md ├── build.sbt ├── modules └── bridge │ ├── build.sbt │ └── src │ ├── main │ └── scala │ │ └── commons │ │ └── lang3 │ │ └── bridge │ │ ├── StringCommons.scala │ │ └── StringUtils.scala │ └── test │ └── scala │ └── commons │ └── lang3 │ └── bridge │ ├── StringUtilsContainsSpec.scala │ ├── StringUtilsEqualsIndexOfSpec.scala │ ├── StringUtilsIEmptyBlankSpec.scala │ ├── StringUtilsSpec.scala │ ├── StringUtilsStartsEndsWithSpec.scala │ ├── StringUtilsSubstringSpec.scala │ └── StringUtilsTrimStripSpec.scala └── project ├── CommonSettings.scala ├── ProjectKeys.scala ├── build.properties ├── plugins.sbt ├── project └── sbt-depts-djx314-lib.sbt └── sbt-depts-plugin.sbt /.gitignore: -------------------------------------------------------------------------------- 1 | /sbt 2 | **/target/ 3 | /.bsp/ 4 | /.idea/ 5 | **/.bloop/ 6 | /.metals/ 7 | **/metals.sbt 8 | /.vscode/ 9 | /sbt.bat 10 | /sbt-launch.jar -------------------------------------------------------------------------------- /.sbt-depts-scalafmt.conf: -------------------------------------------------------------------------------- 1 | maxColumn = 140 2 | align.preset = more 3 | continuationIndent.defnSite = 2 4 | lineEndings = unix 5 | optIn.breakChainOnFirstMethodDot = false 6 | rewrite.rules = [SortImports] 7 | version = 3.7.14 8 | runner.dialect = scala3 9 | -------------------------------------------------------------------------------- /.scalafmt.conf: -------------------------------------------------------------------------------- 1 | include "./.sbt-depts-scalafmt.conf" 2 | project.excludePaths = [ 3 | ] 4 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. 10 | 11 | "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. 12 | 13 | "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. 14 | 15 | "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. 16 | 17 | "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. 18 | 19 | "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. 20 | 21 | "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). 22 | 23 | "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. 24 | 25 | "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." 26 | 27 | "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 28 | 29 | 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 30 | 31 | 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 32 | 33 | 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: 34 | 35 | You must give any other recipients of the Work or Derivative Works a copy of this License; and 36 | You must cause any modified files to carry prominent notices stating that You changed the files; and 37 | You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and 38 | If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. 39 | 40 | You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 41 | 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 42 | 43 | 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 44 | 45 | 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 46 | 47 | 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 48 | 49 | 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. 50 | 51 | END OF TERMS AND CONDITIONS -------------------------------------------------------------------------------- /ReadMe.md: -------------------------------------------------------------------------------- 1 | # Commons Lang3 Scala Bridge 2 | 3 | [![Maven Central](https://img.shields.io/maven-central/v/net.scalax/commons-lang3-bridge_3.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22net.scalax%22%20AND%20a:%22commons-lang3-bridge_3%22) 4 | 5 | A scala bridge library from apache commons lang3 to scala. 6 | 7 | ## Usage 8 | 9 | Add dependence into sbt like: 10 | 11 | ```scala 12 | libraryDependencies += "net.scalax" %% "commons-lang3-bridge" % "0.1.0" 13 | libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.13.0" 14 | ``` 15 | 16 | or maven: 17 | ```xml 18 | 19 | net.scalax 20 | commons-lang3-bridge_3 21 | 0.1.0 22 | 23 | 24 | org.apache.commons 25 | commons-lang3 26 | 3.13.0 27 | 28 | ``` 29 | 30 | *Commons lang3 bridge support scala 2.11, 2.12, 2.13, 3.1, and 3.2, choice edition by prefix.* 31 | 32 | Add import in your source: 33 | 34 | ```scala 35 | import commons.lang3.bridge.StringUtils.ops._ 36 | ``` 37 | 38 | Now, you can call commons lang string utils functions as String or `Option[String]`'s method like: 39 | 40 | ```scala 41 | test("test string substring after last separator char") { 42 | assert(nullString.ops.substringAfterLast(0).isEmpty) 43 | assert(noneString.ops.substringAfterLast('X').isEmpty) 44 | assert("".ops.substringAfterLast(0).contains("")) 45 | assert(Some("").ops.substringAfterLast('a').contains("")) 46 | 47 | assert("foo".ops.substringAfterLast(0).contains("")) 48 | assert("foo".ops.substringAfterLast('b').contains("")) 49 | assert(Some("foot").ops.substringAfterLast('o').contains("t")) 50 | assert("abc".ops.substringAfterLast('a').contains("bc")) 51 | assert("abcba".ops.substringAfterLast('b').contains("a")) 52 | assert("abc".ops.substringAfterLast('c').contains("")) 53 | assert("".ops.substringAfterLast('d').contains("")) 54 | } 55 | ``` 56 | 57 | ## What's it 58 | 59 | [Apache Commons Lang](https://commons.apache.org/proper/commons-lang/) provides a host of helper utilities for the 60 | java.lang API, notably String manipulation methods, basic numerical methods, object reflection, concurrency, creation 61 | and serialization and System properties. Additionally it contains basic enhancements to java.util.Date and a series 62 | of utilities dedicated to help with building methods, such as hashCode, toString and equals. 63 | 64 | Commons Lang3 Bridge is a Scala bridge library. It supported use apache commons lang as scala style. 65 | 66 | ## StringUtils 67 | 68 | With Apache Commons StringUtils, we call functions as: 69 | 70 | ```java 71 | public void testDefaultIfEmpty_StringString() { 72 | assertEquals("NULL", StringUtils.defaultIfEmpty(null, "NULL")); 73 | assertEquals("NULL", StringUtils.defaultIfEmpty("", "NULL")); 74 | assertEquals("abc", StringUtils.defaultIfEmpty("abc", "NULL")); 75 | assertNull(StringUtils.getIfEmpty("", null)); 76 | // Tests compatibility for the API return type 77 | final String s = StringUtils.defaultIfEmpty("abc", "NULL"); 78 | assertEquals("abc", s); 79 | } 80 | ``` 81 | 82 | It's strong and power, null safe with all side conditions. 83 | 84 | ### Extensions 85 | 86 | And now, in scala, we add a extern field named `ops` for `String` and `Option[String]` type. 87 | Call the functions like OO style methods: 88 | 89 | ```scala 90 | import org.scalatest.funsuite.AnyFunSuite 91 | // import bridge extensions 92 | import commons.lang3.bridge.StringUtils.ops._ 93 | // ... 94 | class StringUtilsSpec extends AnyFunSuite { 95 | // .. 96 | test("test string default if empty with string") { 97 | assert(nullString.ops.defaultIfEmpty("NULL") == "NULL") 98 | assert(Some("").ops.defaultIfEmpty("NULL") == "NULL") 99 | assert("abc".ops.defaultIfEmpty(Some("NULL")) == "abc") 100 | assert("".ops.defaultIfEmpty(null) == null) 101 | // Tests compatibility for the API return type 102 | val s = "abc".ops.defaultIfEmpty("NULL") 103 | assert(s == "abc") 104 | } 105 | } 106 | ``` 107 | 108 | ### Null safe and TypeMapping 109 | 110 | All StringUtils functions in Apache Commons Lang3 is null safe. And the bridge bundle it as null and None safe. 111 | 112 | Specifically: 113 | - All functions return String may null that bridged to returns `Option[String]` 114 | - All args accepted a String may null that bridged to accepted `Option[String]` or String. 115 | You can choose any way as you wish. The bridged methods auto handle them! 116 | - When you see a source in document as `none`, It could be a `String` variable as null, or a 117 | `Option[String]` variable as None. In the bridge core, the powerful TypeMapping mechanism 118 | known howto convert it. 119 | - Some functions have varargs typed `String[]`. We bridged them as scala varargs `Seq[(String|Option[String])]*`. 120 | The bridge choice String or `Option[String]` what ever your pass in. But they must all `String` 121 | or all `Option[String]` same. Don't mix difference type in one varargs Seq. 122 | - Some functions have two String parameters. By the bridge you can call them pass etc. 123 | `str.ops.method(String, Option[String])` or `str.ops.method(Option[String], String)` or 124 | what ever combinators. Because the parameters have independents type definitions. 125 | - Some functions are accepted parameters as `CharSequnces`. By bridged you can pass 126 | `CharSequnces` or `Option[CharSequence]` as your wish. 127 | 128 | ### Adt Type Handle 129 | 130 | Many methods in bridge (They have written in `StringCommons.scala` source) with type parameters like: 131 | 132 | ```scala 133 | def removeEnd[R: Adt.Options2[*, String, Option[String]]](rmv: R): Option[String] = { 134 | val rmvStr = mapToStrOpt.input(rmv).orNull 135 | Option(Strings.removeEnd(strOrNull, rmvStr)) 136 | } 137 | ``` 138 | 139 | The type means a union type `String` or `Option[String]`. 140 | 141 | ### Limit 142 | 143 | Not all functions in StringUtils class were been bridged. 144 | 145 | We skip something like: 146 | - All deprecated functions 147 | - Something like `isNoneBlank`、`isAnyEmpty` and so on. They aren't oo style code 148 | have subject, predicate and objects. 149 | - All join method. Not only isn't OO style but also scala has powerful string function `mkString` . 150 | - Bridge support Union Type definition `(String | Option[String])`，but almost char args 151 | just bundled as `Char`, without `Option[Char]`. Because `Char` is a primitive type. 152 | - Some functions received char args as int type. The bridged bundled it as Char or Int. 153 | You need recognize it in scala. 154 | - In apache commons, when you pass null literal into functions, them returns result safely. 155 | But the bridged methods need now what's type of them. So pass a null `String` or None 156 | `Option[String]` this safe, `null` literal without type is *exception*. 157 | 158 | 159 | -------------------------------------------------------------------------------- /build.sbt: -------------------------------------------------------------------------------- 1 | val `modules/file` = file(".").getCanonicalFile / "modules" 2 | 3 | val bridge = project in `modules/file` / "bridge" 4 | 5 | bridge / name := "commons-lang3-bridge" 6 | 7 | Global / onChangedBuildSource := ReloadOnSourceChanges 8 | -------------------------------------------------------------------------------- /modules/bridge/build.sbt: -------------------------------------------------------------------------------- 1 | name := "commons-lang3-bridge" 2 | 3 | libraryDependencies ++= libScalax.`commons-lang3`.value.map(_ % Provided) 4 | libraryDependencies ++= libScalax.scalatest.value.map(_ % Test) 5 | libraryDependencies ++= libScalax.`kind-projector`.value 6 | libraryDependencies ++= libScalax.`simple-adt`.value 7 | 8 | CommonSettings.commonProjectSettings 9 | -------------------------------------------------------------------------------- /modules/bridge/src/main/scala/commons/lang3/bridge/StringUtils.scala: -------------------------------------------------------------------------------- 1 | package commons.lang3.bridge 2 | 3 | /** 封装 Apache Commons 的字符串工具函数，简化代码 4 | * 5 | * @author 6 | * liuxin 7 | * @version 1.0.0 8 | * @since 2022/08/22 9 | * 18:58 10 | */ 11 | object StringUtils { 12 | 13 | object ops { 14 | 15 | import net.scalax.simple.adt.{TypeAdt => Adt} 16 | 17 | implicit class StringOptExt[T: Adt.CoProducts2[*, String, Option[String]]](x: T) { 18 | val ops: StringCommons[T] = new StringCommons(x) 19 | } 20 | 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /modules/bridge/src/test/scala/commons/lang3/bridge/StringUtilsContainsSpec.scala: -------------------------------------------------------------------------------- 1 | package commons.lang3.bridge 2 | 3 | import org.scalatest.funsuite.AnyFunSuite 4 | 5 | import java.util.Locale 6 | 7 | /** TODO 8 | * 9 | * @author 10 | * mars 11 | * @version 1.0.0 12 | * @since 2022/08/28 13 | * 01:18 14 | */ 15 | class StringUtilsContainsSpec extends AnyFunSuite { 16 | val nullString: String = null 17 | val nullChars: Array[Char] = null 18 | val noneString: Option[String] = None 19 | 20 | import commons.lang3.bridge.StringUtils.ops._ 21 | 22 | /** Supplementary character U+20000 See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html 23 | */ 24 | private val CharU20000 = "\uD840\uDC00" 25 | 26 | /** Supplementary character U+20001 See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html 27 | */ 28 | private val CharU20001 = "\uD840\uDC01" 29 | 30 | /** Incomplete supplementary character U+20000, high surrogate only. See 31 | * http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html 32 | */ 33 | private val CharUSuppCharHigh = "\uDC00" 34 | 35 | /** Incomplete supplementary character U+20000, low surrogate only. See 36 | * http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html 37 | */ 38 | private val CharUSuppCharLow = "\uD840" 39 | 40 | test("test string contains char") { 41 | 42 | assert(!nullString.ops.contains(' ')) 43 | assert(!"".ops.contains(' ')) 44 | 45 | assert(!"".ops.contains(nullString)) 46 | assert(!nullString.ops.contains(nullString)) 47 | 48 | assert("abc".ops.contains('a')) 49 | assert("abc".ops.contains('b')) 50 | assert("abc".ops.contains('c')) 51 | assert(!"abc".ops.contains('z')) 52 | } 53 | 54 | test("test option string contains char ") { 55 | assert(!noneString.ops.contains(' ')) 56 | assert(!Some("").ops.contains(' ')) 57 | 58 | assert(!Some("").ops.contains(None)) 59 | 60 | assert(!None.ops.contains(None)) 61 | 62 | assert(Some("abc").ops.contains('a')) 63 | assert(Some("abc").ops.contains('b')) 64 | assert(Some("abc").ops.contains('c')) 65 | assert(!Some("abc").ops.contains('z')) 66 | 67 | } 68 | 69 | test("test string contains string") { 70 | assert(!nullString.ops.contains(nullString)) 71 | assert(!nullString.ops.contains("")) 72 | assert(!nullString.ops.contains("a")) 73 | assert(!"".ops.contains(nullString)) 74 | assert("".ops.contains("")) 75 | assert(!"".ops.contains("a")) 76 | assert("abc".ops.contains("a")) 77 | assert("abc".ops.contains("b")) 78 | assert("abc".ops.contains("c")) 79 | assert("abc".ops.contains(Some("abc"))) 80 | assert(!"abc".ops.contains("z")) 81 | } 82 | 83 | test("test Option[string] contains Option[string]") { 84 | val none: Option[String] = None 85 | assert(!none.ops.contains(None)) 86 | assert(!none.ops.contains("")) 87 | assert(!none.ops.contains(Some("a"))) 88 | assert(!Some("").ops.contains(None)) 89 | assert(Some("").ops.contains(Some(""))) 90 | assert(!Some("").ops.contains(Some("a"))) 91 | assert(Some("abc").ops.contains("a")) 92 | assert(Some("abc").ops.contains(Some("b"))) 93 | assert(Some("abc").ops.contains("c")) 94 | assert(Some("abc").ops.contains(Some("abc"))) 95 | assert(!Some("abc").ops.contains(Some("z"))) 96 | } 97 | 98 | test("test contains String with Bad Supplementary chars") { 99 | assert(!CharUSuppCharHigh.ops.contains(CharU20001)) 100 | assert(!CharUSuppCharLow.ops.contains(CharU20001)) 101 | assert(!CharU20001.ops.contains(CharUSuppCharHigh)) 102 | assert(CharU20001.indexOf(CharUSuppCharLow) == 0) 103 | assert(CharU20001.ops.contains(CharUSuppCharLow)) 104 | assert((CharU20001 + CharUSuppCharLow + "a").ops.contains("a")) 105 | assert((CharU20001 + CharUSuppCharHigh + "a").ops.contains("a")) 106 | } 107 | 108 | test("test contains Option[String] with Bad Supplementary chars") { 109 | assert(!Some(CharUSuppCharHigh).ops.contains(Some(CharU20001))) 110 | assert(!Some(CharUSuppCharLow).ops.contains(CharU20001)) 111 | assert(!Some(CharU20001).ops.contains(Some(CharUSuppCharHigh))) 112 | assert(CharU20001.indexOf(CharUSuppCharLow) == 0) 113 | assert(Some(CharU20001).ops.contains(CharUSuppCharLow)) 114 | assert(Some(CharU20001 + CharUSuppCharLow + "a").ops.contains(Some("a"))) 115 | assert(Some(CharU20001 + CharUSuppCharHigh + "a").ops.contains(Some("a"))) 116 | } 117 | 118 | test("test contains any string char array") { 119 | 120 | assert(!nullString.ops.containsAny(nullString)) 121 | assert(!nullString.ops.containsAny(new Array[Char](0): _*)) 122 | assert(!nullString.ops.containsAny('a', 'b')) 123 | 124 | assert(!"".ops.containsAny(nullString)) 125 | assert(!"".ops.containsAny(new Array[Char](0): _*)) 126 | assert(!"".ops.containsAny('a', 'b')) 127 | 128 | assert(!"zzabyycdxx".ops.containsAny(nullString)) 129 | assert(!"zzabyycdxx".ops.containsAny(new Array[Char](0): _*)) 130 | assert("zzabyycdxx".ops.containsAny('z', 'a')) 131 | assert("zzabyycdxx".ops.containsAny("b", "y")) 132 | assert("zzabyycdxx".ops.containsAny('z', 'y')) 133 | assert(!"ab".ops.containsAny(new Array[Char]('z'): _*)) 134 | } 135 | 136 | test("test option string contains any string char array") { 137 | 138 | assert(!nullString.ops.containsAny(nullString)) 139 | assert(!nullString.ops.containsAny(new Array[Char](0): _*)) 140 | assert(!nullString.ops.containsAny('a', 'b')) 141 | 142 | assert(!Some("").ops.containsAny(nullString)) 143 | assert(!Some("").ops.containsAny(new Array[Char](0): _*)) 144 | assert(!Some("").ops.containsAny('a', 'b')) 145 | 146 | assert(!Some("zzabyycdxx").ops.containsAny(nullString)) 147 | assert(!Some("zzabyycdxx").ops.containsAny(new Array[Char](0): _*)) 148 | assert(Some("zzabyycdxx").ops.containsAny("z", "a")) 149 | assert(Some("zzabyycdxx").ops.containsAny('b', 'y')) 150 | assert(Some("zzabyycdxx").ops.containsAny('z', 'y')) 151 | assert(!Some("ab").ops.containsAny(new Array[Char]('z'): _*)) 152 | } 153 | 154 | test("test contains any string or char array with bad supplement chars") { 155 | assert(!CharUSuppCharHigh.ops.containsAny(CharU20001.toCharArray: _*)) 156 | assert(!("abc" + CharUSuppCharHigh + "xyz").ops.containsAny(CharU20001.toCharArray: _*)) 157 | assert(CharUSuppCharLow.indexOf(CharU20001) == -1) 158 | assert(!Some(CharUSuppCharLow).ops.containsAny(CharU20001.toCharArray: _*)) 159 | assert(!CharU20001.ops.containsAny(CharUSuppCharHigh.toCharArray: _*)) 160 | assert(CharU20001.indexOf(CharUSuppCharLow) == 0) 161 | assert(Some(CharU20001).ops.containsAny(CharUSuppCharLow.toCharArray: _*)) 162 | } 163 | 164 | test("test contains any string or char array with supplement chars") { 165 | assert((CharU20000 + CharU20001).ops.containsAny(CharU20000.toCharArray: _*)) 166 | assert(("a" + CharU20000 + CharU20001).ops.containsAny("a".toCharArray: _*)) 167 | assert((CharU20000 + "a" + CharU20001).ops.containsAny("a".toCharArray: _*)) 168 | assert((CharU20000 + CharU20001 + "a").ops.containsAny("a".toCharArray: _*)) 169 | assert(Some(CharU20000 + CharU20001).ops.containsAny(CharU20001.toCharArray: _*)) 170 | assert(CharU20000.ops.containsAny(CharU20000.toCharArray: _*)) 171 | // Sanity check: 172 | assert(-1 == CharU20000.indexOf(CharU20001)) 173 | assert(0 == CharU20000.indexOf(CharU20001.charAt(0))) 174 | assert(-1 == CharU20000.indexOf(CharU20001.charAt(1))) 175 | // Test: 176 | assert(!Some(CharU20000).ops.containsAny(CharU20001.toCharArray: _*)) 177 | assert(!CharU20001.ops.containsAny(CharU20000.toCharArray: _*)) 178 | } 179 | 180 | test("test string contains any string") { 181 | assert(!nullString.ops.containsAny(nullString)) 182 | assert(!nullString.ops.containsAny("")) 183 | assert(!nullString.ops.containsAny("ab")) 184 | 185 | assert(!"".ops.containsAny(nullString)) 186 | assert(!"".ops.containsAny("")) 187 | assert(!"".ops.containsAny("")) 188 | assert(!"".ops.containsAny("ab")) 189 | 190 | assert(!"zzabyycdxx".ops.containsAny(nullString)) 191 | assert(!"zzabyycdxx".ops.containsAny("")) 192 | assert("zzabyycdxx".ops.containsAny("za")) 193 | assert("zzabyycdxx".ops.containsAny("by")) 194 | assert("zzabyycdxx".ops.containsAny("zy")) 195 | assert(!"ab".ops.containsAny("z")) 196 | 197 | } 198 | 199 | test("test option string contains any string") { 200 | assert(!noneString.ops.containsAny(nullString)) 201 | assert(!noneString.ops.containsAny("")) 202 | assert(!noneString.ops.containsAny("ab")) 203 | 204 | assert(!Some("").ops.containsAny(nullString)) 205 | assert(!Some("").ops.containsAny("")) 206 | assert(!Some("").ops.containsAny("ab")) 207 | 208 | assert(!Some("zzabyycdxx").ops.containsAny(nullString)) 209 | assert(!Some("zzabyycdxx").ops.containsAny("")) 210 | assert(Some("zzabyycdxx").ops.containsAny(Some("za"))) 211 | assert(Some("zzabyycdxx").ops.containsAny("by")) 212 | assert(Some("zzabyycdxx").ops.containsAny("zy")) 213 | assert(!Some("ab").ops.containsAny("z")) 214 | } 215 | 216 | test("test string contains any string array") { 217 | assert(!nullString.ops.containsAny(nullString)) 218 | assert(!nullString.ops.containsAny(new Array[String](0): _*)) 219 | assert(!noneString.ops.containsAny(Array[String]("hello"): _*)) 220 | assert(!Some("").ops.containsAny(noneString)) 221 | assert(!"".ops.containsAny(new Array[String](0): _*)) 222 | assert(!Some("").ops.containsAny(Array[String]("hello"): _*)) 223 | assert(!Some("hello, goodbye").ops.containsAny(noneString)) 224 | assert(!"hello, goodbye".ops.containsAny(new Array[String](0): _*)) 225 | assert("hello, goodbye".ops.containsAny(Array[String]("hello", "goodbye"): _*)) 226 | assert(Some("hello, goodbye").ops.containsAny(Array[String]("hello", "Goodbye"): _*)) 227 | assert(!"hello, goodbye".ops.containsAny(Array[String]("Hello", "Goodbye"): _*)) 228 | assert(!Some("hello, goodbye").ops.containsAny(Array[String]("Hello", null): _*)) 229 | assert(!"hello, null".ops.containsAny(Array[String]("Hello", null): _*)) 230 | // Javadoc examples: 231 | assert("abcd".ops.containsAny("ab", null)) 232 | assert(Some("abcd").ops.containsAny("ab", "cd")) 233 | assert("abc".ops.containsAny("d", "abc")) 234 | } 235 | 236 | test("test string contains any ignore case string array") { 237 | assert(!(nullString.ops.containsAnyIgnoreCase(nullString))) 238 | assert(!nullString.ops.containsAnyIgnoreCase(new Array[String](0): _*)) 239 | assert(!noneString.ops.containsAnyIgnoreCase(Array[String]("hello"): _*)) 240 | assert(!"".ops.containsAnyIgnoreCase(nullString)) 241 | assert(!Some("").ops.containsAnyIgnoreCase(new Array[String](0): _*)) 242 | assert(!Some("").ops.containsAnyIgnoreCase(Array[String]("hello"): _*)) 243 | assert(!Some("hello, goodbye").ops.containsAnyIgnoreCase(nullString)) 244 | assert(!"hello, goodbye".ops.containsAnyIgnoreCase(new Array[String](0): _*)) 245 | assert("hello, goodbye".ops.containsAnyIgnoreCase(Array[String]("hello", "goodbye"): _*)) 246 | assert("hello, goodbye".ops.containsAnyIgnoreCase(Array[String]("hello", "Goodbye"): _*)) 247 | assert(Some("hello, goodbye").ops.containsAnyIgnoreCase(Array[String]("Hello", "Goodbye"): _*)) 248 | assert("hello, goodbye".ops.containsAnyIgnoreCase(Array[String]("Hello", null): _*)) 249 | assert("hello, null".ops.containsAnyIgnoreCase(Array[String]("Hello", null): _*)) 250 | // Javadoc examples: 251 | assert("abcd".ops.containsAnyIgnoreCase("ab", null)) 252 | assert(Some("abcd").ops.containsAnyIgnoreCase("ab", "cd")) 253 | assert("abc".ops.containsAnyIgnoreCase("d", "abc")) 254 | } 255 | 256 | test("test string contains any string with bad supplementary chars") { 257 | assert(!CharUSuppCharHigh.ops.containsAny(CharU20001)) 258 | assert(-1 == CharUSuppCharLow.indexOf(CharU20001)) 259 | assert(!Some(CharUSuppCharLow).ops.containsAny(CharU20001)) 260 | assert(!CharU20001.ops.containsAny(CharUSuppCharHigh)) 261 | assert(0 == CharU20001.indexOf(CharUSuppCharLow)) 262 | assert(CharU20001.ops.containsAnyIgnoreCase(CharUSuppCharLow)) 263 | } 264 | 265 | test("test string contains any string with supplementary chars") { 266 | assert(Some(CharU20000 + CharU20001).ops.containsAny(CharU20000)) 267 | assert((CharU20000 + CharU20001).ops.containsAny(Some(CharU20001))) 268 | assert(CharU20000.ops.containsAny(CharU20000)) 269 | // Sanity check: 270 | assert(-1 == CharU20000.indexOf(CharU20001)) 271 | assert(0 == CharU20000.indexOf(CharU20001.charAt(0))) 272 | assert(-1 == CharU20000.indexOf(CharU20001.charAt(1))) 273 | // Test: 274 | assert(!CharU20000.ops.containsAny(CharU20001)) 275 | assert(!CharU20001.ops.containsAny(CharU20000)) 276 | } 277 | 278 | test("test string contains ignore case locale independence") { 279 | val locales = Array(Locale.ENGLISH, new Locale("tr"), Locale.GERMAN) 280 | 281 | val tdata = Array(Array("i", "I"), Array("I", "i"), Array("\u03C2", "\u03C3"), Array("\u03A3", "\u03C2"), Array("\u03A3", "\u03C3")) 282 | 283 | val fdata = Array(Array("\u00DF", "SS")) 284 | 285 | for (testLocale <- locales) { 286 | Locale.setDefault(testLocale) 287 | for (j <- tdata.indices) { 288 | assert( 289 | tdata(j)(0).ops.containsIgnoreCase(tdata(j)(1)), 290 | Locale.getDefault.toString + ": " + j + " " + tdata(j)(0) + " " + tdata(j)(1) 291 | ) 292 | } 293 | for (j <- fdata.indices) { 294 | assert( 295 | !fdata(j)(0).ops.containsIgnoreCase(fdata(j)(1)), 296 | Locale.getDefault.toString + ": " + j + " " + fdata(j)(0) + " " + fdata(j)(1) 297 | ) 298 | } 299 | } 300 | } 301 | 302 | test("test string contains ignore case string") { 303 | assert(!nullString.ops.containsIgnoreCase(nullString)) 304 | 305 | // Null tests 306 | assert(!noneString.ops.containsIgnoreCase("")) 307 | assert(!noneString.ops.containsIgnoreCase("a")) 308 | assert(!nullString.ops.containsIgnoreCase(Some("abc"))) 309 | 310 | assert(!"".ops.containsIgnoreCase(nullString)) 311 | assert(!Some("a").ops.containsIgnoreCase(nullString)) 312 | assert(!"abc".ops.containsIgnoreCase(noneString)) 313 | 314 | // Match len = 0 315 | assert("".ops.containsIgnoreCase("")) 316 | assert(Some("a").ops.containsIgnoreCase(Some(""))) 317 | assert("abc".ops.containsIgnoreCase("")) 318 | 319 | // Match len = 1 320 | assert(!"".ops.containsIgnoreCase(Some("a"))) 321 | assert(Some("a").ops.containsIgnoreCase("a")) 322 | assert("abc".ops.containsIgnoreCase("a")) 323 | assert(!Some("").ops.containsIgnoreCase("A")) 324 | assert("a".ops.containsIgnoreCase("A")) 325 | assert("abc".ops.containsIgnoreCase("A")) 326 | 327 | // Match len > 1 328 | assert(!"".ops.containsIgnoreCase("abc")) 329 | assert(!"a".ops.containsIgnoreCase(Some("abc"))) 330 | assert(Some("xabcz").ops.containsIgnoreCase("abc")) 331 | assert(!"".ops.containsIgnoreCase(Some("ABC"))) 332 | assert(!"a".ops.containsIgnoreCase("ABC")) 333 | assert("xabcz".ops.containsIgnoreCase("ABC")) 334 | } 335 | 336 | test("test string contains none char array") { 337 | val str1 = "a" 338 | val str2 = "b" 339 | val str3 = "ab." 340 | val chars1 = Array('b') 341 | val chars2 = Array('.') 342 | val chars3 = Array('c', 'd') 343 | val emptyChars = new Array[Char](0) 344 | val noc: Option[Char] = None 345 | 346 | assert(nullString.ops.containsNone(noc)) 347 | assert("".ops.containsNone(noc)) 348 | assert(nullString.ops.containsNone(emptyChars: _*)) 349 | assert(Some(str1).ops.containsNone(emptyChars: _*)) 350 | assert("".ops.containsNone(emptyChars: _*)) 351 | assert("".ops.containsNone(chars1: _*)) 352 | assert(Some(str1).ops.containsNone(chars1: _*)) 353 | assert(str1.ops.containsNone(chars2: _*)) 354 | assert(str1.ops.containsNone(chars3: _*)) 355 | assert(!str2.ops.containsNone(chars1: _*)) 356 | assert(str2.ops.containsNone(chars2: _*)) 357 | assert(str2.ops.containsNone(chars3: _*)) 358 | assert(!Some(str3).ops.containsNone(chars1: _*)) 359 | assert(!str3.ops.containsNone(chars2: _*)) 360 | assert(str3.ops.containsNone(chars3: _*)) 361 | } 362 | 363 | test("test string contains none of char array with bad supplementary chars") { 364 | assert(CharUSuppCharHigh.ops.containsNone(CharU20001.toCharArray: _*)) 365 | assert(-1 == CharUSuppCharLow.indexOf(CharU20001)) 366 | assert(CharUSuppCharLow.ops.containsNone(CharU20001.toCharArray: _*)) 367 | assert(-1 == CharU20001.indexOf(CharUSuppCharHigh)) 368 | assert(Some(CharU20001).ops.containsNone(CharUSuppCharHigh.toCharArray: _*)) 369 | assert(0 == CharU20001.indexOf(CharUSuppCharLow)) 370 | assert(!CharU20001.ops.containsNone(CharUSuppCharLow.toCharArray.map(Some(_)): _*)) 371 | } 372 | 373 | test("test string contains none of char array with supplementary chars") { 374 | assert(!(CharU20000 + CharU20001).ops.containsNone(CharU20000.toCharArray: _*)) 375 | assert(!Some(CharU20000 + CharU20001).ops.containsNone(CharU20001.toCharArray: _*)) 376 | assert(!CharU20000.ops.containsNone(CharU20000.toCharArray: _*)) 377 | // Sanity check: 378 | assert(-1 == CharU20000.indexOf(CharU20001)) 379 | assert(0 == CharU20000.indexOf(CharU20001.charAt(0))) 380 | assert(-1 == CharU20000.indexOf(CharU20001.charAt(1))) 381 | // Test: 382 | assert(CharU20000.ops.containsNone(CharU20001.toCharArray: _*)) 383 | assert(CharU20001.ops.containsNone(CharU20000.toCharArray.map(Some(_)): _*)) 384 | } 385 | 386 | test("test string contains none string") { 387 | val str1 = "a" 388 | val str2 = "b" 389 | val str3 = "ab." 390 | val chars1 = "b" 391 | val chars2 = "." 392 | val chars3 = "cd" 393 | assert(nullString.ops.containsNone(nullString)) 394 | assert(Some("").ops.containsNone(nullString)) 395 | assert(nullString.ops.containsNone("")) 396 | assert(Some(str1).ops.containsNone("")) 397 | assert(Some("").ops.containsNone(Some(""))) 398 | assert("".ops.containsNone(Some(chars1))) 399 | assert(str1.ops.containsNone(chars1)) 400 | assert(str1.ops.containsNone(chars2)) 401 | assert(str1.ops.containsNone(chars3)) 402 | assert(!Some(str2).ops.containsNone(chars1)) 403 | assert(Some(str2).ops.containsNone(Some(chars2))) 404 | assert(str2.ops.containsNone(chars3)) 405 | assert(!str3.ops.containsNone(chars1)) 406 | assert(!str3.ops.containsNone(Some(chars2))) 407 | assert(str3.ops.containsNone(chars3)) 408 | } 409 | 410 | test("test string contains none string with bad supplementary chars") { 411 | // Test edge case: 1/2 of a (broken) supplementary char 412 | assert(CharUSuppCharHigh.ops.containsNone(CharU20001)) 413 | assert(-1 == CharUSuppCharLow.indexOf(CharU20001)) 414 | assert(CharUSuppCharLow.ops.containsNone(Some(CharU20001))) 415 | assert(-1 == CharU20001.indexOf(CharUSuppCharHigh)) 416 | assert(Some(CharU20001).ops.containsNone(CharUSuppCharHigh)) 417 | assert(0 == CharU20001.indexOf(CharUSuppCharLow)) 418 | assert(!CharU20001.ops.containsNone(CharUSuppCharLow)) 419 | } 420 | 421 | test("test string contains none string with supplementary chars") { 422 | assert(!(CharU20000 + CharU20001).ops.containsNone(CharU20000)) 423 | assert(!Some(CharU20000 + CharU20001).ops.containsNone(Some(CharU20001))) 424 | assert(!CharU20000.ops.containsNone(CharU20000)) 425 | // Sanity check: 426 | assert(-1 == CharU20000.indexOf(CharU20001)) 427 | assert(0 == CharU20000.indexOf(CharU20001.charAt(0))) 428 | assert(-1 == CharU20000.indexOf(CharU20001.charAt(1))) 429 | // Test: 430 | assert(CharU20000.ops.containsNone(CharU20001)) 431 | assert(CharU20001.ops.containsNone(CharU20000)) 432 | } 433 | 434 | test("test string contains only char array") { 435 | val str1 = "a" 436 | val str2 = "b" 437 | val str3 = "ab" 438 | val chars1 = Array('b') 439 | val chars2 = Array('a') 440 | val chars3 = Array('a', 'b') 441 | val emptyChars = new Array[Char](0) 442 | assert(!nullString.ops.containsOnly(noneString)) 443 | assert(!Some("").ops.containsOnly(nullString)) 444 | assert(!nullString.ops.containsOnly(emptyChars: _*)) 445 | assert(!str1.ops.containsOnly(emptyChars: _*)) 446 | assert(Some("").ops.containsOnly(emptyChars: _*)) 447 | assert("".ops.containsOnly(chars1: _*)) 448 | assert(!Some(str1).ops.containsOnly(chars1: _*)) 449 | assert(str1.ops.containsOnly(chars2: _*)) 450 | assert(str1.ops.containsOnly(chars3: _*)) 451 | assert(str2.ops.containsOnly(chars1: _*)) 452 | assert(!Some(str2).ops.containsOnly(chars2.map(Option(_)): _*)) 453 | assert(str2.ops.containsOnly(chars3.map(Option(_)): _*)) 454 | assert(!str3.ops.containsOnly(chars1: _*)) 455 | assert(!str3.ops.containsOnly(chars2: _*)) 456 | assert(str3.ops.containsOnly(chars3: _*)) 457 | } 458 | 459 | test("test string contains only string") { 460 | val str1 = "a" 461 | val str2 = "b" 462 | val str3 = "ab" 463 | val chars1 = "b" 464 | val chars2 = "a" 465 | val chars3 = "ab" 466 | assert(!noneString.ops.containsOnly(noneString)) 467 | assert(!Some("").ops.containsOnly(nullString)) 468 | assert(!noneString.ops.containsOnly("")) 469 | assert(!Some(str1).ops.containsOnly(Some(""))) 470 | assert("".ops.containsOnly("")) 471 | assert("".ops.containsOnly(chars1)) 472 | assert(!str1.ops.containsOnly(Some(chars1))) 473 | assert(str1.ops.containsOnly(chars2)) 474 | assert(str1.ops.containsOnly(chars3)) 475 | assert(str2.ops.containsOnly(chars1)) 476 | assert(!str2.ops.containsOnly(chars2)) 477 | assert(str2.ops.containsOnly(chars3)) 478 | assert(!str3.ops.containsOnly(chars1)) 479 | assert(!Some(str3).ops.containsOnly(Some(chars2))) 480 | assert(str3.ops.containsOnly(chars3)) 481 | } 482 | 483 | test("test string contains whitespace") { 484 | assert(!"".ops.containsWhitespace) 485 | assert(Some(" ").ops.containsWhitespace) 486 | assert(!"a".ops.containsWhitespace) 487 | assert("a ".ops.containsWhitespace) 488 | assert(" a".ops.containsWhitespace) 489 | assert(Some("a\t").ops.containsWhitespace) 490 | assert("\n".ops.containsWhitespace) 491 | } 492 | } 493 | -------------------------------------------------------------------------------- /modules/bridge/src/test/scala/commons/lang3/bridge/StringUtilsEqualsIndexOfSpec.scala: -------------------------------------------------------------------------------- 1 | package commons.lang3.bridge 2 | 3 | import commons.lang3.bridge.StringUtils.ops._ 4 | import org.scalatest.funsuite.AnyFunSuite 5 | 6 | import java.lang 7 | import java.nio.CharBuffer 8 | 9 | /** TODO 10 | * 11 | * @author 12 | * mars 13 | * @version 1.0.0 14 | * @since 2022/09/10 15 | * 21:25 16 | */ 17 | class StringUtilsEqualsIndexOfSpec extends AnyFunSuite { 18 | import StringUtilsSpec.{noneString, nullString} 19 | 20 | private val BAR = "bar" 21 | 22 | /** Supplementary character U+20000 See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html 23 | */ 24 | private val CharU20000 = "\uD840\uDC00" 25 | 26 | /** Supplementary character U+20001 See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html 27 | */ 28 | private val CharU20001 = "\uD840\uDC01" 29 | 30 | private val FOO = "foo" 31 | 32 | private val FOOBAR = "foobar" 33 | 34 | private val FOOBAR_SUB_ARRAY = Array[String]("ob", "ba") 35 | 36 | test("string index of") { 37 | assert(noneString.ops.indexOf(nullString) == -1) 38 | assert("".ops.indexOf(' ') == -1) 39 | assert("aabaabaa".ops.indexOf('a') == 0) 40 | assert("aabaabaa".ops.indexOf('b') == 2) 41 | } 42 | 43 | import org.apache.commons.lang3.{StringUtils => Strings} 44 | test("test string index of char start index") { 45 | assert(-1 == noneString.ops.indexOf(' ', 0)) 46 | assert(-1 == nullString.ops.indexOf(' ', -1)) 47 | assert(-1 == "".ops.indexOf(' ', 0)) 48 | assert(-1 == Some("").ops.indexOf(' ', -1)) 49 | assert(0 == "aabaabaa".ops.indexOf('a', 0)) 50 | assert(2 == "aabaabaa".ops.indexOf('b', 0)) 51 | assert(5 == "aabaabaa".ops.indexOf('b', 3)) 52 | assert(-1 == "aabaabaa".ops.indexOf('b', 9)) 53 | assert(2 == "aabaabaa".ops.indexOf('b', -1)) 54 | } 55 | 56 | test("test string index of string") { 57 | assert(-1 == noneString.ops.indexOf(nullString)) 58 | assert(-1 == "".ops.indexOf(noneString)) 59 | assert(0 == Some("").ops.indexOf("")) 60 | assert(0 == Some("aabaabaa").ops.indexOf("a")) 61 | assert(2 == "aabaabaa".ops.indexOf(Some("b"))) 62 | assert(1 == "aabaabaa".ops.indexOf("ab")) 63 | assert(0 == "aabaabaa".ops.indexOf("")) 64 | } 65 | 66 | test("test string index of string and start position") { 67 | assert(-1 == nullString.ops.indexOf(noneString, 0)) 68 | assert(-1 == noneString.ops.indexOf(nullString, -1)) 69 | assert(-1 == nullString.ops.indexOf("", 0)) 70 | assert(-1 == nullString.ops.indexOf("", -1)) 71 | assert(-1 == Some("").ops.indexOf(nullString, 0)) 72 | assert(-1 == "".ops.indexOf(nullString, -1)) 73 | assert(0 == "".ops.indexOf("", 0)) 74 | assert(0 == "".ops.indexOf("", -1)) 75 | assert(0 == Some("").ops.indexOf("", 9)) 76 | assert(0 == "abc".ops.indexOf(Some(""), 0)) 77 | assert(0 == "abc".ops.indexOf("", -1)) 78 | assert(3 == "abc".ops.indexOf("", 9)) 79 | assert(3 == "abc".ops.indexOf("", 3)) 80 | assert(0 == "aabaabaa".ops.indexOf("a", 0)) 81 | assert(2 == "aabaabaa".ops.indexOf("b", 0)) 82 | assert(1 == "aabaabaa".ops.indexOf("ab", 0)) 83 | assert(5 == "aabaabaa".ops.indexOf("b", 3)) 84 | assert(-1 == "aabaabaa".ops.indexOf("b", 9)) 85 | assert(2 == "aabaabaa".ops.indexOf("b", -1)) 86 | assert(2 == "aabaabaa".ops.indexOf(Some(""), 2)) 87 | 88 | // Test that startIndex works correctly, i.e. cannot match before startIndex 89 | assert(7 == "12345678".ops.indexOf("8", 5)) 90 | assert(7 == "12345678".ops.indexOf(Some("8"), 6)) 91 | assert(7 == "12345678".ops.indexOf("8", 7)) // 7 is last index 92 | 93 | assert(-1 == Some("12345678").ops.indexOf("8", 8)) 94 | 95 | } 96 | 97 | test("test string index of any char") { 98 | assert(-1 == noneString.ops.indexOfAny(null.asInstanceOf[Array[Char]]: _*)) 99 | assert(-1 == noneString.ops.indexOfAny(new Array[Char](0): _*)) 100 | assert(-1 == nullString.ops.indexOfAny('a', 'b')) 101 | 102 | assert(-1 == "".ops.indexOfAny(null.asInstanceOf[Array[Char]]: _*)) 103 | assert(-1 == "".ops.indexOfAny(new Array[Char](0): _*)) 104 | assert(-1 == Some("").ops.indexOfAny('a', 'b')) 105 | 106 | assert(-1 == "zzabyycdxx".ops.indexOfAny(null.asInstanceOf[Array[Char]]: _*)) 107 | assert(-1 == Some("zzabyycdxx").ops.indexOfAny(new Array[Char](0): _*)) 108 | assert(0 == "zzabyycdxx".ops.indexOfAny('z', 'a')) 109 | assert(3 == "zzabyycdxx".ops.indexOfAny('b', 'y')) 110 | assert(-1 == "ab".ops.indexOfAny('z')) 111 | } 112 | 113 | test("test string index of any chars with supplementary chars") { 114 | assert(0 == (CharU20000 + CharU20001).ops.indexOfAny(CharU20000.toCharArray: _*)) 115 | assert(2 == Some(CharU20000 + CharU20001).ops.indexOfAny(CharU20001.toCharArray: _*)) 116 | assert(0 == CharU20000.ops.indexOfAny(CharU20000.toCharArray: _*)) 117 | assert(-1 == CharU20000.ops.indexOfAny(CharU20001.toCharArray: _*)) 118 | } 119 | 120 | test("test string index of any bug string") { 121 | assert(-1 == nullString.ops.indexOfAnyBut(nullString)) 122 | assert(-1 == noneString.ops.indexOfAnyBut("")) 123 | assert(-1 == nullString.ops.indexOfAnyBut(Some("ab"))) 124 | 125 | assert(-1 == Some("").ops.indexOfAnyBut(noneString)) 126 | assert(-1 == "".ops.indexOfAnyBut("")) 127 | assert(-1 == "".ops.indexOfAnyBut(Some("ab"))) 128 | 129 | assert(-1 == "zzabyycdxx".ops.indexOfAnyBut(noneString)) 130 | assert(-1 == Some("zzabyycdxx").ops.indexOfAnyBut("")) 131 | assert(3 == "zzabyycdxx".ops.indexOfAnyBut("za")) 132 | assert(0 == "zzabyycdxx".ops.indexOfAnyBut(Some("by"))) 133 | assert(0 == "ab".ops.indexOfAnyBut("z")) 134 | } 135 | 136 | test("test string index of any but string with supplement chars") { 137 | assert(2 == Some(CharU20000 + CharU20001).ops.indexOfAnyBut(CharU20000)) 138 | assert(0 == (CharU20000 + CharU20001).ops.indexOfAnyBut(Some(CharU20001))) 139 | assert(-1 == CharU20000.ops.indexOfAnyBut(CharU20000)) 140 | assert(0 == CharU20000.ops.indexOfAnyBut(CharU20001)) 141 | } 142 | 143 | test("test string index of ignore case") { 144 | assert(-1 == noneString.ops.indexOfIgnoreCase(nullString)) 145 | assert(-1 == nullString.ops.indexOfIgnoreCase(Some(""))) 146 | assert(-1 == "".ops.indexOfIgnoreCase(noneString)) 147 | assert(0 == Some("").ops.indexOfIgnoreCase("")) 148 | assert(0 == "aabaabaa".ops.indexOfIgnoreCase("a")) 149 | assert(0 == "aabaabaa".ops.indexOfIgnoreCase("A")) 150 | assert(2 == Some("aabaabaa").ops.indexOfIgnoreCase("b")) 151 | assert(2 == "aabaabaa".ops.indexOfIgnoreCase("B")) 152 | assert(1 == "aabaabaa".ops.indexOfIgnoreCase(Some("ab"))) 153 | assert(1 == "aabaabaa".ops.indexOfIgnoreCase("AB")) 154 | assert(0 == "aabaabaa".ops.indexOfIgnoreCase("")) 155 | } 156 | 157 | test("test string index of ignore case with start position") { 158 | assert(1 == "aabaabaa".ops.indexOfIgnoreCase("AB", -1)) 159 | assert(1 == Some("aabaabaa").ops.indexOfIgnoreCase("AB", 0)) 160 | assert(1 == "aabaabaa".ops.indexOfIgnoreCase("AB", 1)) 161 | assert(4 == "aabaabaa".ops.indexOfIgnoreCase("AB", 2)) 162 | assert(4 == "aabaabaa".ops.indexOfIgnoreCase(Some("AB"), 3)) 163 | assert(4 == "aabaabaa".ops.indexOfIgnoreCase("AB", 4)) 164 | assert(-1 == "aabaabaa".ops.indexOfIgnoreCase("AB", 5)) 165 | assert(-1 == "aabaabaa".ops.indexOfIgnoreCase("AB", 6)) 166 | assert(-1 == ("aabaabaa").ops.indexOfIgnoreCase("AB", 7)) 167 | assert(-1 == "aabaabaa".ops.indexOfIgnoreCase("AB", 8)) 168 | assert(1 == "aab".ops.indexOfIgnoreCase("AB", 1)) 169 | assert(5 == "aabaabaa".ops.indexOfIgnoreCase("", 5)) 170 | assert(-1 == "ab".ops.indexOfIgnoreCase("AAB", 0)) 171 | assert(-1 == "aab".ops.indexOfIgnoreCase("AAB", 1)) 172 | assert(-1 == "abc".ops.indexOfIgnoreCase("", 9)) 173 | } 174 | 175 | test("test string last index of char") { 176 | assert(-1 == noneString.ops.lastIndexOf(' ')) 177 | assert(-1 == Some("").ops.lastIndexOf(' ')) 178 | assert(7 == "aabaabaa".ops.lastIndexOf('a')) 179 | assert(5 == Some("aabaabaa").ops.lastIndexOf('b')) 180 | } 181 | 182 | test("test string last index of char from start position") { 183 | assert(-1 == noneString.ops.lastIndexOf(' ', 0)) 184 | assert(-1 == nullString.ops.lastIndexOf(' ', -1)) 185 | assert(-1 == "".ops.lastIndexOf(' ', 0)) 186 | assert(-1 == Some("").ops.lastIndexOf(' ', -1)) 187 | assert(7 == "aabaabaa".ops.lastIndexOf('a', 8)) 188 | assert(5 == "aabaabaa".ops.lastIndexOf('b', 8)) 189 | assert(2 == "aabaabaa".ops.lastIndexOf('b', 3)) 190 | assert(5 == Some("aabaabaa").ops.lastIndexOf('b', 9)) 191 | assert(-1 == "aabaabaa".ops.lastIndexOf('b', -1)) 192 | assert(0 == "aabaabaa".ops.lastIndexOf('a', 0)) 193 | 194 | // LANG-1300 addition test 195 | val CODE_POINT = 0x2070e 196 | var builder: java.lang.StringBuilder = new lang.StringBuilder 197 | builder.appendCodePoint(CODE_POINT) 198 | assert(0 == builder.toString.ops.lastIndexOf(CODE_POINT, 0)) 199 | builder.appendCodePoint(CODE_POINT) 200 | assert(0 == builder.toString.ops.lastIndexOf(CODE_POINT, 0)) 201 | assert(0 == builder.toString.ops.lastIndexOf(CODE_POINT, 1)) 202 | assert(2 == builder.toString.ops.lastIndexOf(CODE_POINT, 2)) 203 | 204 | builder.append("aaaaa") 205 | assert(2 == builder.toString.ops.lastIndexOf(CODE_POINT, 4)) 206 | // inner branch on the supplementary character block 207 | val tmp: Array[Char] = Array(55361.toChar) 208 | builder = new lang.StringBuilder() 209 | builder.append(tmp) 210 | assert(-1 == builder.toString.ops.lastIndexOf(CODE_POINT, 0)) 211 | builder.appendCodePoint(CODE_POINT) 212 | assert(-1 == builder.toString.ops.lastIndexOf(CODE_POINT, 0)) 213 | assert(1 == builder.toString.ops.lastIndexOf(CODE_POINT, 1)) 214 | assert(-1 == builder.toString.ops.lastIndexOf(CODE_POINT, 0)) 215 | assert(1 == builder.toString.ops.lastIndexOf(CODE_POINT, 1)) 216 | assert(-1 == CharBuffer.wrap("[%{.c.0rro").toString.ops.lastIndexOf(-1738.toChar, 982)) 217 | 218 | } 219 | 220 | test("test string last index of string") { 221 | assert(-1 == noneString.ops.lastIndexOf(nullString)) 222 | assert(-1 == "".ops.lastIndexOf(noneString)) 223 | assert(-1 == "".ops.lastIndexOf("a")) 224 | assert(0 == Some("").ops.lastIndexOf("")) 225 | assert(8 == "aabaabaa".ops.lastIndexOf("")) 226 | assert(7 == "aabaabaa".ops.lastIndexOf(Some("a"))) 227 | assert(5 == "aabaabaa".ops.lastIndexOf("b")) 228 | assert(4 == "aabaabaa".ops.lastIndexOf("ab")) 229 | 230 | } 231 | 232 | test("test last index of string with start position") { 233 | assert(-1 == noneString.ops.lastIndexOf(nullString, 0)) 234 | assert(-1 == nullString.ops.lastIndexOf(noneString, -1)) 235 | assert(-1 == noneString.ops.lastIndexOf("", 0)) 236 | assert(-1 == nullString.ops.lastIndexOf(Some(""), -1)) 237 | assert(-1 == "".ops.lastIndexOf(nullString, 0)) 238 | assert(-1 == "".ops.lastIndexOf(noneString, -1)) 239 | assert(0 == Some("").ops.lastIndexOf(Some(""), 0)) 240 | assert(-1 == "".ops.lastIndexOf("", -1)) 241 | assert(0 == "".ops.lastIndexOf("", 9)) 242 | assert(0 == "abc".ops.lastIndexOf("", 0)) 243 | assert(-1 == "abc".ops.lastIndexOf("", -1)) 244 | assert(3 == "abc".ops.lastIndexOf("", 9)) 245 | assert(7 == "aabaabaa".ops.lastIndexOf("a", 8)) 246 | assert(5 == "aabaabaa".ops.lastIndexOf("b", 8)) 247 | assert(4 == "aabaabaa".ops.lastIndexOf("ab", 8)) 248 | assert(2 == "aabaabaa".ops.lastIndexOf("b", 3)) 249 | assert(5 == "aabaabaa".ops.lastIndexOf("b", 9)) 250 | assert(-1 == "aabaabaa".ops.lastIndexOf("b", -1)) 251 | assert(-1 == "aabaabaa".ops.lastIndexOf("b", 0)) 252 | assert(0 == "aabaabaa".ops.lastIndexOf("a", 0)) 253 | assert(-1 == "aabaabaa".ops.lastIndexOf("a", -1)) 254 | 255 | // Test that fromIndex works correctly, i.e. cannot match after fromIndex 256 | assert(7 == Some("12345678").ops.lastIndexOf("8", 9)) 257 | assert(7 == "12345678".ops.lastIndexOf("8", 8)) 258 | assert(7 == "12345678".ops.lastIndexOf("8", 7)) // 7 is last index 259 | 260 | assert(-1 == "12345678".ops.lastIndexOf("8", 6)) 261 | 262 | assert(-1 == "aabaabaa".ops.lastIndexOf("b", 1)) 263 | assert(2 == "aabaabaa".ops.lastIndexOf("b", 2)) 264 | assert(2 == "aabaabaa".ops.lastIndexOf(Some("ba"), 2)) 265 | assert(2 == "aabaabaa".ops.lastIndexOf("ba", 3)) 266 | 267 | } 268 | 269 | test("test string last index of any strings") { 270 | assert(-1 == noneString.ops.lastIndexOfAny(null.asInstanceOf[CharSequence])) // test both types of ... 271 | 272 | assert(-1 == noneString.ops.lastIndexOfAny(null.asInstanceOf[Array[CharSequence]]: _*)) // ... varargs invocation 273 | 274 | assert(-1 == noneString.ops.lastIndexOfAny(FOOBAR_SUB_ARRAY: _*)) 275 | assert(-1 == FOOBAR.ops.lastIndexOfAny(null.asInstanceOf[CharSequence])) 276 | assert(-1 == Some(FOOBAR).ops.lastIndexOfAny(null.asInstanceOf[Array[CharSequence]]: _*)) 277 | 278 | assert(3 == FOOBAR.ops.lastIndexOfAny(FOOBAR_SUB_ARRAY: _*)) 279 | assert(-1 == FOOBAR.ops.lastIndexOfAny(new Array[String](0): _*)) 280 | assert(-1 == noneString.ops.lastIndexOfAny(new Array[String](0): _*)) 281 | assert(-1 == Some("").ops.lastIndexOfAny(new Array[Option[String]](0): _*)) 282 | assert(-1 == FOOBAR.ops.lastIndexOfAny(Array[String]("llll"): _*)) 283 | assert(6 == FOOBAR.ops.lastIndexOfAny(Array[String](""): _*)) 284 | assert(0 == "".ops.lastIndexOfAny(Array[String](""): _*)) 285 | assert(-1 == "".ops.lastIndexOfAny(Array[String]("a"): _*)) 286 | assert(-1 == "".ops.lastIndexOfAny(Array[String](null): _*)) 287 | assert(-1 == FOOBAR.ops.lastIndexOfAny(Array[String](null): _*)) 288 | assert(-1 == noneString.ops.lastIndexOfAny(Array[String](null): _*)) 289 | } 290 | 291 | test("test string last index of ignore case") { 292 | assert(-1 == noneString.ops.lastIndexOfIgnoreCase(nullString)) 293 | assert(-1 == Some("").ops.lastIndexOfIgnoreCase(noneString)) 294 | assert(-1 == nullString.ops.lastIndexOfIgnoreCase("")) 295 | assert(-1 == "".ops.lastIndexOfIgnoreCase(Some("a"))) 296 | assert(0 == "".ops.lastIndexOfIgnoreCase("")) 297 | assert(8 == "aabaabaa".ops.lastIndexOfIgnoreCase("")) 298 | assert(7 == "aabaabaa".ops.lastIndexOfIgnoreCase("a")) 299 | assert(7 == "aabaabaa".ops.lastIndexOfIgnoreCase("A")) 300 | assert(5 == "aabaabaa".ops.lastIndexOfIgnoreCase("b")) 301 | assert(5 == "aabaabaa".ops.lastIndexOfIgnoreCase("B")) 302 | assert(4 == "aabaabaa".ops.lastIndexOfIgnoreCase("ab")) 303 | assert(4 == "aabaabaa".ops.lastIndexOfIgnoreCase("AB")) 304 | assert(-1 == "ab".ops.lastIndexOfIgnoreCase("AAB")) 305 | assert(0 == "aab".ops.lastIndexOfIgnoreCase("AAB")) 306 | } 307 | 308 | test("test string last index of ignore case with start position") { 309 | assert(-1 == nullString.ops.lastIndexOfIgnoreCase(nullString, 0)) 310 | assert(-1 == noneString.ops.lastIndexOfIgnoreCase(noneString, -1)) 311 | assert(-1 == nullString.ops.lastIndexOfIgnoreCase("", 0)) 312 | assert(-1 == nullString.ops.lastIndexOfIgnoreCase(Some(""), -1)) 313 | assert(-1 == "".ops.lastIndexOfIgnoreCase(noneString, 0)) 314 | assert(-1 == "".ops.lastIndexOfIgnoreCase(nullString, -1)) 315 | assert(0 == Some("").ops.lastIndexOfIgnoreCase("", 0)) 316 | assert(-1 == Some("").ops.lastIndexOfIgnoreCase("", -1)) 317 | assert(0 == "".ops.lastIndexOfIgnoreCase(Some(""), 9)) 318 | assert(0 == "abc".ops.lastIndexOfIgnoreCase("", 0)) 319 | assert(-1 == "abc".ops.lastIndexOfIgnoreCase("", -1)) 320 | assert(3 == "abc".ops.lastIndexOfIgnoreCase("", 9)) 321 | assert(7 == "aabaabaa".ops.lastIndexOfIgnoreCase("A", 8)) 322 | assert(5 == "aabaabaa".ops.lastIndexOfIgnoreCase("B", 8)) 323 | assert(4 == "aabaabaa".ops.lastIndexOfIgnoreCase("AB", 8)) 324 | assert(2 == "aabaabaa".ops.lastIndexOfIgnoreCase("B", 3)) 325 | assert(5 == "aabaabaa".ops.lastIndexOfIgnoreCase("B", 9)) 326 | assert(-1 == "aabaabaa".ops.lastIndexOfIgnoreCase("B", -1)) 327 | assert(-1 == "aabaabaa".ops.lastIndexOfIgnoreCase("B", 0)) 328 | assert(0 == "aabaabaa".ops.lastIndexOfIgnoreCase("A", 0)) 329 | assert(1 == "aab".ops.lastIndexOfIgnoreCase("AB", 1)) 330 | } 331 | 332 | test("test last ordinal index of") { 333 | assert(-1 == noneString.ops.lastOrdinalIndexOf("*", 42)) 334 | assert(-1 == Some("*").ops.lastOrdinalIndexOf(nullString, 42)) 335 | assert(0 == "".ops.lastOrdinalIndexOf("", 42)) 336 | assert(7 == "aabaabaa".ops.lastOrdinalIndexOf("a", 1)) 337 | assert(6 == "aabaabaa".ops.lastOrdinalIndexOf("a", 2)) 338 | assert(5 == Some("aabaabaa").ops.lastOrdinalIndexOf("b", 1)) 339 | assert(2 == "aabaabaa".ops.lastOrdinalIndexOf("b", 2)) 340 | assert(4 == "aabaabaa".ops.lastOrdinalIndexOf(Some("ab"), 1)) 341 | assert(1 == "aabaabaa".ops.lastOrdinalIndexOf("ab", 2)) 342 | assert(8 == "aabaabaa".ops.lastOrdinalIndexOf("", 1)) 343 | assert(8 == "aabaabaa".ops.lastOrdinalIndexOf("", 2)) 344 | } 345 | 346 | test("test ordinal index of") { 347 | assert(-1 == nullString.ops.ordinalIndexOf(noneString, Integer.MIN_VALUE)) 348 | assert(-1 == "".ops.ordinalIndexOf(nullString, Integer.MIN_VALUE)) 349 | assert(-1 == "".ops.ordinalIndexOf("", Integer.MIN_VALUE)) 350 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("a", Integer.MIN_VALUE)) 351 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("b", Integer.MIN_VALUE)) 352 | assert(-1 == Some("aabaabaa").ops.ordinalIndexOf("ab", Integer.MIN_VALUE)) 353 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("", Integer.MIN_VALUE)) 354 | 355 | assert(-1 == noneString.ops.ordinalIndexOf(nullString, -1)) 356 | assert(-1 == "".ops.ordinalIndexOf(noneString, -1)) 357 | assert(-1 == "".ops.ordinalIndexOf("", -1)) 358 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("a", -1)) 359 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("b", -1)) 360 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("ab", -1)) 361 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("", -1)) 362 | 363 | assert(-1 == nullString.ops.ordinalIndexOf(nullString, 0)) 364 | assert(-1 == "".ops.ordinalIndexOf(noneString, 0)) 365 | assert(-1 == "".ops.ordinalIndexOf("", 0)) 366 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("a", 0)) 367 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("b", 0)) 368 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("ab", 0)) 369 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("", 0)) 370 | 371 | assert(-1 == nullString.ops.ordinalIndexOf(nullString, 1)) 372 | assert(-1 == "".ops.ordinalIndexOf(noneString, 1)) 373 | assert(0 == "".ops.ordinalIndexOf("", 1)) 374 | assert(0 == "aabaabaa".ops.ordinalIndexOf("a", 1)) 375 | assert(2 == "aabaabaa".ops.ordinalIndexOf("b", 1)) 376 | assert(1 == "aabaabaa".ops.ordinalIndexOf("ab", 1)) 377 | assert(0 == "aabaabaa".ops.ordinalIndexOf("", 1)) 378 | 379 | assert(-1 == nullString.ops.ordinalIndexOf(noneString, 2)) 380 | assert(-1 == "".ops.ordinalIndexOf(nullString, 2)) 381 | assert(0 == "".ops.ordinalIndexOf(Some(""), 2)) 382 | assert(1 == "aabaabaa".ops.ordinalIndexOf("a", 2)) 383 | assert(5 == "aabaabaa".ops.ordinalIndexOf("b", 2)) 384 | assert(4 == "aabaabaa".ops.ordinalIndexOf("ab", 2)) 385 | assert(0 == "aabaabaa".ops.ordinalIndexOf("", 2)) 386 | 387 | assert(-1 == noneString.ops.ordinalIndexOf(noneString, Integer.MAX_VALUE)) 388 | assert(-1 == "".ops.ordinalIndexOf(nullString, Integer.MAX_VALUE)) 389 | assert(0 == "".ops.ordinalIndexOf("", Integer.MAX_VALUE)) 390 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("a", Integer.MAX_VALUE)) 391 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("b", Integer.MAX_VALUE)) 392 | assert(-1 == "aabaabaa".ops.ordinalIndexOf("ab", Integer.MAX_VALUE)) 393 | assert(0 == "aabaabaa".ops.ordinalIndexOf("", Integer.MAX_VALUE)) 394 | 395 | assert(-1 == "aaaaaaaaa".ops.ordinalIndexOf("a", 0)) 396 | assert(0 == "aaaaaaaaa".ops.ordinalIndexOf("a", 1)) 397 | assert(1 == "aaaaaaaaa".ops.ordinalIndexOf("a", 2)) 398 | assert(2 == "aaaaaaaaa".ops.ordinalIndexOf("a", 3)) 399 | assert(3 == "aaaaaaaaa".ops.ordinalIndexOf("a", 4)) 400 | assert(4 == "aaaaaaaaa".ops.ordinalIndexOf("a", 5)) 401 | assert(5 == "aaaaaaaaa".ops.ordinalIndexOf("a", 6)) 402 | assert(6 == Some("aaaaaaaaa").ops.ordinalIndexOf(Some("a"), 7)) 403 | assert(7 == "aaaaaaaaa".ops.ordinalIndexOf("a", 8)) 404 | assert(8 == "aaaaaaaaa".ops.ordinalIndexOf("a", 9)) 405 | assert(-1 == "aaaaaaaaa".ops.ordinalIndexOf("a", 10)) 406 | 407 | // match at each possible position 408 | assert(0 == "aaaaaa".ops.ordinalIndexOf("aa", 1)) 409 | assert(1 == "aaaaaa".ops.ordinalIndexOf("aa", 2)) 410 | assert(2 == Some("aaaaaa").ops.ordinalIndexOf("aa", 3)) 411 | assert(3 == "aaaaaa".ops.ordinalIndexOf("aa", 4)) 412 | assert(4 == "aaaaaa".ops.ordinalIndexOf("aa", 5)) 413 | assert(-1 == "aaaaaa".ops.ordinalIndexOf("aa", 6)) 414 | 415 | assert(0 == "ababab".ops.ordinalIndexOf("aba", 1)) 416 | assert(2 == "ababab".ops.ordinalIndexOf(Some("aba"), 2)) 417 | assert(-1 == "ababab".ops.ordinalIndexOf("aba", 3)) 418 | 419 | assert(0 == "abababab".ops.ordinalIndexOf("abab", 1)) 420 | assert(2 == "abababab".ops.ordinalIndexOf("abab", 2)) 421 | assert(4 == "abababab".ops.ordinalIndexOf("abab", 3)) 422 | assert(-1 == "abababab".ops.ordinalIndexOf("abab", 4)) 423 | } 424 | 425 | test("test lang 1193") { 426 | assert(0 == "abc".ops.ordinalIndexOf("ab", 1)) 427 | } 428 | 429 | test("test lang 1241 1") { 430 | assert(0 == "abaabaab".ops.ordinalIndexOf("ab", 1)) 431 | assert(3 == "abaabaab".ops.ordinalIndexOf("ab", 2)) 432 | assert(6 == "abaabaab".ops.ordinalIndexOf("ab", 3)) 433 | } 434 | 435 | test("test lang 1241 2") { 436 | // 0 2 4 437 | assert(0 == "abababa".ops.ordinalIndexOf("aba", 1)) 438 | assert(2 == "abababa".ops.ordinalIndexOf("aba", 2)) 439 | assert(4 == "abababa".ops.ordinalIndexOf("aba", 3)) 440 | assert(0 == "abababab".ops.ordinalIndexOf("abab", 1)) 441 | assert(2 == "abababab".ops.ordinalIndexOf("abab", 2)) 442 | assert(4 == "abababab".ops.ordinalIndexOf("abab", 3)) 443 | } 444 | } 445 | -------------------------------------------------------------------------------- /modules/bridge/src/test/scala/commons/lang3/bridge/StringUtilsIEmptyBlankSpec.scala: -------------------------------------------------------------------------------- 1 | package commons.lang3.bridge 2 | 3 | import commons.lang3.bridge.StringUtils.ops._ 4 | import org.scalatest.funsuite.AnyFunSuite 5 | 6 | /** TODO 7 | * 8 | * @author 9 | * mars 10 | * @version 1.0.0 11 | * @since 2022/09/10 12 | * 16:26 13 | */ 14 | class StringUtilsIEmptyBlankSpec extends AnyFunSuite { 15 | val noneString: Option[String] = None 16 | val nullString: String = null 17 | val noneStrings: Option[Array[String]] = None 18 | 19 | test("test string is empty") { 20 | assert(nullString.ops.isEmpty) 21 | assert("".ops.isEmpty) 22 | assert(!Some(" ").ops.isEmpty) 23 | assert(!"foo".ops.isEmpty) 24 | assert(!" foo ".ops.isEmpty) 25 | } 26 | 27 | test("test string is not empty") { 28 | assert(!nullString.ops.isNotEmpty) 29 | assert(!"".ops.isNotEmpty) 30 | assert(" ".ops.isNotEmpty) 31 | assert("foo".ops.isNotEmpty) 32 | assert(" foo ".ops.isNotEmpty) 33 | } 34 | 35 | test("test string is blank") { 36 | assert(noneString.ops.isBlank) 37 | assert("".ops.isBlank) 38 | assert(StringUtilsSpec.WHITESPACE.ops.isBlank) 39 | assert(!"foo".ops.isBlank) 40 | assert(!Some(" foo ").ops.isBlank) 41 | } 42 | 43 | test("test string is not blank") { 44 | assert(!noneString.ops.isNotBlank) 45 | assert(!"".ops.isNotBlank) 46 | assert(!Some(StringUtilsSpec.WHITESPACE).ops.isNotBlank) 47 | assert("foo".ops.isNotBlank) 48 | assert(" foo ".ops.isNotBlank) 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /modules/bridge/src/test/scala/commons/lang3/bridge/StringUtilsSpec.scala: -------------------------------------------------------------------------------- 1 | package commons.lang3.bridge 2 | 3 | import commons.lang3.bridge.StringUtils.ops._ 4 | import org.apache.commons.lang3.mutable.MutableInt 5 | import org.apache.commons.lang3.{ArrayUtils, CharUtils, StringUtils => Strings} 6 | import org.scalatest.funsuite.AnyFunSuite 7 | 8 | import java.nio.CharBuffer 9 | import java.nio.charset.StandardCharsets 10 | import java.util 11 | import java.util.function.Supplier 12 | import java.util.{Collections, Locale, Objects} 13 | import scala.collection.mutable 14 | 15 | /** TODO 16 | * 17 | * @author 18 | * mars 19 | * @version 1.0.0 20 | * @since 2022/09/01 21 | * 00:53 22 | */ 23 | class StringUtilsSpec extends AnyFunSuite { 24 | import StringUtilsSpec._ 25 | 26 | private def assertAbbreviateWithAbbrevMarkerAndOffset(expected: String, abbrevMarker: String, offset: Int, maxWidth: Int): Unit = { 27 | val abcdefghijklmno = "abcdefghijklmno" 28 | val message = "abbreviate(String,String,int,int) failed" 29 | val result = abcdefghijklmno.ops.abbreviate(abbrevMarker, offset, maxWidth) 30 | assert(result.isDefined) 31 | result foreach { actual => 32 | if (offset >= 0 && offset < abcdefghijklmno.length) { 33 | assert(actual.indexOf(('a' + offset).toChar) != -1, message + " -- should contain offset character") 34 | } 35 | assert(actual.length <= maxWidth, message + " -- should not be greater than maxWidth") 36 | assert(expected == actual, message) 37 | } 38 | } 39 | 40 | private def assertAbbreviateWithOffset(expected: String, offset: Int, maxWidth: Int): Unit = { 41 | val abcdefghijklmno = "abcdefghijklmno" 42 | val message = "abbreviate(String,int,int) failed" 43 | val result = abcdefghijklmno.ops.abbreviate(offset, maxWidth) 44 | assert(result.isDefined) 45 | result foreach { actual => 46 | if (offset >= 0 && offset < abcdefghijklmno.length) { 47 | assert(actual.indexOf(('a' + offset).toChar) != -1, message + " -- should contain offset character") 48 | } 49 | assert(actual.length <= maxWidth, message + " -- should not be greater than maxWidth") 50 | assert(expected == actual, message) 51 | } 52 | } 53 | 54 | private def innerTestSplit(separator: Char, sepStr: String, noMatch: Char): Unit = { 55 | val msg = "Failed on separator hex(" + Integer.toHexString(separator) + "), noMatch hex(" + Integer.toHexString( 56 | noMatch 57 | ) + "), sepStr(" + sepStr + ")" 58 | val str = "a" + separator + "b" + separator + separator + noMatch + "c" 59 | 60 | // (str, sepStr) 61 | val res1 = str.ops.split(sepStr).get 62 | assert(3 == res1.length, msg) 63 | assert("a" == res1(0)) 64 | assert("b" == res1(1)) 65 | assert((noMatch + "c") == res1(2)) 66 | val str2 = separator + "a" + separator 67 | val res2 = str2.ops.split(sepStr).get 68 | assert(1 == res2.length, msg) 69 | assert("a" == res2(0), msg) 70 | val res3 = str.ops.split(sepStr, -1).get 71 | assert(3 == res3.length, msg) 72 | assert("a" == res3(0), msg) 73 | assert("b" == res3(1), msg) 74 | assert((noMatch + "c") == res3(2), msg) 75 | val res4 = str.ops.split(sepStr, 0).get 76 | assert(3 == res4.length, msg) 77 | assert("a" == res4(0), msg) 78 | assert("b" == res4(1), msg) 79 | assert((noMatch + "c") == res4(2), msg) 80 | val res5 = str.ops.split(sepStr, 1).get 81 | assert(1 == res5.length, msg) 82 | assert(str == res5(0), msg) 83 | val res6 = str.ops.split(sepStr, 2).get 84 | assert(2 == res6.length, msg) 85 | assert("a" == res6(0), msg) 86 | assert(str.substring(2) == res6(1), msg) 87 | } 88 | 89 | private def innerTestSplitPreserveAllTokens(separator: Char, sepStr: String, noMatch: Char): Unit = { 90 | val msg = "Failed on separator hex(" + Integer.toHexString(separator) + "), noMatch hex(" + Integer.toHexString( 91 | noMatch 92 | ) + "), sepStr(" + sepStr + ")" 93 | val str = "a" + separator + "b" + separator + separator + noMatch + "c" 94 | val res = str.ops.splitPreserveAllTokens(sepStr) 95 | assert(res.isDefined) 96 | val resStr = res.get 97 | assert(4 == resStr.length, msg) 98 | assert("a" == resStr(0), msg) 99 | assert("b" == resStr(1), msg) 100 | assert("" == resStr(2), msg) 101 | assert(noMatch + "c" == resStr(3), msg) 102 | 103 | val str2 = separator + "a" + separator 104 | val res2 = str2.ops.splitPreserveAllTokens(sepStr) 105 | assert(res2.isDefined) 106 | val resStr2 = res2.get 107 | 108 | assert(3 == resStr2.length, msg) 109 | assert("" == resStr2(0), msg) 110 | assert("a" == resStr2(1), msg) 111 | assert("" == resStr2(2), msg) 112 | 113 | val res3 = str.ops.splitPreserveAllTokens(sepStr, -1) 114 | assert(res3.isDefined) 115 | val resStr3 = res3.get 116 | 117 | assert(4 == resStr3.length, msg) 118 | assert("a" == resStr3(0), msg) 119 | assert("b" == resStr3(1), msg) 120 | assert("" == resStr3(2), msg) 121 | assert(noMatch + "c" == resStr3(3), msg) 122 | 123 | val res4 = str.ops.splitPreserveAllTokens(sepStr, 0) 124 | assert(res4.isDefined) 125 | val resStr4 = res4.get 126 | 127 | assert(4 == resStr4.length, msg) 128 | assert("a" == resStr4(0), msg) 129 | assert("b" == resStr4(1), msg) 130 | assert("" == resStr4(2), msg) 131 | assert(noMatch + "c" == resStr4(3), msg) 132 | 133 | val res5 = str.ops.splitPreserveAllTokens(sepStr, 1) 134 | assert(res5.isDefined) 135 | val resStr5 = res5.get 136 | 137 | assert(1 == resStr5.length, msg) 138 | assert(str == resStr5(0), msg) 139 | 140 | val res6 = str.ops.splitPreserveAllTokens(sepStr, 2) 141 | assert(res6.isDefined) 142 | val resStr6 = res6.get 143 | 144 | assert(2 == resStr6.length, msg) 145 | assert("a" == resStr6(0), msg) 146 | assert(str.substring(2) == resStr6(1), msg) 147 | } 148 | 149 | test("test abbreviate marker with empty string") { 150 | val greaterThanMaxTest = "much too long text" 151 | assert(greaterThanMaxTest.ops.abbreviate("", 13).contains("much too long")) 152 | } 153 | 154 | test("test abbreviate string int") { 155 | assert(noneString.ops.abbreviate(10).isEmpty) 156 | assert("".ops.abbreviate(10).contains("")) 157 | assert(Some("short").ops.abbreviate(10).contains("short")) 158 | assert("Now is the time for all good men to come to the aid of their party.".ops.abbreviate(10).contains("Now is ...")) 159 | 160 | val raspberry = "raspberry peach" 161 | assert(raspberry.ops.abbreviate(14).contains("raspberry p...")) 162 | assert(Some("raspberry peach").ops.abbreviate(15).contains("raspberry peach")) 163 | assert("raspberry peach".ops.abbreviate(16).contains("raspberry peach")) 164 | assert("abcdefg".ops.abbreviate(6).contains("abc...")) 165 | assert("abcdefg".ops.abbreviate(7).contains("abcdefg")) 166 | assert("abcdefg".ops.abbreviate(8).contains("abcdefg")) 167 | assert(Some("abcdefg").ops.abbreviate(4).contains("a...")) 168 | assert("".ops.abbreviate(4).contains("")) 169 | 170 | assertThrows[IllegalArgumentException] { 171 | "abc".ops.abbreviate(3) 172 | } 173 | } 174 | 175 | test("test string abbreviate with offset and max width") { 176 | assert(nullString.ops.abbreviate(10, 12).isEmpty) 177 | assert("".ops.abbreviate(0, 10).contains("")) 178 | assert(Some("").ops.abbreviate(2, 10).contains("")) 179 | 180 | assertThrows[IllegalArgumentException] { 181 | "abcdefghij".ops.abbreviate(0, 3) 182 | } 183 | assertThrows[IllegalArgumentException] { 184 | "abcdefghij".ops.abbreviate(5, 6) 185 | } 186 | 187 | val raspberry = "raspberry peach" 188 | assert(raspberry.ops.abbreviate(11, 15).contains("raspberry peach")) 189 | 190 | assert(nullString.ops.abbreviate(7, 14).isEmpty) 191 | assertAbbreviateWithOffset("abcdefg...", -1, 10) 192 | assertAbbreviateWithOffset("abcdefg...", 0, 10) 193 | assertAbbreviateWithOffset("abcdefg...", 1, 10) 194 | assertAbbreviateWithOffset("abcdefg...", 2, 10) 195 | assertAbbreviateWithOffset("abcdefg...", 3, 10) 196 | assertAbbreviateWithOffset("abcdefg...", 4, 10) 197 | assertAbbreviateWithOffset("...fghi...", 5, 10) 198 | assertAbbreviateWithOffset("...ghij...", 6, 10) 199 | assertAbbreviateWithOffset("...hijk...", 7, 10) 200 | assertAbbreviateWithOffset("...ijklmno", 8, 10) 201 | assertAbbreviateWithOffset("...ijklmno", 9, 10) 202 | assertAbbreviateWithOffset("...ijklmno", 10, 10) 203 | assertAbbreviateWithOffset("...ijklmno", 10, 10) 204 | assertAbbreviateWithOffset("...ijklmno", 11, 10) 205 | assertAbbreviateWithOffset("...ijklmno", 12, 10) 206 | assertAbbreviateWithOffset("...ijklmno", 13, 10) 207 | assertAbbreviateWithOffset("...ijklmno", 14, 10) 208 | assertAbbreviateWithOffset("...ijklmno", 15, 10) 209 | assertAbbreviateWithOffset("...ijklmno", 16, 10) 210 | assertAbbreviateWithOffset("...ijklmno", Integer.MAX_VALUE, 10) 211 | } 212 | 213 | test("test string abbreviate with abbrev maker and max width") { 214 | assert(nullString.ops.abbreviate(null, 10).isEmpty) 215 | assert(None.ops.abbreviate("...", 10).isEmpty) 216 | assert(Some("paranaguacu").ops.abbreviate(None, 10).contains("paranaguacu")) 217 | assert("".ops.abbreviate("...", 2).contains("")) 218 | assert("waiheke".ops.abbreviate("**", 5).contains("wai**")) 219 | assert("And after a long time, he finally met his son.".ops.abbreviate(",,,,", 10).contains("And af,,,,")) 220 | 221 | val raspberry = "raspberry peach" 222 | assert(raspberry.ops.abbreviate("..", 14).contains("raspberry pe..")) 223 | assert(Some("raspberry peach").ops.abbreviate("---*---", 15).contains("raspberry peach")) 224 | assert("raspberry peach".ops.abbreviate(".", 16).contains("raspberry peach")) 225 | assert("abcdefg".ops.abbreviate(Some("()("), 6).contains("abc()(")) 226 | assert("abcdefg".ops.abbreviate(";", 7).contains("abcdefg")) 227 | assert(Some("abcdefg").ops.abbreviate("_-", 8).contains("abcdefg")) 228 | assert("abcdefg".ops.abbreviate(".", 4).contains("abc.")) 229 | assert("".ops.abbreviate("", 4).contains("")) 230 | 231 | assertThrows[IllegalArgumentException] { 232 | Some("abcdefghij").ops.abbreviate(Some("..."), 3) 233 | } 234 | 235 | } 236 | 237 | test("test strings abbreviate with abbrev maker, offset and max width") { 238 | assert(nullString.ops.abbreviate(None, 10, 12).isEmpty) 239 | assert(noneString.ops.abbreviate("...", 10, 12).isEmpty) 240 | assert("".ops.abbreviate(null, 0, 10).contains("")) 241 | assert(Some("").ops.abbreviate("...", 2, 10).contains("")) 242 | 243 | assertThrows[IllegalArgumentException] { 244 | Some("abcdefghij").ops.abbreviate(Some("::"), 0, 2) 245 | } 246 | assertThrows[IllegalArgumentException] { 247 | Some("abcdefghij").ops.abbreviate("!!!", 5, 6) 248 | } 249 | 250 | val raspberry = "raspberry peach" 251 | assert(raspberry.ops.abbreviate("--", 12, 15).contains("raspberry peach")) 252 | 253 | assert(noneString.ops.abbreviate(";", 7, 14).isEmpty) 254 | assertAbbreviateWithAbbrevMarkerAndOffset("abcdefgh;;", ";;", -1, 10) 255 | assertAbbreviateWithAbbrevMarkerAndOffset("abcdefghi.", ".", 0, 10) 256 | assertAbbreviateWithAbbrevMarkerAndOffset("abcdefgh++", "++", 1, 10) 257 | assertAbbreviateWithAbbrevMarkerAndOffset("abcdefghi*", "*", 2, 10) 258 | assertAbbreviateWithAbbrevMarkerAndOffset("abcdef{{{{", "{{{{", 4, 10) 259 | assertAbbreviateWithAbbrevMarkerAndOffset("abcdef____", "____", 5, 10) 260 | assertAbbreviateWithAbbrevMarkerAndOffset("==fghijk==", "==", 5, 10) 261 | assertAbbreviateWithAbbrevMarkerAndOffset("___ghij___", "___", 6, 10) 262 | assertAbbreviateWithAbbrevMarkerAndOffset("/ghijklmno", "/", 7, 10) 263 | assertAbbreviateWithAbbrevMarkerAndOffset("/ghijklmno", "/", 8, 10) 264 | assertAbbreviateWithAbbrevMarkerAndOffset("/ghijklmno", "/", 9, 10) 265 | assertAbbreviateWithAbbrevMarkerAndOffset("///ijklmno", "///", 10, 10) 266 | assertAbbreviateWithAbbrevMarkerAndOffset("//hijklmno", "//", 10, 10) 267 | assertAbbreviateWithAbbrevMarkerAndOffset("//hijklmno", "//", 11, 10) 268 | assertAbbreviateWithAbbrevMarkerAndOffset("...ijklmno", "...", 12, 10) 269 | assertAbbreviateWithAbbrevMarkerAndOffset("/ghijklmno", "/", 13, 10) 270 | assertAbbreviateWithAbbrevMarkerAndOffset("/ghijklmno", "/", 14, 10) 271 | assertAbbreviateWithAbbrevMarkerAndOffset("999ijklmno", "999", 15, 10) 272 | assertAbbreviateWithAbbrevMarkerAndOffset("_ghijklmno", "_", 16, 10) 273 | assertAbbreviateWithAbbrevMarkerAndOffset("+ghijklmno", "+", Integer.MAX_VALUE, 10) 274 | } 275 | 276 | test("test abbreviate middle") { 277 | // javadoc examples 278 | assert(noneString.ops.abbreviateMiddle(null, 0).isEmpty) 279 | assert("abc".ops.abbreviateMiddle(null, 0).contains("abc")) 280 | assert("abc".ops.abbreviateMiddle(Some("."), 0).contains("abc")) 281 | assert("abc".ops.abbreviateMiddle(Some("."), 3).contains("abc")) 282 | assert(Some("abcdef").ops.abbreviateMiddle(".", 4).contains("ab.f")) 283 | 284 | // JIRA issue (LANG-405) example (slightly different than actual expected result) 285 | assert( 286 | Some("A very long text with unimportant stuff in the middle but interesting start and " + "end to see if the text is complete.").ops 287 | .abbreviateMiddle("...", 50) 288 | .contains("A very long text with un...f the text is complete.") 289 | ) 290 | 291 | // Test a much longer text :) 292 | val longText = "Start text" + "x".ops.repeat(10000) + "Close text" 293 | assert(longText.ops.abbreviateMiddle("->", 22).contains("Start text->Close text")) 294 | 295 | // Test negative length 296 | assert("abc".ops.abbreviateMiddle(".", -1).contains("abc")) 297 | 298 | // Test boundaries 299 | // Fails to change anything as method ensures first and last char are kept 300 | assert(Some("abc").ops.abbreviateMiddle(".", 1).contains("abc")) 301 | assert("abc".ops.abbreviateMiddle(Some("."), 2).contains("abc")) 302 | 303 | // Test length of n=1 304 | assert(Some("a").ops.abbreviateMiddle(".", 1).contains("a")) 305 | 306 | // Test smallest length that can lead to success 307 | assert("abcd".ops.abbreviateMiddle(".", 3).contains("a.d")) 308 | 309 | // More from LANG-405 310 | assert("abcdef".ops.abbreviateMiddle("..", 4).contains("a..f")) 311 | assert("abcdef".ops.abbreviateMiddle(".", 5).contains("ab.ef")) 312 | } 313 | 314 | test("test string append if missing") { 315 | assert(nullString.ops.appendIfMissing(noneString).isEmpty, "appendIfMissing(null,null)") 316 | assert(Some("abc").ops.appendIfMissing(nullString).contains("abc"), "appendIfMissing(abc,null)") 317 | assert("".ops.appendIfMissing(Some("xyz")).contains("xyz"), "appendIfMissing(\"\",xyz)") 318 | assert("abc".ops.appendIfMissing("xyz").contains("abcxyz"), "appendIfMissing(abc,xyz)") 319 | assert(Some("abcxyz").ops.appendIfMissing(Some("xyz")).contains("abcxyz"), "appendIfMissing(abcxyz,xyz)") 320 | assert("aXYZ".ops.appendIfMissing("xyz").contains("aXYZxyz"), "appendIfMissing(aXYZ,xyz)") 321 | 322 | assert( 323 | nullString.ops.appendIfMissing(nullString, null.asInstanceOf[Array[CharSequence]]: _*).isEmpty, 324 | "appendIfMissing(null,null,null)" 325 | ) 326 | assert( 327 | "abc".ops.appendIfMissing(noneString, null.asInstanceOf[Array[CharSequence]]: _*).contains("abc"), 328 | "appendIfMissing(abc,null,null)" 329 | ) 330 | assert("".ops.appendIfMissing("xyz", null.asInstanceOf[Array[CharSequence]]: _*).contains("xyz"), "appendIfMissing(\"\",xyz,null))") 331 | assert("abc".ops.appendIfMissing("xyz", nullString).contains("abcxyz"), "appendIfMissing(abc,xyz,{null})") 332 | assert("abc".ops.appendIfMissing("xyz", "").contains("abc"), "appendIfMissing(abc,xyz,\"\")") 333 | assert(Some("abc").ops.appendIfMissing("xyz", "mno").contains("abcxyz"), "appendIfMissing(abc,xyz,mno)") 334 | assert("abcxyz".ops.appendIfMissing("xyz", Some("mno")).contains("abcxyz"), "appendIfMissing(abcxyz,xyz,mno)") 335 | assert("abcmno".ops.appendIfMissing("xyz", "mno").contains("abcmno"), "appendIfMissing(abcmno,xyz,mno)") 336 | assert("abcXYZ".ops.appendIfMissing(Some("xyz"), Some("mno")).contains("abcXYZxyz"), "appendIfMissing(abcXYZ,xyz,mno)") 337 | assert("abcMNO".ops.appendIfMissing("xyz", "mno").contains("abcMNOxyz"), "appendIfMissing(abcMNO,xyz,mno)") 338 | 339 | } 340 | 341 | test("test append if missing ignore case") { 342 | assert(noneString.ops.appendIfMissingIgnoreCase(nullString).isEmpty, "appendIfMissingIgnoreCase(null,null)") 343 | assert("abc".ops.appendIfMissingIgnoreCase(noneString).contains("abc"), "appendIfMissingIgnoreCase(abc,null)") 344 | assert("".ops.appendIfMissingIgnoreCase("xyz").contains("xyz"), "appendIfMissingIgnoreCase(\"\",xyz)") 345 | assert(Some("abc").ops.appendIfMissingIgnoreCase("xyz").contains("abcxyz"), "appendIfMissingIgnoreCase(abc,xyz)") 346 | assert("abcxyz".ops.appendIfMissing("xyz").contains("abcxyz"), "appendIfMissingIgnoreCase(abcxyz,xyz)") 347 | assert("abcXYZ".ops.appendIfMissingIgnoreCase("xyz").contains("abcXYZ"), "appendIfMissingIgnoreCase(abcXYZ,xyz)") 348 | 349 | assert(nullString.ops.appendIfMissingIgnoreCase(noneString, null).isEmpty, "appendIfMissingIgnoreCase(null,null,null)") 350 | assert("abc".ops.appendIfMissingIgnoreCase(null, null).contains("abc"), "appendIfMissingIgnoreCase(abc,null,null)") 351 | assert("".ops.appendIfMissingIgnoreCase("xyz", null).contains("xyz"), "appendIfMissingIgnoreCase(\"\",xyz,null)") 352 | assert("abc".ops.appendIfMissingIgnoreCase("xyz", null).contains("abcxyz"), "appendIfMissingIgnoreCase(abc,xyz,{null})") 353 | assert(Some("abc").ops.appendIfMissingIgnoreCase(Some("xyz"), "").contains("abc"), "appendIfMissingIgnoreCase(abc,xyz,\"\")") 354 | assert("abc".ops.appendIfMissingIgnoreCase("xyz", "mno").contains("abcxyz"), "appendIfMissingIgnoreCase(abc,xyz,mno)") 355 | assert(Some("abcxyz").ops.appendIfMissingIgnoreCase("xyz", Some("mno")).contains("abcxyz"), "appendIfMissingIgnoreCase(abcxyz,xyz,mno)") 356 | assert("abcmno".ops.appendIfMissingIgnoreCase("xyz", "mno").contains("abcmno"), "appendIfMissingIgnoreCase(abcmno,xyz,mno)") 357 | assert( 358 | Some("abcXYZ").ops.appendIfMissingIgnoreCase(Some("xyz"), Some("mno")).contains("abcXYZ"), 359 | "appendIfMissingIgnoreCase(abcXYZ,xyz,mno)" 360 | ) 361 | assert("abcMNO".ops.appendIfMissingIgnoreCase("abcMNO", "xyz", "mno").contains("abcMNO"), "appendIfMissingIgnoreCase(abcMNO,xyz,mno)") 362 | } 363 | 364 | test("test string capitalize") { 365 | assert(nullString.ops.capitalize.isEmpty) 366 | 367 | assert(Some("").ops.capitalize.contains(""), "capitalize(empty-string) failed") 368 | assert("x".ops.capitalize.contains("X"), "capitalize(single-char-string) failed") 369 | assert(FOO_CAP.ops.capitalize.contains(FOO_CAP), "capitalize(String) failed") 370 | assert(FOO_UNCAP.ops.capitalize.contains(FOO_CAP), "capitalize(string) failed") 371 | 372 | assert(Some("\u01C9").ops.capitalize.contains("\u01C8"), "capitalize(String) is not using TitleCase") 373 | 374 | // Javadoc examples 375 | assert(noneString.ops.capitalize.isEmpty) 376 | assert("".ops.capitalize.contains("")) 377 | assert("cat".ops.capitalize.contains("Cat")) 378 | assert("cAt".ops.capitalize.contains("CAt")) 379 | assert(Some("'cat'").ops.capitalize.contains("'cat'")) 380 | } 381 | 382 | test("test string utils center with size") { 383 | assert(nullString.ops.center(-1).isEmpty) 384 | assert(noneString.ops.center(4).isEmpty) 385 | assert(Some("").ops.center(4).contains(" ")) 386 | assert("ab".ops.center(0).contains("ab")) 387 | assert("ab".ops.center(-1).contains("ab")) 388 | assert("ab".ops.center(1).contains("ab")) 389 | assert("".ops.center(4).contains(" ")) 390 | assert("ab".ops.center(4).contains(" ab ")) 391 | assert("abcd".ops.center(2).contains("abcd")) 392 | assert("a".ops.center(4).contains(" a ")) 393 | assert(Some("a").ops.center(5).contains(" a ")) 394 | } 395 | 396 | test("test string utils center with size and pad char") { 397 | assert(nullString.ops.center(-1, ' ').isEmpty) 398 | assert(noneString.ops.center(4, ' ').isEmpty) 399 | assert(Some("").ops.center(4, ' ').contains(" ")) 400 | assert("ab".ops.center(0, ' ').contains("ab")) 401 | assert(Some("ab").ops.center(-1, ' ').contains("ab")) 402 | assert("ab".ops.center(1, ' ').contains("ab")) 403 | assert("".ops.center(4, ' ').contains(" ")) 404 | assert("ab".ops.center(4, ' ').contains(" ab ")) 405 | assert("abcd".ops.center(2, ' ').contains("abcd")) 406 | assert("a".ops.center(4, ' ').contains(" a ")) 407 | assert("a".ops.center(5, ' ').contains(" a ")) 408 | assert("a".ops.center(5, 'x').contains("xxaxx")) 409 | } 410 | 411 | test("test string utils chomp") { 412 | val chompCases = Array( 413 | Array(FOO_UNCAP + "\r\n", FOO_UNCAP), 414 | Array(FOO_UNCAP + "\n", FOO_UNCAP), 415 | Array(FOO_UNCAP + "\r", FOO_UNCAP), 416 | Array(FOO_UNCAP + " \r", FOO_UNCAP + " "), 417 | Array(FOO_UNCAP, FOO_UNCAP), 418 | Array(FOO_UNCAP + "\n\n", FOO_UNCAP + "\n"), 419 | Array(FOO_UNCAP + "\r\n\r\n", FOO_UNCAP + "\r\n"), 420 | Array("foo\nfoo", "foo\nfoo"), 421 | Array("foo\n\rfoo", "foo\n\rfoo"), 422 | Array("\n", ""), 423 | Array("\r", ""), 424 | Array("a", "a"), 425 | Array("\r\n", ""), 426 | Array("", ""), 427 | Array(nullString, nullString), 428 | Array(FOO_UNCAP + "\n\r", FOO_UNCAP + "\n") 429 | ) 430 | for (chompCase <- chompCases) { 431 | val original = chompCase(0) 432 | val expectedResult = chompCase(1) 433 | original.ops.chomp match { 434 | case None => assert(expectedResult == null) 435 | case Some(value) => assert(value == expectedResult) 436 | } 437 | } 438 | // StringUtils.chomp(String, String) is deprecated 439 | } 440 | 441 | test("test default string") { 442 | assert(noneString.ops.defaultString == "") 443 | assert(Some("").ops.defaultString == "") 444 | assert("abc".ops.defaultString == "abc") 445 | } 446 | 447 | test("test string utils default with default value") { 448 | assert(nullString.ops.defaultString("NULL").contains("NULL")) 449 | assert("".ops.defaultString("NULL").contains("")) 450 | assert("abc".ops.defaultString("NULL").contains("abc")) 451 | } 452 | 453 | test("test string utils default if blank with char buffers") { 454 | assert(CharBuffer.wrap("").toString.ops.defaultIfBlank(CharBuffer.wrap("NULL")).toString == "NULL") 455 | assert(CharBuffer.wrap(" ").toString.ops.defaultIfBlank(CharBuffer.wrap("NULL")).toString == "NULL") 456 | assert(CharBuffer.wrap("abc").toString.ops.defaultIfBlank(CharBuffer.wrap("NULL")).toString == "abc") 457 | 458 | assert(CharBuffer.wrap("").toString.ops.defaultIfBlank(null.asInstanceOf[CharBuffer]) == null) 459 | // Tests compatibility for the API return type 460 | val s = CharBuffer.wrap("abc").toString.ops.defaultIfBlank(CharBuffer.wrap("NULL")).toString 461 | assert(s == "abc") 462 | } 463 | 464 | test("test string utils default string if blank string builder") { 465 | assert((new mutable.StringBuilder("")).toString().ops.defaultIfBlank(new mutable.StringBuilder("NULL")).toString == "NULL") 466 | assert(Some(new mutable.StringBuilder(" ").toString()).ops.defaultIfBlank(new mutable.StringBuilder("NULL")).toString == "NULL") 467 | assert((new mutable.StringBuilder("abc")).toString().ops.defaultIfBlank(new mutable.StringBuilder("NULL")).toString == "abc") 468 | 469 | assert((new mutable.StringBuilder("")).toString().ops.defaultIfBlank(null.asInstanceOf[mutable.StringBuilder]) == null) 470 | // Tests compatibility for the API return type 471 | val s = Some(new mutable.StringBuilder("abc").toString()).ops.defaultIfBlank(new mutable.StringBuilder("NULL")).toString 472 | assert("abc" == s) 473 | } 474 | 475 | test("test string utils default string if blank with string") { 476 | assert(nullString.ops.defaultIfBlank("NULL") == "NULL") 477 | assert("".ops.defaultIfBlank("NULL") == "NULL") 478 | assert(Some(" ").ops.defaultIfBlank("NULL") == "NULL") 479 | assert("abc".ops.defaultIfBlank("NULL") == "abc") 480 | assert("".ops.defaultIfBlank(null.asInstanceOf[String]) == null) 481 | // Tests compatibility for the API return type 482 | val s = "abc".ops.defaultIfBlank("NULL") 483 | assert(s == "abc") 484 | } 485 | 486 | test("test string get if blank with string supplier") { 487 | assert(nullString.ops.getIfBlank(() => "NULL") == "NULL") 488 | assert(Some("").ops.getIfBlank(() => "NULL") == "NULL") 489 | assert(" ".ops.getIfBlank(() => "NULL") == "NULL") 490 | assert("abc".ops.getIfBlank(() => "NULL") == "abc") 491 | assert("".ops.getIfBlank(() => None) == null) 492 | assert("".ops.getIfBlank(() => null.asInstanceOf[String]) == null) 493 | // Tests compatibility for the API return type 494 | val s = "abc".ops.getIfBlank(() => "NULL") 495 | assert(s.toString == "abc") 496 | // Checking that default value supplied only on demand 497 | val numberOfCalls = new MutableInt(0) 498 | val countingDefaultSupplier: Supplier[String] = () => { 499 | def foo(): String = { 500 | numberOfCalls.increment() 501 | "NULL" 502 | } 503 | 504 | foo() 505 | } 506 | "abc".ops.getIfBlank(countingDefaultSupplier) 507 | assert(0 == numberOfCalls.getValue) 508 | "".ops.getIfBlank(countingDefaultSupplier) 509 | assert(1 == numberOfCalls.getValue) 510 | " ".ops.getIfBlank(countingDefaultSupplier) 511 | assert(2 == numberOfCalls.getValue) 512 | noneString.ops.getIfBlank(countingDefaultSupplier) 513 | assert(3 == numberOfCalls.getValue) 514 | } 515 | 516 | test("test string default if empty with char buffers") { 517 | assert(Some(CharBuffer.wrap("").toString).ops.defaultIfEmpty(CharBuffer.wrap("NULL")).toString == "NULL") 518 | assert(nullString.ops.defaultIfEmpty("NULL").toString == "NULL") 519 | assert(CharBuffer.wrap("abc").toString.ops.defaultIfEmpty(CharBuffer.wrap("NULL")).toString == "abc") 520 | assert(CharBuffer.wrap("").toString.ops.defaultIfEmpty(null.asInstanceOf[CharBuffer]) == null) 521 | // Tests compatibility for the API return type 522 | val s = CharBuffer.wrap("abc").toString.ops.defaultIfEmpty(CharBuffer.wrap("NULL")) 523 | assert(s == "abc") 524 | } 525 | 526 | test("test string default if empty with string builder") { 527 | assert( 528 | Some(new mutable.StringBuilder("").toString()).ops.defaultIfEmpty(new mutable.StringBuilder("NULL")).toString == "NULL" 529 | ) 530 | assert((new mutable.StringBuilder("abc").toString()).ops.defaultIfEmpty(new mutable.StringBuilder("NULL")).toString == "abc") 531 | assert((new mutable.StringBuilder("")).toString().ops.defaultIfEmpty(noneString) == null) 532 | // Tests compatibility for the API return type 533 | val s = (new mutable.StringBuilder("abc")).toString().ops.defaultIfEmpty(new mutable.StringBuilder("NULL")) 534 | assert(s.toString == "abc") 535 | } 536 | 537 | test("test string default if empty with string") { 538 | assert(nullString.ops.defaultIfEmpty("NULL") == "NULL") 539 | assert(Some("").ops.defaultIfEmpty("NULL") == "NULL") 540 | assert("abc".ops.defaultIfEmpty("NULL") == "abc") 541 | assert("".ops.defaultIfEmpty(null) == null) 542 | // Tests compatibility for the API return type 543 | val s = "abc".ops.defaultIfEmpty("NULL") 544 | assert(s == "abc") 545 | } 546 | 547 | test("get string get if emtpy with supplier") { 548 | assert(nullString.ops.getIfEmpty(() => "NULL") == "NULL") 549 | assert(Some("").ops.getIfEmpty(() => "NULL") == "NULL") 550 | assert("abc".ops.getIfEmpty(() => "NULL") == "abc") 551 | assert(Some("").ops.getIfEmpty(() => null) == null) 552 | assert("".ops.getIfEmpty(null.asInstanceOf[Supplier[String]]) == null) 553 | // Tests compatibility for the API return type 554 | val s = "abc".ops.getIfEmpty(() => "NULL") 555 | assert(s.toString == "abc") 556 | // Checking that default value supplied only on demand 557 | val numberOfCalls = new MutableInt(0) 558 | val countingDefaultSupplier: Supplier[String] = () => { 559 | def foo(): String = { 560 | numberOfCalls.increment() 561 | "NULL" 562 | } 563 | 564 | foo() 565 | } 566 | Some("abc").ops.getIfEmpty(countingDefaultSupplier) 567 | assert(0 == numberOfCalls.getValue) 568 | "".ops.getIfEmpty(countingDefaultSupplier) 569 | assert(1 == numberOfCalls.getValue) 570 | noneString.ops.getIfEmpty(countingDefaultSupplier) 571 | assert(2 == numberOfCalls.getValue) 572 | } 573 | 574 | test("test string delete white space") { 575 | assert(nullString.ops.deleteWhitespace().isEmpty) 576 | assert("".ops.deleteWhitespace().contains("")) 577 | assert(Some(" \u000C \t\t\u001F\n\n \u000B ").ops.deleteWhitespace().contains("")) 578 | assert(WHITESPACE.ops.deleteWhitespace().contains("")) 579 | assert(NON_WHITESPACE.ops.deleteWhitespace().contains(NON_WHITESPACE)) 580 | // Note: u-2007 and u-000A both cause problems in the source code 581 | // it should ignore 2007 but delete 000A 582 | assert(Some(" \u00A0 \t\t\n\n \u202F ").ops.deleteWhitespace().contains("\u00A0\u202F")) 583 | assert("\u00A0\u202F".ops.deleteWhitespace().contains("\u00A0\u202F")) 584 | assert("\u000Bt \t\n\u0009e\rs\n\n \tt".ops.deleteWhitespace().contains("test")) 585 | } 586 | 587 | test("test string difference to string") { 588 | assert(noneString.ops.difference(nullString).ops.isEmpty) 589 | assert(Some("").ops.difference(Some("")).contains("")) 590 | assert("".ops.difference("abc").contains("abc")) 591 | assert("abc".ops.difference("").contains("")) 592 | assert(nullString.ops.difference("i am a robot").contains("i am a robot")) 593 | assert("i am a machine".ops.difference(noneString).contains("i am a machine")) 594 | assert("i am a machine".ops.difference("i am a robot").contains("robot")) 595 | assert("abc".ops.difference("abc").contains("")) 596 | assert("i am a robot".ops.difference("you are a robot").contains("you are a robot")) 597 | } 598 | 599 | test("test string index of difference between string") { 600 | assert(-1 == nullString.ops.indexOfDifference(noneString)) 601 | assert(0 == nullString.ops.indexOfDifference("i am a robot")) 602 | assert(-1 == Some("").ops.indexOfDifference("")) 603 | assert(0 == Some("").ops.indexOfDifference("abc")) 604 | assert(0 == "abc".ops.indexOfDifference("")) 605 | assert(0 == "i am a machine".ops.indexOfDifference(nullString)) 606 | assert(7 == "i am a machine".ops.indexOfDifference("i am a robot")) 607 | assert(-1 == "foo".ops.indexOfDifference("foo")) 608 | assert(0 == "i am a robot".ops.indexOfDifference("you are a robot")) 609 | } 610 | 611 | test("test string get bytes") { 612 | assert(ArrayUtils.EMPTY_BYTE_ARRAY sameElements nullString.ops.getBytes(nullString)) 613 | assert(Strings.EMPTY.getBytes sameElements Strings.EMPTY.ops.getBytes(nullString)) 614 | assert( 615 | Strings.EMPTY.getBytes(StandardCharsets.US_ASCII.name) sameElements 616 | Strings.EMPTY.ops.getBytes(StandardCharsets.US_ASCII.name) 617 | ) 618 | } 619 | 620 | test("test string get digits") { 621 | assert(nullString.ops.getDigits == null) 622 | assert(Some("").ops.getDigits == "") 623 | assert("abc".ops.getDigits == "") 624 | assert("1000$".ops.getDigits == "1000") 625 | assert("123password45".ops.getDigits == "12345") 626 | assert(Some("(541) 754-3010").ops.getDigits == "5417543010") 627 | assert("\u0967\u0968\u0969".ops.getDigits == "\u0967\u0968\u0969") 628 | } 629 | 630 | test("test string is all lower case") { 631 | 632 | assert(!nullString.ops.isAllLowerCase) 633 | assert(!Strings.EMPTY.ops.isAllLowerCase) 634 | assert(!" ".ops.isAllLowerCase) 635 | assert(Some("abc").ops.isAllLowerCase) 636 | assert(!"abc ".ops.isAllLowerCase) 637 | assert(!"abc\n".ops.isAllLowerCase) 638 | assert(!"abC".ops.isAllLowerCase) 639 | assert(!"ab c".ops.isAllLowerCase) 640 | assert(!"ab1c".ops.isAllLowerCase) 641 | assert(!"ab/c".ops.isAllLowerCase) 642 | } 643 | 644 | test("test string is all upper case") { 645 | assert(!noneString.ops.isAllUpperCase) 646 | assert(!Strings.EMPTY.ops.isAllUpperCase) 647 | assert(!Some(" ").ops.isAllUpperCase) 648 | assert(Some("ABC").ops.isAllUpperCase) 649 | assert(!"ABC ".ops.isAllUpperCase) 650 | assert(!"ABC\n".ops.isAllUpperCase) 651 | assert(!"aBC".ops.isAllUpperCase) 652 | assert(!"A C".ops.isAllUpperCase) 653 | assert(!"A1C".ops.isAllUpperCase) 654 | assert(!"A/C".ops.isAllUpperCase) 655 | } 656 | 657 | test("test string is mixed case") { 658 | assert(!nullString.ops.isMixedCase) 659 | assert(!Strings.EMPTY.ops.isMixedCase) 660 | assert(!" ".ops.isMixedCase) 661 | assert(!Some("A").ops.isMixedCase) 662 | assert(!"a".ops.isMixedCase) 663 | assert(!"/".ops.isMixedCase) 664 | assert(!"A/".ops.isMixedCase) 665 | assert(!"/b".ops.isMixedCase) 666 | assert(!"abc".ops.isMixedCase) 667 | assert(!"ABC".ops.isMixedCase) 668 | assert("aBc".ops.isMixedCase) 669 | assert("aBc ".ops.isMixedCase) 670 | assert("A c".ops.isMixedCase) 671 | assert("aBc\n".ops.isMixedCase) 672 | assert("A1c".ops.isMixedCase) 673 | assert("a/C".ops.isMixedCase) 674 | } 675 | 676 | test("test lang 623") { 677 | assert("\u00DE".ops.replaceChars('\u00DE', 't').contains("t")) 678 | assert(Some("\u00FE").ops.replaceChars('\u00FE', 't').contains("t")) 679 | } 680 | 681 | test("test lang 666") { 682 | assert("120.00".ops.stripEnd(".0").contains("12")) 683 | assert("121.00".ops.stripEnd(Some(".0")).contains("121")) 684 | } 685 | 686 | test("test string left pad with size and pad char") { 687 | assert(noneString.ops.leftPad(5, ' ').isEmpty) 688 | assert("".ops.leftPad(5, ' ').contains(" ")) 689 | assert("abc".ops.leftPad(5, ' ').contains(" abc")) 690 | assert("abc".ops.leftPad(5, 'x').contains("xxabc")) 691 | assert("abc".ops.leftPad(5, '\uffff').contains("\uffff\uffffabc")) 692 | assert("abc".ops.leftPad(2, ' ').contains("abc")) 693 | val str = "aaa".ops.leftPad(10000, 'a').get // bigger than pad length 694 | assert(10000 == str.length) 695 | assert(str.ops.containsOnly('a')) 696 | } 697 | 698 | test("test string left pad with size and pad string") { 699 | assert(nullString.ops.leftPad(5, "-+").isEmpty) 700 | assert(noneString.ops.leftPad(5, nullString).isEmpty) 701 | assert("".ops.leftPad(5, " ").contains(" ")) 702 | assert(Some("abc").ops.leftPad(7, "-+").contains("-+-+abc")) 703 | assert("abc".ops.leftPad(6, "-+~").contains("-+~abc")) 704 | assert("abc".ops.leftPad(5, "-+~").contains("-+abc")) 705 | assert("abc".ops.leftPad(2, " ").contains("abc")) 706 | assert("abc".ops.leftPad(-1, Some(" ")).contains("abc")) 707 | assert(Some("abc").ops.leftPad(5, noneString).contains(" abc")) 708 | assert("abc".ops.leftPad(5, Some("")).contains(" abc")) 709 | } 710 | 711 | test("test string lower case") { 712 | assert(nullString.ops.lowerCase.isEmpty) 713 | assert(noneString.ops.lowerCase(Locale.ENGLISH).isEmpty) 714 | assert("fOo test THING".ops.lowerCase.contains("foo test thing"), "lowerCase(String) failed") 715 | assert("".ops.lowerCase.contains(""), "lowerCase(empty-string) failed") 716 | assert("fOo test THING".ops.lowerCase(Locale.ENGLISH).contains("foo test thing"), "lowerCase(String, Locale) failed") 717 | assert("".ops.lowerCase(Locale.ENGLISH).contains(""), "lowerCase(empty-string, Locale) failed") 718 | } 719 | 720 | test("test string normalize space") { 721 | // Java says a non-breaking whitespace is not a whitespace. 722 | assert(!Character.isWhitespace('\u00A0')) 723 | // 724 | assert(nullString.ops.normalizeSpace.isEmpty) 725 | assert(Some("").ops.normalizeSpace.contains("")) 726 | assert(" ".ops.normalizeSpace.contains("")) 727 | assert("\t".ops.normalizeSpace.contains("")) 728 | assert("\n".ops.normalizeSpace.contains("")) 729 | assert("\u0009".ops.normalizeSpace.contains("")) 730 | assert("\u000B".ops.normalizeSpace.contains("")) 731 | assert("\u000C".ops.normalizeSpace.contains("")) 732 | assert("\u001C".ops.normalizeSpace.contains("")) 733 | assert("\u001D".ops.normalizeSpace.contains("")) 734 | assert("\u001E".ops.normalizeSpace.contains("")) 735 | assert("\u001F".ops.normalizeSpace.contains("")) 736 | assert("\f".ops.normalizeSpace.contains("")) 737 | assert("\r".ops.normalizeSpace.contains("")) 738 | assert(" a ".ops.normalizeSpace.contains("a")) 739 | assert(" a b c ".ops.normalizeSpace.contains("a b c")) 740 | assert("a\t\f\r b\u000B c\n".ops.normalizeSpace.contains("a b c")) 741 | assert(("a\t\f\r " + HARD_SPACE + HARD_SPACE + "b\u000B c\n").ops.normalizeSpace.contains("a b c")) 742 | assert("\u0000b".ops.normalizeSpace.contains("b")) 743 | assert("b\u0000".ops.normalizeSpace.contains("b")) 744 | } 745 | 746 | test("test string overlay with start end") { 747 | assert(nullString.ops.overlay(noneString, 2, 4).isEmpty) 748 | assert(noneString.ops.overlay(nullString, -2, -4).isEmpty) 749 | 750 | assert("".ops.overlay(noneString, 0, 0).contains("")) 751 | assert("".ops.overlay("", 0, 0).contains("")) 752 | assert("".ops.overlay("zzzz", 0, 0).contains("zzzz")) 753 | assert("".ops.overlay("zzzz", 2, 4).contains("zzzz")) 754 | assert("".ops.overlay("zzzz", -2, -4).contains("zzzz")) 755 | 756 | assert("abcdef".ops.overlay(nullString, 2, 4).contains("abef")) 757 | assert("abcdef".ops.overlay(noneString, 4, 2).contains("abef")) 758 | assert(Some("abcdef").ops.overlay("", 2, 4).contains("abef")) 759 | assert("abcdef".ops.overlay(Some(""), 4, 2).contains("abef")) 760 | assert("abcdef".ops.overlay("zzzz", 2, 4).contains("abzzzzef")) 761 | assert("abcdef".ops.overlay("zzzz", 4, 2).contains("abzzzzef")) 762 | 763 | assert("abcdef".ops.overlay("zzzz", -1, 4).contains("zzzzef")) 764 | assert("abcdef".ops.overlay("zzzz", 4, -1).contains("zzzzef")) 765 | assert("abcdef".ops.overlay("zzzz", -2, -1).contains("zzzzabcdef")) 766 | assert("abcdef".ops.overlay("zzzz", -1, -2).contains("zzzzabcdef")) 767 | assert("abcdef".ops.overlay("zzzz", 4, 10).contains("abcdzzzz")) 768 | assert("abcdef".ops.overlay("zzzz", 10, 4).contains("abcdzzzz")) 769 | assert("abcdef".ops.overlay("zzzz", 8, 10).contains("abcdefzzzz")) 770 | assert("abcdef".ops.overlay("zzzz", 10, 8).contains("abcdefzzzz")) 771 | } 772 | 773 | test("test string prepend if missing") { 774 | assert(nullString.ops.prependIfMissing(noneString).isEmpty, "prependIfMissing(null,null)") 775 | assert("abc".ops.prependIfMissing(nullString).contains("abc"), "prependIfMissing(abc,null)") 776 | assert(Some("").ops.prependIfMissing("xyz").contains("xyz"), "prependIfMissing(\"\",xyz)") 777 | assert("abc".ops.prependIfMissing(Some("xyz")).contains("xyzabc"), "prependIfMissing(abc,xyz)") 778 | assert("xyzabc".ops.prependIfMissing("xyz").contains("xyzabc"), "prependIfMissing(xyzabc,xyz)") 779 | assert("XYZabc".ops.prependIfMissing("xyz").contains("xyzXYZabc"), "prependIfMissing(XYZabc,xyz)") 780 | 781 | assert( 782 | nullString.ops.prependIfMissing(noneString, null.asInstanceOf[Array[CharSequence]]: _*).isEmpty, 783 | "prependIfMissing(null,null null)" 784 | ) 785 | assert( 786 | "abc".ops.prependIfMissing(nullString, null.asInstanceOf[Array[CharSequence]]: _*).contains("abc"), 787 | "prependIfMissing(abc,null,null)" 788 | ) 789 | assert("".ops.prependIfMissing("xyz", null.asInstanceOf[Array[CharSequence]]: _*).contains("xyz"), "prependIfMissing(\"\",xyz,null)") 790 | assert("abc".ops.prependIfMissing("xyz", nullString).contains("xyzabc"), "prependIfMissing(abc,xyz,{null})") 791 | assert("abc".ops.prependIfMissing("xyz", "").contains("abc"), "prependIfMissing(abc,xyz,\"\")") 792 | assert("abc".ops.prependIfMissing("xyz", "mno").contains("xyzabc"), "prependIfMissing(abc,xyz,mno)") 793 | assert("xyzabc".ops.prependIfMissing("xyz", "mno").contains("xyzabc"), "prependIfMissing(xyzabc,xyz,mno)") 794 | assert("mnoabc".ops.prependIfMissing("xyz", "mno").contains("mnoabc"), "prependIfMissing(mnoabc,xyz,mno)") 795 | assert("XYZabc".ops.prependIfMissing("xyz", "mno").contains("xyzXYZabc"), "prependIfMissing(XYZabc,xyz,mno)") 796 | assert("MNOabc".ops.prependIfMissing("xyz", "mno").contains("xyzMNOabc"), "prependIfMissing(MNOabc,xyz,mno)") 797 | } 798 | 799 | test("test string prepend if missing ignore case") { 800 | assert(nullString.ops.prependIfMissingIgnoreCase(noneString).isEmpty, "prependIfMissingIgnoreCase(null,null)") 801 | assert("abc".ops.prependIfMissingIgnoreCase(nullString).contains("abc"), "prependIfMissingIgnoreCase(abc,null)") 802 | assert("".ops.prependIfMissingIgnoreCase("xyz").contains("xyz"), "prependIfMissingIgnoreCase(\"\",xyz)") 803 | assert("abc".ops.prependIfMissingIgnoreCase("xyz").contains("xyzabc"), "prependIfMissingIgnoreCase(abc,xyz)") 804 | assert("xyzabc".ops.prependIfMissingIgnoreCase("xyz").contains("xyzabc"), "prependIfMissingIgnoreCase(xyzabc,xyz)") 805 | assert("XYZabc".ops.prependIfMissingIgnoreCase("xyz").contains("XYZabc"), "prependIfMissingIgnoreCase(XYZabc,xyz)") 806 | 807 | assert( 808 | noneString.ops.prependIfMissingIgnoreCase(nullString, null.asInstanceOf[Array[CharSequence]]: _*).isEmpty, 809 | "prependIfMissingIgnoreCase(null,null null)" 810 | ) 811 | assert( 812 | "abc".ops.prependIfMissingIgnoreCase(noneString, null.asInstanceOf[Array[CharSequence]]: _*).contains("abc"), 813 | "prependIfMissingIgnoreCase(abc,null,null)" 814 | ) 815 | assert( 816 | "".ops.prependIfMissingIgnoreCase("xyz", null.asInstanceOf[Array[CharSequence]]: _*).contains("xyz"), 817 | "prependIfMissingIgnoreCase(\"\",xyz,null)" 818 | ) 819 | assert("abc".ops.prependIfMissingIgnoreCase("xyz", noneString).contains("xyzabc"), "prependIfMissingIgnoreCase(abc,xyz,{null})") 820 | assert("abc".ops.prependIfMissingIgnoreCase("xyz", "").contains("abc"), "prependIfMissingIgnoreCase(abc,xyz,\"\")") 821 | assert("abc".ops.prependIfMissingIgnoreCase("xyz", "mno").contains("xyzabc"), "prependIfMissingIgnoreCase(abc,xyz,mno)") 822 | assert(Some("xyzabc").ops.prependIfMissingIgnoreCase("xyz", "mno").contains("xyzabc"), "prependIfMissingIgnoreCase(xyzabc,xyz,mno)") 823 | assert("mnoabc".ops.prependIfMissingIgnoreCase("xyz", "mno").contains("mnoabc"), "prependIfMissingIgnoreCase(mnoabc,xyz,mno)") 824 | assert("XYZabc".ops.prependIfMissingIgnoreCase("xyz", "mno").contains("XYZabc"), "prependIfMissingIgnoreCase(XYZabc,xyz,mno)") 825 | assert("MNOabc".ops.prependIfMissingIgnoreCase("xyz", "mno").contains("MNOabc"), "prependIfMissingIgnoreCase(MNOabc,xyz,mno)") 826 | } 827 | 828 | test("test string recapitalize") { 829 | // reflection type of tests: Sentences. 830 | assert(SENTENCE_UNCAP.ops.capitalize.ops.uncapitalize.contains(SENTENCE_UNCAP), "uncapitalize(capitalize(String)) failed") 831 | assert(SENTENCE_CAP.ops.uncapitalize.ops.capitalize.contains(SENTENCE_CAP), "capitalize(uncapitalize(String)) failed") 832 | 833 | // reflection type of tests: One word. 834 | assert(FOO_UNCAP.ops.capitalize.ops.uncapitalize.contains(FOO_UNCAP), "uncapitalize(capitalize(String)) failed") 835 | assert(FOO_CAP.ops.uncapitalize.ops.capitalize.contains(FOO_CAP), "capitalize(uncapitalize(String)) failed") 836 | } 837 | 838 | test("test string remove string") { 839 | // StringUtils.remove(null, *) = null 840 | assert(nullString.ops.remove(nullString).isEmpty) 841 | assert(noneString.ops.remove("").isEmpty) 842 | assert(noneString.ops.remove("a").isEmpty) 843 | 844 | // StringUtils.remove("", *) = "" 845 | assert("".ops.remove(nullString).contains("")) 846 | assert("".ops.remove("").contains("")) 847 | assert(Some("").ops.remove("a").contains("")) 848 | 849 | // StringUtils.remove(*, null) = * 850 | assert(nullString.ops.remove(noneString).isEmpty) 851 | assert("".ops.remove(nullString).contains("")) 852 | assert("a".ops.remove(nullString).contains("a")) 853 | 854 | // StringUtils.remove(*, "") = * 855 | assert(noneString.ops.remove("").isEmpty) 856 | assert("".ops.remove("").contains("")) 857 | assert("a".ops.remove("").contains("a")) 858 | 859 | // StringUtils.remove("queued", "ue") = "qd" 860 | assert("queued".ops.remove("ue").contains("qd")) 861 | 862 | // StringUtils.remove("queued", "zz") = "queued" 863 | assert("queued".ops.remove("zz").contains("queued")) 864 | } 865 | 866 | test("test string remove end") { 867 | assert(noneString.ops.removeEnd(nullString).isEmpty) 868 | assert(nullString.ops.removeEnd("").isEmpty) 869 | assert(nullString.ops.removeEnd(Some("a")).isEmpty) 870 | 871 | // StringUtils.removeEnd(*, null) = * 872 | assert("".ops.removeEnd(nullString).contains("")) 873 | assert(Some("").ops.removeEnd("").contains("")) 874 | assert("".ops.removeEnd("a").contains("")) 875 | 876 | // All others: 877 | assert("www.domain.com.".ops.removeEnd(Some(".com")).contains("www.domain.com.")) 878 | assert("www.domain.com".ops.removeEnd(".com").contains("www.domain")) 879 | assert("www.domain".ops.removeEnd(".com").contains("www.domain")) 880 | assert("domain.com".ops.removeEnd("").contains("domain.com")) 881 | assert("domain.com".ops.removeEnd(noneString).contains("domain.com")) 882 | } 883 | 884 | test("test string remove end ignore case") { 885 | assert(noneString.ops.removeEndIgnoreCase(nullString).isEmpty, "removeEndIgnoreCase(null, null)") 886 | assert(nullString.ops.removeEndIgnoreCase("").isEmpty, "removeEndIgnoreCase(null, \"\")") 887 | assert(nullString.ops.removeEndIgnoreCase("a").isEmpty, "removeEndIgnoreCase(null, \"a\")") 888 | 889 | // StringUtils.removeEnd(*, null) = * 890 | assert("".ops.removeEndIgnoreCase(nullString).contains(""), "removeEndIgnoreCase(\"\", null)") 891 | assert("".ops.removeEndIgnoreCase("").contains(""), "removeEndIgnoreCase(\"\", \"\")") 892 | assert("".ops.removeEndIgnoreCase("a").contains(""), "removeEndIgnoreCase(\"\", \"a\")") 893 | 894 | // All others: 895 | assert( 896 | "www.domain.com.".ops.removeEndIgnoreCase(".com") contains "www.domain.com.", 897 | "removeEndIgnoreCase(\"www.domain.com.\", \".com\")" 898 | ) 899 | assert("www.domain.com".ops.removeEndIgnoreCase(".com").contains("www.domain"), "removeEndIgnoreCase(\"www.domain.com\", \".com\")") 900 | assert("www.domain".ops.removeEndIgnoreCase(".com") contains "www.domain", "removeEndIgnoreCase(\"www.domain\", \".com\")") 901 | assert("domain.com".ops.removeEndIgnoreCase("") contains "domain.com", "removeEndIgnoreCase(\"domain.com\", \"\")") 902 | assert("domain.com".ops.removeEndIgnoreCase(nullString) contains "domain.com", "removeEndIgnoreCase(\"domain.com\", null)") 903 | 904 | // Case insensitive: 905 | assert("www.domain.com".ops.removeEndIgnoreCase(".COM") contains "www.domain", "removeEndIgnoreCase(\"www.domain.com\", \".COM\")") 906 | assert("www.domain.COM".ops.removeEndIgnoreCase(".com") contains "www.domain", "removeEndIgnoreCase(\"www.domain.COM\", \".com\")") 907 | } 908 | 909 | test("string test remove ignore case") { 910 | // StringUtils.removeIgnoreCase(null, *) = null 911 | assert(noneString.ops.removeIgnoreCase(nullString).isEmpty) 912 | assert(nullString.ops.removeIgnoreCase("").isEmpty) 913 | assert(noneString.ops.removeIgnoreCase("a").isEmpty) 914 | 915 | // StringUtils.removeIgnoreCase("", *) = "" 916 | assert("".ops.removeIgnoreCase(nullString).contains("")) 917 | assert("".ops.removeIgnoreCase(noneString).contains("")) 918 | assert("".ops.removeIgnoreCase("a").contains("")) 919 | 920 | // StringUtils.removeIgnoreCase(*, null) = * 921 | assert(nullString.ops.removeIgnoreCase(nullString).isEmpty) 922 | assert("".ops.removeIgnoreCase(noneString).contains("")) 923 | assert("a".ops.removeIgnoreCase(nullString).contains("a")) 924 | 925 | // StringUtils.removeIgnoreCase(*, "") = * 926 | assert(nullString.ops.removeIgnoreCase("").isEmpty) 927 | assert("".ops.removeIgnoreCase(Some("")).contains("")) 928 | assert("a".ops.removeIgnoreCase(Some("")).contains("a")) 929 | 930 | // StringUtils.removeIgnoreCase("queued", "ue") = "qd" 931 | assert("queued".ops.removeIgnoreCase("ue").contains("qd")) 932 | 933 | // StringUtils.removeIgnoreCase("queued", "zz") = "queued" 934 | assert("queued".ops.removeIgnoreCase("zz").contains("queued")) 935 | 936 | // IgnoreCase 937 | // StringUtils.removeIgnoreCase("quEUed", "UE") = "qd" 938 | assert("quEUed".ops.removeIgnoreCase("UE").contains("qd")) 939 | 940 | // StringUtils.removeIgnoreCase("queued", "zZ") = "queued" 941 | assert(Some("queued").ops.removeIgnoreCase("zZ").contains("queued")) 942 | 943 | // StringUtils.removeIgnoreCase("\u0130x", "x") = "\u0130" 944 | assert("\u0130x".ops.removeIgnoreCase("x").contains("\u0130")) 945 | 946 | // LANG-1453 947 | "İa".ops.removeIgnoreCase("a") 948 | } 949 | 950 | test("test string remove start") { 951 | // StringUtils.removeStart("", *) = "" 952 | assert(nullString.ops.removeStart(noneString).isEmpty) 953 | assert(nullString.ops.removeStart("").isEmpty) 954 | assert(noneString.ops.removeStart("a").isEmpty) 955 | 956 | // StringUtils.removeStart(*, null) = * 957 | assert("".ops.removeStart(nullString) contains "") 958 | assert("".ops.removeStart("") contains "") 959 | assert("".ops.removeStart("a") contains "") 960 | 961 | // All others: 962 | assert(Some("www.domain.com").ops.removeStart(Some("www.")) contains "domain.com") 963 | assert("domain.com".ops.removeStart("www.") contains "domain.com") 964 | assert("domain.com".ops.removeStart("").contains("domain.com")) 965 | assert("domain.com".ops.removeStart(noneString).contains("domain.com")) 966 | } 967 | 968 | test("test string remove start ignore case") { 969 | // StringUtils.removeStart("", *) = "" 970 | assert(nullString.ops.removeStartIgnoreCase(nullString).isEmpty, "removeStartIgnoreCase(null, null)") 971 | assert(noneString.ops.removeStartIgnoreCase(Some("")).isEmpty, "removeStartIgnoreCase(null, \"\")") 972 | assert(nullString.ops.removeStartIgnoreCase("a").isEmpty, "removeStartIgnoreCase(null, \"a\")") 973 | 974 | // StringUtils.removeStart(*, null) = * 975 | assert("".ops.removeStartIgnoreCase(nullString).contains(""), "removeStartIgnoreCase(\"\", null)") 976 | assert("".ops.removeStartIgnoreCase("").contains(""), "removeStartIgnoreCase(\"\", \"\")") 977 | assert("".ops.removeStartIgnoreCase("a").contains(""), "removeStartIgnoreCase(\"\", \"a\")") 978 | 979 | // All others: 980 | assert("www.domain.com".ops.removeStartIgnoreCase("www.") contains "domain.com", "removeStartIgnoreCase(\"www.domain.com\", \"www.\")") 981 | assert("domain.com".ops.removeStartIgnoreCase("www.") contains "domain.com", "removeStartIgnoreCase(\"domain.com\", \"www.\")") 982 | assert(Some("domain.com").ops.removeStartIgnoreCase("") contains "domain.com", "removeStartIgnoreCase(\"domain.com\", \"\")") 983 | assert("domain.com".ops.removeStartIgnoreCase(nullString) contains "domain.com", "removeStartIgnoreCase(\"domain.com\", null)") 984 | 985 | // Case insensitive: 986 | assert("www.domain.com".ops.removeStartIgnoreCase("WWW.").contains("domain.com"), "removeStartIgnoreCase(\"www.domain.com\", \"WWW.\")") 987 | 988 | } 989 | 990 | test("test string repeat with repeat times") { 991 | assert(noneString.ops.repeat(2).isEmpty) 992 | assert(Some("ab").ops.repeat(0).contains("")) 993 | assert("".ops.repeat(3).contains("")) 994 | assert("a".ops.repeat(3).contains("aaa")) 995 | assert("a".ops.repeat(-2).contains("")) 996 | assert("ab".ops.repeat(3).contains("ababab")) 997 | assert("abc".ops.repeat(3).contains("abcabcabc")) 998 | val str = "a".ops.repeat(10000) // bigger than pad limit 999 | assert(10000 == str.get.length) 1000 | assert(str.ops.containsOnly('a')) 1001 | } 1002 | 1003 | test("test string repeat separator and times") { 1004 | assert(noneString.ops.repeat(noneString, 2).isEmpty) 1005 | assert(nullString.ops.repeat("x", 2).isEmpty) 1006 | assert("".ops.repeat(nullString, 2).contains("")) 1007 | 1008 | assert("ab".ops.repeat("", 0).contains("")) 1009 | assert("".ops.repeat("", 2).contains("")) 1010 | 1011 | assert("".ops.repeat("x", 3).contains("xx")) 1012 | 1013 | assert("?".ops.repeat(", ", 3).contains("?, ?, ?")) 1014 | } 1015 | 1016 | test("test string replace string array to string array") { 1017 | // JAVADOC TESTS START 1018 | assert(nullString.ops.replaceEach(Array[String]("a"), Array[String]("b")).isEmpty) 1019 | assert("".ops.replaceEach(Array[String]("a"), Array[String]("b")) contains "") 1020 | assert("aba".ops.replaceEach(null, null) contains "aba") 1021 | assert("aba".ops.replaceEach(new Array[String](0), null) contains "aba") 1022 | assert(Some("aba").ops.replaceEach(null, new Array[String](0)) contains "aba") 1023 | assert("aba".ops.replaceEach(Array[String]("a"), null) contains "aba") 1024 | 1025 | assert("aba".ops.replaceEach(Array[String]("a"), Array[String]("")) contains "b") 1026 | assert("aba".ops.replaceEach(Array[String](null), Array[String]("a")) contains "aba") 1027 | assert("abcde".ops.replaceEach(Array[String]("ab", "d"), Array[String]("w", "t")) contains "wcte") 1028 | assert("abcde".ops.replaceEach(Array[String]("ab", "d"), Array[String]("d", "t")) contains "dcte") 1029 | // JAVADOC TESTS END 1030 | 1031 | assert("abc".ops.replaceEach(Array[String]("a", "b"), Array[String]("b", "c")) contains "bcc") 1032 | assert( 1033 | "d216.102oren".ops 1034 | .replaceEach( 1035 | Array[String]( 1036 | "a", 1037 | "b", 1038 | "c", 1039 | "d", 1040 | "e", 1041 | "f", 1042 | "g", 1043 | "h", 1044 | "i", 1045 | "j", 1046 | "k", 1047 | "l", 1048 | "m", 1049 | "n", 1050 | "o", 1051 | "p", 1052 | "q", 1053 | "r", 1054 | "s", 1055 | "t", 1056 | "u", 1057 | "v", 1058 | "w", 1059 | "x", 1060 | "y", 1061 | "z", 1062 | "A", 1063 | "B", 1064 | "C", 1065 | "D", 1066 | "E", 1067 | "F", 1068 | "G", 1069 | "H", 1070 | "I", 1071 | "J", 1072 | "K", 1073 | "L", 1074 | "M", 1075 | "N", 1076 | "O", 1077 | "P", 1078 | "Q", 1079 | "R", 1080 | "S", 1081 | "T", 1082 | "U", 1083 | "V", 1084 | "W", 1085 | "X", 1086 | "Y", 1087 | "Z", 1088 | "1", 1089 | "2", 1090 | "3", 1091 | "4", 1092 | "5", 1093 | "6", 1094 | "7", 1095 | "8", 1096 | "9" 1097 | ), 1098 | Array[String]( 1099 | "n", 1100 | "o", 1101 | "p", 1102 | "q", 1103 | "r", 1104 | "s", 1105 | "t", 1106 | "u", 1107 | "v", 1108 | "w", 1109 | "x", 1110 | "y", 1111 | "z", 1112 | "a", 1113 | "b", 1114 | "c", 1115 | "d", 1116 | "e", 1117 | "f", 1118 | "g", 1119 | "h", 1120 | "i", 1121 | "j", 1122 | "k", 1123 | "l", 1124 | "m", 1125 | "N", 1126 | "O", 1127 | "P", 1128 | "Q", 1129 | "R", 1130 | "S", 1131 | "T", 1132 | "U", 1133 | "V", 1134 | "W", 1135 | "X", 1136 | "Y", 1137 | "Z", 1138 | "A", 1139 | "B", 1140 | "C", 1141 | "D", 1142 | "E", 1143 | "F", 1144 | "G", 1145 | "H", 1146 | "I", 1147 | "J", 1148 | "K", 1149 | "L", 1150 | "M", 1151 | "5", 1152 | "6", 1153 | "7", 1154 | "8", 1155 | "9", 1156 | "1", 1157 | "2", 1158 | "3", 1159 | "4" 1160 | ) 1161 | ) 1162 | .contains("q651.506bera") 1163 | ) 1164 | 1165 | // Test null safety inside arrays - LANG-552 1166 | assert("aba".ops.replaceEach(Array[String]("a"), Array[String](null)) contains "aba") 1167 | assert("aba".ops.replaceEach(Array[String]("a", "b"), Array[String]("c", null)) contains "cbc") 1168 | 1169 | assertThrows[IllegalArgumentException] { 1170 | "abba".ops.replaceEach(Array[String]("a"), Array[String]("b", "a")) 1171 | } 1172 | } 1173 | 1174 | test("test string replace string to string") { 1175 | assert(nullString.ops.replace(nullString, noneString).isEmpty) 1176 | assert(noneString.ops.replace(nullString, "any").isEmpty) 1177 | assert(nullString.ops.replace("any", null).isEmpty) 1178 | assert(nullString.ops.replace("any", "any").isEmpty) 1179 | 1180 | assert(Some("").ops.replace(nullString, nullString).contains("")) 1181 | assert("".ops.replace(noneString, "any").contains("")) 1182 | assert("".ops.replace("any", nullString).contains("")) 1183 | assert("".ops.replace(Some("any"), Some("any")).contains("")) 1184 | 1185 | assert("FOO".ops.replace("", "any").contains("FOO")) 1186 | assert("FOO".ops.replace(nullString, "any").contains("FOO")) 1187 | assert("FOO".ops.replace("F", nullString).contains("FOO")) 1188 | assert("FOO".ops.replace(noneString, null).contains("FOO")) 1189 | 1190 | assert("foofoofoo".ops.replace("foo", "").contains("")) 1191 | assert(Some("foofoofoo").ops.replace("foo", "bar").contains("barbarbar")) 1192 | assert("foofoofoo".ops.replace("oo", "ar").contains("farfarfar")) 1193 | } 1194 | 1195 | test("test string replace string to string with max times") { 1196 | assert(nullString.ops.replace(noneString, noneString, 2).isEmpty) 1197 | assert(noneString.ops.replace(nullString, Some("any"), 2).isEmpty) 1198 | assert(nullString.ops.replace(Some("any"), noneString, 2).isEmpty) 1199 | assert(nullString.ops.replace("any", "any", 2).isEmpty) 1200 | 1201 | assert("".ops.replace(noneString, noneString, 2).contains("")) 1202 | assert("".ops.replace(noneString, "any", 2).contains("")) 1203 | assert(Some("").ops.replace("any", noneString, 2).contains("")) 1204 | assert("".ops.replace("any", "any", 2).contains("")) 1205 | 1206 | val str = new String(Array[Char]('o', 'o', 'f', 'o', 'o')) 1207 | assert(str.ops.replace("x", "", -1).contains(str)) 1208 | 1209 | assert("oofoo".ops.replace("o", "", -1).contains("f")) 1210 | assert("oofoo".ops.replace("o", "", 0).contains("oofoo")) 1211 | assert(Some("oofoo").ops.replace("o", "", 1).contains("ofoo")) 1212 | assert("oofoo".ops.replace("o", "", 2).contains("foo")) 1213 | assert("oofoo".ops.replace("o", "", 3).contains("fo")) 1214 | assert("oofoo".ops.replace("o", "", 4).contains("f")) 1215 | 1216 | assert("oofoo".ops.replace("o", "", -5).contains("f")) 1217 | assert("oofoo".ops.replace("o", "", 1000).contains("f")) 1218 | } 1219 | 1220 | test("test string replace string char to char") { 1221 | assert(nullString.ops.replaceChars('b', 'z').isEmpty) 1222 | assert("".ops.replaceChars('b', 'z').contains("")) 1223 | assert("abcba".ops.replaceChars('b', 'z').contains("azcza")) 1224 | assert("abcba".ops.replaceChars('x', 'z').contains("abcba")) 1225 | } 1226 | 1227 | test("test string replace chars string to chars string") { 1228 | assert(nullString.ops.replaceChars(nullString, nullString).isEmpty) 1229 | assert(noneString.ops.replaceChars("", null).isEmpty) 1230 | assert(nullString.ops.replaceChars("a", noneString).isEmpty) 1231 | assert(nullString.ops.replaceChars(nullString, "").isEmpty) 1232 | assert(nullString.ops.replaceChars(noneString, Some("x")).isEmpty) 1233 | 1234 | assert("".ops.replaceChars(noneString, noneString).contains("")) 1235 | assert("".ops.replaceChars("", noneString).contains("")) 1236 | assert("".ops.replaceChars("a", nullString).contains("")) 1237 | assert("".ops.replaceChars(nullString, "").contains("")) 1238 | assert("".ops.replaceChars(nullString, "x").contains("")) 1239 | 1240 | assert(Some("abc").ops.replaceChars(noneString, nullString).contains("abc")) 1241 | assert("abc".ops.replaceChars(nullString, "").contains("abc")) 1242 | assert("abc".ops.replaceChars(nullString, "x").contains("abc")) 1243 | 1244 | assert("abc".ops.replaceChars("", nullString).contains("abc")) 1245 | assert("abc".ops.replaceChars("", "").contains("abc")) 1246 | assert("abc".ops.replaceChars(Some(""), Some("x")).contains("abc")) 1247 | 1248 | assert("abc".ops.replaceChars("b", null).contains("ac")) 1249 | assert("abc".ops.replaceChars("b", "").contains("ac")) 1250 | assert("abc".ops.replaceChars("b", "x").contains("axc")) 1251 | 1252 | assert("abcba".ops.replaceChars("bc", "yz").contains("ayzya")) 1253 | assert("abcba".ops.replaceChars("bc", "y").contains("ayya")) 1254 | assert("abcba".ops.replaceChars("bc", "yzx").contains("ayzya")) 1255 | 1256 | assert("abcba".ops.replaceChars("z", "w").contains("abcba")) 1257 | assert("abcba".ops.replaceChars("z", "w").contains("abcba")) 1258 | 1259 | // Javadoc examples: 1260 | assert(Some("hello").ops.replaceChars("ho", "jy").contains("jelly")) 1261 | assert("abcba".ops.replaceChars("bc", "yz").contains("ayzya")) 1262 | assert("abcba".ops.replaceChars("bc", "y").contains("ayya")) 1263 | assert("abcba".ops.replaceChars("bc", "yzx").contains("ayzya")) 1264 | 1265 | // From https://issues.apache.org/bugzilla/show_bug.cgi?id=25454 1266 | assert("abc".ops.replaceChars("ab", "bc").contains("bcc")) 1267 | assert( 1268 | "d216.102oren".ops 1269 | .replaceChars( 1270 | "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789", 1271 | "nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM567891234" 1272 | ) 1273 | .contains("q651.506bera") 1274 | ) 1275 | } 1276 | 1277 | test("test string replace ignore case from string to string") { 1278 | assert(nullString.ops.replaceIgnoreCase(noneString, noneString).isEmpty) 1279 | assert(noneString.ops.replaceIgnoreCase(nullString, Some("any")).isEmpty) 1280 | assert(nullString.ops.replaceIgnoreCase("any", nullString).isEmpty) 1281 | assert(nullString.ops.replaceIgnoreCase("any", "any").isEmpty) 1282 | 1283 | assert("".ops.replaceIgnoreCase(nullString, nullString).contains("")) 1284 | assert(Some("").ops.replaceIgnoreCase(noneString, "any").contains("")) 1285 | assert("".ops.replaceIgnoreCase("any", nullString).contains("")) 1286 | assert("".ops.replaceIgnoreCase("any", "any").contains("")) 1287 | 1288 | assert("FOO".ops.replaceIgnoreCase("", "any").contains("FOO")) 1289 | assert("FOO".ops.replaceIgnoreCase(noneString, "any").contains("FOO")) 1290 | assert("FOO".ops.replaceIgnoreCase("F", nullString).contains("FOO")) 1291 | assert("FOO".ops.replaceIgnoreCase(nullString, nullString).contains("FOO")) 1292 | 1293 | assert("foofoofoo".ops.replaceIgnoreCase("foo", "").contains("")) 1294 | assert("foofoofoo".ops.replaceIgnoreCase("foo", "bar").contains("barbarbar")) 1295 | assert("foofoofoo".ops.replaceIgnoreCase("oo", "ar").contains("farfarfar")) 1296 | 1297 | // IgnoreCase 1298 | assert(Some("foofoofoo").ops.replaceIgnoreCase("FOO", "").contains("")) 1299 | assert("fooFOOfoo".ops.replaceIgnoreCase("foo", "bar").contains("barbarbar")) 1300 | assert("foofOOfoo".ops.replaceIgnoreCase("OO", Some("ar")).contains("farfarfar")) 1301 | } 1302 | 1303 | test("test string replace ignore case from string to string max times") { 1304 | assert(noneString.ops.replaceIgnoreCase(nullString, nullString, 2).isEmpty) 1305 | assert(nullString.ops.replaceIgnoreCase(nullString, Some("any"), 2).isEmpty) 1306 | assert(nullString.ops.replaceIgnoreCase("any", noneString, 2).isEmpty) 1307 | assert(noneString.ops.replaceIgnoreCase(Some("any"), "any", 2).isEmpty) 1308 | 1309 | assert(Some("").ops.replaceIgnoreCase(nullString, nullString, 2).contains("")) 1310 | assert("".ops.replaceIgnoreCase(nullString, "any", 2).contains("")) 1311 | assert("".ops.replaceIgnoreCase("any", nullString, 2).contains("")) 1312 | assert("".ops.replaceIgnoreCase("any", "any", 2).contains("")) 1313 | 1314 | val str = new String(Array[Char]('o', 'o', 'f', 'o', 'o')) 1315 | assert(Some(str).ops.replaceIgnoreCase("x", "", -1).contains(str)) 1316 | 1317 | assert("oofoo".ops.replaceIgnoreCase("o", "", -1).contains("f")) 1318 | assert(Some("oofoo").ops.replaceIgnoreCase("o", "", 0).contains("oofoo")) 1319 | assert("oofoo".ops.replaceIgnoreCase("o", "", 1).contains("ofoo")) 1320 | assert("oofoo".ops.replaceIgnoreCase("o", "", 2).contains("foo")) 1321 | assert("oofoo".ops.replaceIgnoreCase("o", "", 3).contains("fo")) 1322 | assert("oofoo".ops.replaceIgnoreCase("o", "", 4).contains("f")) 1323 | 1324 | assert("oofoo".ops.replaceIgnoreCase("o", "", -5).contains("f")) 1325 | assert("oofoo".ops.replaceIgnoreCase("o", "", 1000).contains("f")) 1326 | 1327 | // IgnoreCase 1328 | assert("oofoo".ops.replaceIgnoreCase("O", "", -1).contains("f")) 1329 | assert("oofoo".ops.replaceIgnoreCase("O", "", 0).contains("oofoo")) 1330 | assert("oofoo".ops.replaceIgnoreCase("O", "", 1).contains("ofoo")) 1331 | assert("oofoo".ops.replaceIgnoreCase("O", "", 2).contains("foo")) 1332 | assert("oofoo".ops.replaceIgnoreCase("O", "", 3).contains("fo")) 1333 | assert("oofoo".ops.replaceIgnoreCase("O", "", 4).contains("f")) 1334 | 1335 | assert("oofoo".ops.replaceIgnoreCase("O", "", -5).contains("f")) 1336 | assert("oofoo".ops.replaceIgnoreCase("O", "", 1000).contains("f")) 1337 | 1338 | } 1339 | 1340 | test("test string replace once from string to string") { 1341 | assert(noneString.ops.replaceOnce(nullString, nullString).isEmpty) 1342 | assert(nullString.ops.replaceOnce(nullString, "any").isEmpty) 1343 | assert(nullString.ops.replaceOnce("any", null).isEmpty) 1344 | assert(nullString.ops.replaceOnce("any", "any").isEmpty) 1345 | 1346 | assert("".ops.replaceOnce(nullString, nullString).contains("")) 1347 | assert(Some("").ops.replaceOnce(noneString, "any").contains("")) 1348 | assert("".ops.replaceOnce(Some("any"), noneString).contains("")) 1349 | assert("".ops.replaceOnce("any", "any").contains("")) 1350 | 1351 | assert("FOO".ops.replaceOnce("", "any").contains("FOO")) 1352 | assert("FOO".ops.replaceOnce(nullString, "any").contains("FOO")) 1353 | assert("FOO".ops.replaceOnce("F", nullString).contains("FOO")) 1354 | assert("FOO".ops.replaceOnce(nullString, nullString).contains("FOO")) 1355 | 1356 | assert("foofoofoo".ops.replaceOnce("foo", "").contains("foofoo")) 1357 | } 1358 | 1359 | test("test string replace once ignore case from string to string") { 1360 | assert(nullString.ops.replaceOnceIgnoreCase(nullString, nullString).isEmpty) 1361 | assert(noneString.ops.replaceOnceIgnoreCase(nullString, "any").isEmpty) 1362 | assert(nullString.ops.replaceOnceIgnoreCase(noneString, "any").isEmpty) 1363 | assert(noneString.ops.replaceOnceIgnoreCase("any", "any").isEmpty) 1364 | 1365 | assert("".ops.replaceOnceIgnoreCase(noneString, noneString).contains("")) 1366 | assert("".ops.replaceOnceIgnoreCase(noneString, "any").contains("")) 1367 | assert("".ops.replaceOnceIgnoreCase("any", nullString).contains("")) 1368 | assert(Some("").ops.replaceOnceIgnoreCase(Some("any"), Some("any")).contains("")) 1369 | 1370 | assert("FOO".ops.replaceOnceIgnoreCase("", "any").contains("FOO")) 1371 | assert("FOO".ops.replaceOnceIgnoreCase(nullString, "any").contains("FOO")) 1372 | assert("FOO".ops.replaceOnceIgnoreCase("F", null).contains("FOO")) 1373 | assert("FOO".ops.replaceOnceIgnoreCase(nullString, nullString).contains("FOO")) 1374 | 1375 | assert("foofoofoo".ops.replaceOnceIgnoreCase("foo", "").contains("foofoo")) 1376 | 1377 | // Ignore Case 1378 | assert("FoOFoofoo".ops.replaceOnceIgnoreCase("foo", "").contains("Foofoo")) 1379 | } 1380 | 1381 | test("test string reverse") { 1382 | assert(noneString.ops.reverse.isEmpty) 1383 | assert("".ops.reverse.contains("")) 1384 | assert(Some("backwards").ops.reverse.contains("sdrawkcab")) 1385 | } 1386 | 1387 | test("test string reverse delimited") { 1388 | assert(nullString.ops.reverseDelimited('.').isEmpty) 1389 | assert("".ops.reverseDelimited('.').contains("")) 1390 | assert("a.b.c".ops.reverseDelimited('.').contains("c.b.a")) 1391 | assert("a b c".ops.reverseDelimited('.').contains("a b c")) 1392 | assert("".ops.reverseDelimited('.').contains("")) 1393 | } 1394 | 1395 | test("test string right pad with size") { 1396 | assert(nullString.ops.rightPad(5).isEmpty) 1397 | assert(Some("").ops.rightPad(5).contains(" ")) 1398 | assert("abc".ops.rightPad(5).contains("abc ")) 1399 | assert("abc".ops.rightPad(2).contains("abc")) 1400 | assert(Some("abc").ops.rightPad(-1).contains("abc")) 1401 | } 1402 | 1403 | test("test string right pad with size and pad char") { 1404 | assert(nullString.ops.rightPad(5, ' ').isEmpty) 1405 | assert("".ops.rightPad(5, ' ').contains(" ")) 1406 | assert(Some("abc").ops.rightPad(5, ' ').contains("abc ")) 1407 | assert("abc".ops.rightPad(2, ' ').contains("abc")) 1408 | assert("abc".ops.rightPad(-1, ' ').contains("abc")) 1409 | assert("abc".ops.rightPad(5, 'x').contains("abcxx")) 1410 | val str = "aaa".ops.rightPad(10000, 'a') // bigger than pad length 1411 | assert(str.get.length == 10000) 1412 | assert(str.ops.containsOnly('a')) 1413 | } 1414 | 1415 | test("test string right pad with size and pad string") { 1416 | assert(nullString.ops.rightPad(5, "-+").isEmpty) 1417 | assert("".ops.rightPad(5, " ").contains(" ")) 1418 | assert(noneString.ops.rightPad(8, null).isEmpty) 1419 | assert("abc".ops.rightPad(7, Some("-+")).contains("abc-+-+")) 1420 | assert("abc".ops.rightPad(6, "-+~").contains("abc-+~")) 1421 | assert("abc".ops.rightPad(5, "-+~").contains("abc-+")) 1422 | assert("abc".ops.rightPad(2, " ").contains("abc")) 1423 | assert(Some("abc").ops.rightPad(-1, " ").contains("abc")) 1424 | assert("abc".ops.rightPad(5, null).contains("abc ")) 1425 | assert("abc".ops.rightPad(5, "").contains("abc ")) 1426 | } 1427 | 1428 | test("test string rotate with shift") { 1429 | assert(nullString.ops.rotate(1).isEmpty) 1430 | assert("".ops.rotate(1).contains("")) 1431 | assert(Some("abcdefg").ops.rotate(0).contains("abcdefg")) 1432 | assert("abcdefg".ops.rotate(2).contains("fgabcde")) 1433 | assert("abcdefg".ops.rotate(-2).contains("cdefgab")) 1434 | assert("abcdefg".ops.rotate(7).contains("abcdefg")) 1435 | assert("abcdefg".ops.rotate(-7).contains("abcdefg")) 1436 | assert("abcdefg".ops.rotate(9).contains("fgabcde")) 1437 | assert("abcdefg".ops.rotate(-9).contains("cdefgab")) 1438 | assert("abcdefg".ops.rotate(17).contains("efgabcd")) 1439 | assert("abcdefg".ops.rotate(-17).contains("defgabc")) 1440 | } 1441 | 1442 | test("test string split") { 1443 | assert(nullString.ops.split.isEmpty) 1444 | assert("".ops.split.exists(_.length == 0)) 1445 | 1446 | val str1 = "a b .c" 1447 | val res1 = str1.ops.split 1448 | assert(res1.exists(_.length == 3)) 1449 | assert(res1.exists(elements => elements.head == "a")) 1450 | assert(res1.exists(elements => elements(1) == "b")) 1451 | assert(res1.exists(elements => elements(2) == ".c")) 1452 | 1453 | val str2 = " a " 1454 | val res2 = str2.ops.split.get 1455 | assert(1 == res2.length) 1456 | assert("a" == res2.head) 1457 | 1458 | val str3 = "a" + WHITESPACE + "b" + NON_WHITESPACE + "c" 1459 | val res3 = str3.ops.split.get 1460 | assert(2 == res3.length) 1461 | assert("a" == res3.head) 1462 | assert("b" + NON_WHITESPACE + "c" == res3(1)) 1463 | } 1464 | 1465 | test("test string split with separator char") { 1466 | assert(noneString.ops.split('.').isEmpty) 1467 | assert(Some("").ops.split('.').exists(_.length == 0)) 1468 | 1469 | val str1 = "a.b.. c" 1470 | val res1 = str1.ops.split('.').get 1471 | assert(3 == res1.length) 1472 | assert("a" == res1.head) 1473 | assert("b" == res1(1)) 1474 | assert(" c" == res1.last) 1475 | 1476 | val str2 = ".a." 1477 | val res2 = str2.ops.split('.').get 1478 | assert(res2.length == 1) 1479 | assert("a" == res2.head) 1480 | 1481 | val str3 = "a b c" 1482 | val res3 = str3.ops.split(' ').get 1483 | assert(3 == res3.length) 1484 | assert("a" == res3.head) 1485 | assert("b" == res3(1)) 1486 | assert("c" == res3.last) 1487 | } 1488 | 1489 | test("test string split with separator chars string and max times") { 1490 | assert(nullString.ops.split(".").isEmpty) 1491 | assert(noneString.ops.split(".", 3).isEmpty) 1492 | 1493 | assert("".ops.split(".").exists(_.length == 0)) 1494 | assert("".ops.split(".", 3).exists(_.length == 0)) 1495 | 1496 | innerTestSplit('.', ".", ' ') 1497 | innerTestSplit('.', ".", ',') 1498 | innerTestSplit('.', ".,", 'x') 1499 | for (i <- 0 until WHITESPACE.length) { 1500 | for (j <- 0 until NON_WHITESPACE.length) { 1501 | innerTestSplit(WHITESPACE.charAt(i), null, NON_WHITESPACE.charAt(j)) 1502 | innerTestSplit(WHITESPACE.charAt(i), String.valueOf(WHITESPACE.charAt(i)), NON_WHITESPACE.charAt(j)) 1503 | } 1504 | } 1505 | 1506 | val expectedResults = Array("ab", "de fg") 1507 | val results1 = "ab de fg".ops.split(null, 2).get 1508 | assert(expectedResults.length == results1.length) 1509 | for (i <- expectedResults.indices) { 1510 | assert(expectedResults(i) == results1(i)) 1511 | } 1512 | 1513 | val expectedResults2 = Array("ab", "cd:ef") 1514 | val results2 = "ab:cd:ef".ops.split(":", 2).get 1515 | assert(expectedResults2.length == results2.length) 1516 | for (i <- expectedResults2.indices) { 1517 | assert(expectedResults2(i) == results2(i)) 1518 | } 1519 | } 1520 | 1521 | test("test string split by character type") { 1522 | assert(nullString.ops.splitByCharacterType.isEmpty) 1523 | assert("".ops.splitByCharacterType.exists(_.length == 0)) 1524 | 1525 | assert("ab de fg".ops.splitByCharacterType.exists(Objects.deepEquals(Array[String]("ab", " ", "de", " ", "fg"), _))) 1526 | 1527 | assert(Some("ab de fg").ops.splitByCharacterType.exists(Objects.deepEquals(Array[String]("ab", " ", "de", " ", "fg"), _))) 1528 | 1529 | assert("ab:cd:ef".ops.splitByCharacterType.exists(Objects.deepEquals(Array[String]("ab", ":", "cd", ":", "ef"), _))) 1530 | 1531 | assert("number5".ops.splitByCharacterType.exists(Objects.deepEquals(Array[String]("number", "5"), _))) 1532 | 1533 | assert("fooBar".ops.splitByCharacterType.exists(Objects.deepEquals(Array[String]("foo", "B", "ar"), _))) 1534 | 1535 | assert("foo200Bar".ops.splitByCharacterType.exists(Objects.deepEquals(Array[String]("foo", "200", "B", "ar"), _))) 1536 | 1537 | assert("ASFRules".ops.splitByCharacterType.exists(Objects.deepEquals(Array[String]("ASFR", "ules"), _))) 1538 | } 1539 | 1540 | test("test string split by character type camel case") { 1541 | assert(noneString.ops.splitByCharacterTypeCamelCase.isEmpty) 1542 | assert("".ops.splitByCharacterTypeCamelCase.exists(_.length == 0)) 1543 | 1544 | assert("ab de fg".ops.splitByCharacterTypeCamelCase.exists(Objects.deepEquals(Array[String]("ab", " ", "de", " ", "fg"), _))) 1545 | 1546 | assert("ab de fg".ops.splitByCharacterTypeCamelCase.exists(Objects.deepEquals(Array[String]("ab", " ", "de", " ", "fg"), _))) 1547 | 1548 | assert(Some("ab:cd:ef").ops.splitByCharacterTypeCamelCase.exists(Objects.deepEquals(Array[String]("ab", ":", "cd", ":", "ef"), _))) 1549 | 1550 | assert("number5".ops.splitByCharacterTypeCamelCase.exists(Objects.deepEquals(Array[String]("number", "5"), _))) 1551 | 1552 | assert("fooBar".ops.splitByCharacterTypeCamelCase.exists(Objects.deepEquals(Array[String]("foo", "Bar"), _))) 1553 | 1554 | assert("foo200Bar".ops.splitByCharacterTypeCamelCase.exists(Objects.deepEquals(Array[String]("foo", "200", "Bar"), _))) 1555 | 1556 | assert("ASFRules".ops.splitByCharacterTypeCamelCase.exists(Objects.deepEquals(Array[String]("ASF", "Rules"), _))) 1557 | } 1558 | 1559 | test("test string split by whole separator preserve all tokens string") { 1560 | assert(nullString.ops.splitByWholeSeparatorPreserveAllTokens(".").isEmpty) 1561 | 1562 | assert("".ops.splitByWholeSeparatorPreserveAllTokens(".").exists(_.length == 0)) 1563 | 1564 | // test whitespace 1565 | var input = "ab de fg" 1566 | var expected = Array[String]("ab", "", "", "de", "fg") 1567 | 1568 | var actual = input.ops.splitByWholeSeparatorPreserveAllTokens(null).get 1569 | assert(expected.length == actual.length) 1570 | for (i <- actual.indices) { 1571 | assert(expected(i) == actual(i)) 1572 | } 1573 | 1574 | // test delimiter singlechar 1575 | input = "1::2:::3::::4" 1576 | expected = Array[String]("1", "", "2", "", "", "3", "", "", "", "4") 1577 | 1578 | actual = input.ops.splitByWholeSeparatorPreserveAllTokens(":").get 1579 | assert(expected.length == actual.length) 1580 | for (i <- actual.indices) { 1581 | assert(expected(i) == actual(i)) 1582 | } 1583 | 1584 | // test delimiter multichar 1585 | input = "1::2:::3::::4" 1586 | expected = Array[String]("1", "2", ":3", "", "4") 1587 | 1588 | actual = input.ops.splitByWholeSeparatorPreserveAllTokens("::").get 1589 | assert(expected.length == actual.length) 1590 | for (i <- actual.indices) { 1591 | assert(expected(i) == actual(i)) 1592 | } 1593 | } 1594 | 1595 | test("test string split by whole separator preserve all tokens with separator and max times") { 1596 | assert(nullString.ops.splitByWholeSeparatorPreserveAllTokens(".", -1).isEmpty) 1597 | 1598 | assert(Some("").ops.splitByWholeSeparatorPreserveAllTokens(".", -1).exists(_.length == 0)) 1599 | 1600 | // test whitespace 1601 | var input = "ab de fg" 1602 | var expected = Array[String]("ab", "", "", "de", "fg") 1603 | 1604 | var actual = input.ops.splitByWholeSeparatorPreserveAllTokens(noneString, -1).get 1605 | assert(expected.length == actual.length) 1606 | for (i <- actual.indices) { 1607 | assert(expected(i) == actual(i)) 1608 | } 1609 | 1610 | // test delimiter singlechar 1611 | input = "1::2:::3::::4" 1612 | expected = Array[String]("1", "", "2", "", "", "3", "", "", "", "4") 1613 | 1614 | actual = input.ops.splitByWholeSeparatorPreserveAllTokens(Some(":"), -1).get 1615 | assert(expected.length == actual.length) 1616 | for (i <- actual.indices) { 1617 | assert(expected(i) == actual(i)) 1618 | } 1619 | 1620 | // test delimiter multichar 1621 | input = "1::2:::3::::4" 1622 | expected = Array[String]("1", "2", ":3", "", "4") 1623 | 1624 | actual = input.ops.splitByWholeSeparatorPreserveAllTokens("::", -1).get 1625 | assert(expected.length == actual.length) 1626 | for (i <- actual.indices) { 1627 | assert(expected(i) == actual(i)) 1628 | } 1629 | 1630 | // test delimiter char with max 1631 | input = "1::2::3:4" 1632 | expected = Array[String]("1", "", "2", ":3:4") 1633 | 1634 | actual = input.ops.splitByWholeSeparatorPreserveAllTokens(":", 4).get 1635 | assert(expected.length == actual.length) 1636 | for (i <- actual.indices) { 1637 | assert(expected(i) == actual(i)) 1638 | } 1639 | } 1640 | 1641 | test("test string split by whole string separator") { 1642 | assert(nullString.ops.splitByWholeSeparator(".").isEmpty) 1643 | 1644 | assert("".ops.splitByWholeSeparator(".").exists(_.length == 0)) 1645 | 1646 | val stringToSplitOnNulls = "ab de fg" 1647 | val splitOnNullExpectedResults = Array("ab", "de", "fg") 1648 | 1649 | val splitOnNullResults = stringToSplitOnNulls.ops.splitByWholeSeparator(null).get 1650 | assert(splitOnNullExpectedResults.length == splitOnNullResults.length) 1651 | for (i <- splitOnNullExpectedResults.indices) { 1652 | assert(splitOnNullExpectedResults(i) == splitOnNullResults(i)) 1653 | } 1654 | 1655 | val stringToSplitOnCharactersAndString = "abstemiouslyaeiouyabstemiously" 1656 | 1657 | val splitOnStringExpectedResults = Array("abstemiously", "abstemiously") 1658 | val splitOnStringResults = stringToSplitOnCharactersAndString.ops.splitByWholeSeparator("aeiouy").get 1659 | assert(splitOnStringExpectedResults.length == splitOnStringResults.length) 1660 | for (i <- splitOnStringExpectedResults.indices) { 1661 | assert(splitOnStringExpectedResults(i) == splitOnStringResults(i)) 1662 | } 1663 | 1664 | val splitWithMultipleSeparatorExpectedResults = Array("ab", "cd", "ef") 1665 | val splitWithMultipleSeparator = "ab:cd::ef".ops.splitByWholeSeparator(":").get 1666 | assert(splitWithMultipleSeparatorExpectedResults.length == splitWithMultipleSeparator.length) 1667 | for (i <- splitWithMultipleSeparatorExpectedResults.indices) { 1668 | assert(splitWithMultipleSeparatorExpectedResults(i) == splitWithMultipleSeparator(i)) 1669 | } 1670 | } 1671 | 1672 | test("test split by whole string separator and max times") { 1673 | assert(noneString.ops.splitByWholeSeparator(".", 3).isEmpty) 1674 | 1675 | assert("".ops.splitByWholeSeparator(".", 3).exists(_.length == 0)) 1676 | 1677 | val stringToSplitOnNulls = "ab de fg" 1678 | val splitOnNullExpectedResults = Array("ab", "de fg") 1679 | // String[] splitOnNullExpectedResults = { "ab", "de" } ; 1680 | 1681 | val splitOnNullResults = Some(stringToSplitOnNulls).ops.splitByWholeSeparator(null, 2).get 1682 | assert(splitOnNullExpectedResults.length == splitOnNullResults.length) 1683 | for (i <- splitOnNullExpectedResults.indices) { 1684 | assert(splitOnNullExpectedResults(i) == splitOnNullResults(i)) 1685 | } 1686 | 1687 | val stringToSplitOnCharactersAndString = "abstemiouslyaeiouyabstemiouslyaeiouyabstemiously" 1688 | 1689 | val splitOnStringExpectedResults = Array("abstemiously", "abstemiouslyaeiouyabstemiously") 1690 | // String[] splitOnStringExpectedResults = { "abstemiously", "abstemiously" } ; 1691 | val splitOnStringResults = stringToSplitOnCharactersAndString.ops.splitByWholeSeparator("aeiouy", 2).get 1692 | assert(splitOnStringExpectedResults.length == splitOnStringResults.length) 1693 | for (i <- splitOnStringExpectedResults.indices) { 1694 | assert(splitOnStringExpectedResults(i) == splitOnStringResults(i)) 1695 | } 1696 | } 1697 | 1698 | test("test string split preserve all tokens") { 1699 | assert(noneString.ops.splitPreserveAllTokens.isEmpty) 1700 | assert("".ops.splitPreserveAllTokens.exists(_.length == 0)) 1701 | 1702 | var str = "abc def" 1703 | var res = Some(str).ops.splitPreserveAllTokens.get 1704 | assert(2 == res.length) 1705 | assert("abc" == res(0)) 1706 | assert("def" == res(1)) 1707 | 1708 | str = "abc def" 1709 | res = str.ops.splitPreserveAllTokens.get 1710 | assert(3 == res.length) 1711 | assert("abc" == res(0)) 1712 | assert("" == res(1)) 1713 | assert("def" == res(2)) 1714 | 1715 | str = " abc " 1716 | res = str.ops.splitPreserveAllTokens.get 1717 | assert(3 == res.length) 1718 | assert("" == res(0)) 1719 | assert("abc" == res(1)) 1720 | assert("" == res(2)) 1721 | 1722 | str = "a b .c" 1723 | res = str.ops.splitPreserveAllTokens.get 1724 | assert(3 == res.length) 1725 | assert("a" == res(0)) 1726 | assert("b" == res(1)) 1727 | assert(".c" == res(2)) 1728 | 1729 | str = " a b .c" 1730 | res = str.ops.splitPreserveAllTokens.get 1731 | assert(4 == res.length) 1732 | assert("" == res(0)) 1733 | assert("a" == res(1)) 1734 | assert("b" == res(2)) 1735 | assert(".c" == res(3)) 1736 | 1737 | str = "a b .c" 1738 | res = str.ops.splitPreserveAllTokens.get 1739 | assert(5 == res.length) 1740 | assert("a" == res(0)) 1741 | assert("" == res(1)) 1742 | assert("b" == res(2)) 1743 | assert("" == res(3)) 1744 | assert(".c" == res(4)) 1745 | 1746 | str = " a " 1747 | res = str.ops.splitPreserveAllTokens.get 1748 | assert(4 == res.length) 1749 | assert("" == res(0)) 1750 | assert("a" == res(1)) 1751 | assert("" == res(2)) 1752 | assert("" == res(3)) 1753 | 1754 | str = " a b" 1755 | res = str.ops.splitPreserveAllTokens.get 1756 | assert(4 == res.length) 1757 | assert("" == res(0)) 1758 | assert("a" == res(1)) 1759 | assert("" == res(2)) 1760 | assert("b" == res(3)) 1761 | 1762 | str = "a" + WHITESPACE + "b" + NON_WHITESPACE + "c" 1763 | res = str.ops.splitPreserveAllTokens.get 1764 | assert(WHITESPACE.length + 1 == res.length) 1765 | assert("a" == res(0)) 1766 | for (i <- 1 until WHITESPACE.length - 1) { 1767 | assert("" == res(i)) 1768 | } 1769 | assert("b" + NON_WHITESPACE + "c" == res(WHITESPACE.length)) 1770 | } 1771 | 1772 | test("test string split preserve all tokens by separator char") { 1773 | assert(noneString.ops.splitPreserveAllTokens('.').isEmpty) 1774 | assert("".ops.splitPreserveAllTokens('.').exists(_.length == 0)) 1775 | 1776 | var str = "a.b. c" 1777 | var res = Some(str).ops.splitPreserveAllTokens('.').get 1778 | assert(3 == res.length) 1779 | assert("a" == res(0)) 1780 | assert("b" == res(1)) 1781 | assert(" c" == res(2)) 1782 | 1783 | str = "a.b.. c" 1784 | res = str.ops.splitPreserveAllTokens('.').get 1785 | assert(4 == res.length) 1786 | assert("a" == res(0)) 1787 | assert("b" == res(1)) 1788 | assert("" == res(2)) 1789 | assert(" c" == res(3)) 1790 | 1791 | str = ".a." 1792 | res = str.ops.splitPreserveAllTokens('.').get 1793 | assert(3 == res.length) 1794 | assert("" == res(0)) 1795 | assert("a" == res(1)) 1796 | assert("" == res(2)) 1797 | 1798 | str = ".a.." 1799 | res = str.ops.splitPreserveAllTokens('.').get 1800 | assert(4 == res.length) 1801 | assert("" == res(0)) 1802 | assert("a" == res(1)) 1803 | assert("" == res(2)) 1804 | assert("" == res(3)) 1805 | 1806 | str = "..a." 1807 | res = str.ops.splitPreserveAllTokens('.').get 1808 | assert(4 == res.length) 1809 | assert("" == res(0)) 1810 | assert("" == res(1)) 1811 | assert("a" == res(2)) 1812 | assert("" == res(3)) 1813 | 1814 | str = "..a" 1815 | res = str.ops.splitPreserveAllTokens('.').get 1816 | assert(3 == res.length) 1817 | assert("" == res(0)) 1818 | assert("" == res(1)) 1819 | assert("a" == res(2)) 1820 | 1821 | str = "a b c" 1822 | res = Some(str).ops.splitPreserveAllTokens(' ').get 1823 | assert(3 == res.length) 1824 | assert("a" == res(0)) 1825 | assert("b" == res(1)) 1826 | assert("c" == res(2)) 1827 | 1828 | str = "a b c" 1829 | res = str.ops.splitPreserveAllTokens(' ').get 1830 | assert(5 == res.length) 1831 | assert("a" == res(0)) 1832 | assert("" == res(1)) 1833 | assert("b" == res(2)) 1834 | assert("" == res(3)) 1835 | assert("c" == res(4)) 1836 | 1837 | str = " a b c" 1838 | res = str.ops.splitPreserveAllTokens(' ').get 1839 | assert(4 == res.length) 1840 | assert("" == res(0)) 1841 | assert("a" == res(1)) 1842 | assert("b" == res(2)) 1843 | assert("c" == res(3)) 1844 | 1845 | str = " a b c" 1846 | res = str.ops.splitPreserveAllTokens(' ').get 1847 | assert(5 == res.length) 1848 | assert("" == res(0)) 1849 | assert("" == res(1)) 1850 | assert("a" == res(2)) 1851 | assert("b" == res(3)) 1852 | assert("c" == res(4)) 1853 | 1854 | str = "a b c " 1855 | res = Some(str).ops.splitPreserveAllTokens(' ').get 1856 | assert(4 == res.length) 1857 | assert("a" == res(0)) 1858 | assert("b" == res(1)) 1859 | assert("c" == res(2)) 1860 | assert("" == res(3)) 1861 | 1862 | str = "a b c " 1863 | res = str.ops.splitPreserveAllTokens(' ').get 1864 | assert(5 == res.length) 1865 | assert("a" == res(0)) 1866 | assert("b" == res(1)) 1867 | assert("c" == res(2)) 1868 | assert("" == res(3)) 1869 | assert("" == res(3)) 1870 | 1871 | // Match example in javadoc 1872 | val expectedResults = Array("a", "", "b", "c") 1873 | val results = "a..b.c".ops.splitPreserveAllTokens('.').get 1874 | assert(expectedResults.length == results.length) 1875 | for (i <- expectedResults.indices) { 1876 | assert(expectedResults(i) == results(i)) 1877 | } 1878 | 1879 | } 1880 | 1881 | test("test string split preserve all tokens with separator char and max times") { 1882 | assert(noneString.ops.splitPreserveAllTokens(".").isEmpty) 1883 | assert(nullString.ops.splitPreserveAllTokens(".", 3).isEmpty) 1884 | 1885 | assert("".ops.splitPreserveAllTokens(Some(".")).exists(_.length == 0)) 1886 | assert(Some("").ops.splitPreserveAllTokens(".", 3).exists(_.length == 0)) 1887 | 1888 | innerTestSplitPreserveAllTokens('.', ".", ' ') 1889 | innerTestSplitPreserveAllTokens('.', ".", ',') 1890 | innerTestSplitPreserveAllTokens('.', ".,", 'x') 1891 | for (i <- 0 until WHITESPACE.length) { 1892 | for (j <- 0 until NON_WHITESPACE.length) { 1893 | innerTestSplitPreserveAllTokens(WHITESPACE.charAt(i), null, NON_WHITESPACE.charAt(j)) 1894 | innerTestSplitPreserveAllTokens(WHITESPACE.charAt(i), String.valueOf(WHITESPACE.charAt(i)), NON_WHITESPACE.charAt(j)) 1895 | } 1896 | } 1897 | 1898 | var expectedResults: Array[String] = Array("ab", "de fg") 1899 | var results: Array[String] = "ab de fg".ops.splitPreserveAllTokens(nullString, 2).get 1900 | assert(expectedResults.length == results.length) 1901 | for (i <- expectedResults.indices) { 1902 | assert(expectedResults(i) == results(i)) 1903 | } 1904 | 1905 | expectedResults = Array("ab", " de fg") 1906 | results = "ab de fg".ops.splitPreserveAllTokens(noneString, 2).get 1907 | assert(expectedResults.length == results.length) 1908 | for (i <- expectedResults.indices) { 1909 | assert(expectedResults(i) == results(i)) 1910 | } 1911 | 1912 | expectedResults = Array("ab", "::de:fg") 1913 | results = "ab:::de:fg".ops.splitPreserveAllTokens(":", 2).get 1914 | assert(expectedResults.length == results.length) 1915 | for (i <- expectedResults.indices) { 1916 | assert(expectedResults(i) == results(i)) 1917 | } 1918 | 1919 | expectedResults = Array("ab", "", " de fg") 1920 | results = Some("ab de fg").ops.splitPreserveAllTokens(nullString, 3).get 1921 | assert(expectedResults.length == results.length) 1922 | for (i <- expectedResults.indices) { 1923 | assert(expectedResults(i) == results(i)) 1924 | } 1925 | 1926 | expectedResults = Array("ab", "", "", "de fg") 1927 | results = "ab de fg".ops.splitPreserveAllTokens(noneString, 4).get 1928 | assert(expectedResults.length == results.length) 1929 | for (i <- expectedResults.indices) { 1930 | assert(expectedResults(i) == results(i)) 1931 | } 1932 | 1933 | expectedResults = Array("ab", "cd:ef") 1934 | results = "ab:cd:ef".ops.splitPreserveAllTokens(Some(":"), 2).get 1935 | assert(expectedResults.length == results.length) 1936 | for (i <- expectedResults.indices) { 1937 | assert(expectedResults(i) == results(i)) 1938 | } 1939 | 1940 | expectedResults = Array("ab", ":cd:ef") 1941 | results = "ab::cd:ef".ops.splitPreserveAllTokens(":", 2).get 1942 | assert(expectedResults.length == results.length) 1943 | for (i <- expectedResults.indices) { 1944 | assert(expectedResults(i) == results(i)) 1945 | } 1946 | 1947 | expectedResults = Array("ab", "", ":cd:ef") 1948 | results = "ab:::cd:ef".ops.splitPreserveAllTokens(":", 3).get 1949 | assert(expectedResults.length == results.length) 1950 | for (i <- expectedResults.indices) { 1951 | assert(expectedResults(i) == results(i)) 1952 | } 1953 | 1954 | expectedResults = Array("ab", "", "", "cd:ef") 1955 | results = Some("ab:::cd:ef").ops.splitPreserveAllTokens(Some(":"), 4).get 1956 | assert(expectedResults.length == results.length) 1957 | for (i <- expectedResults.indices) { 1958 | assert(expectedResults(i) == results(i)) 1959 | } 1960 | 1961 | expectedResults = Array("", "ab", "", "", "cd:ef") 1962 | results = ":ab:::cd:ef".ops.splitPreserveAllTokens(":", 5).get 1963 | assert(expectedResults.length == results.length) 1964 | for (i <- expectedResults.indices) { 1965 | assert(expectedResults(i) == results(i)) 1966 | } 1967 | 1968 | expectedResults = Array("", "", "ab", "", "", "cd:ef") 1969 | results = "::ab:::cd:ef".ops.splitPreserveAllTokens(":", 6).get 1970 | assert(expectedResults.length == results.length) 1971 | for (i <- expectedResults.indices) { 1972 | assert(expectedResults(i) == results(i)) 1973 | } 1974 | 1975 | } 1976 | 1977 | test("test string swap case") { 1978 | assert(nullString.ops.swapCase.isEmpty) 1979 | assert(Some("").ops.swapCase.contains("")) 1980 | assert(" ".ops.swapCase.contains(" ")) 1981 | 1982 | assert(Some("I").ops.swapCase.contains("i")) 1983 | assert("i".ops.swapCase.contains("I")) 1984 | assert("i am here 123".ops.swapCase.contains("I AM HERE 123")) 1985 | assert("I Am Here 123".ops.swapCase.contains("i aM hERE 123")) 1986 | assert("i am HERE 123".ops.swapCase.contains("I AM here 123")) 1987 | assert(Some("I AM HERE 123").ops.swapCase.contains("i am here 123")) 1988 | 1989 | val test = "This String contains a TitleCase character: \u01C8" 1990 | val expect = "tHIS sTRING CONTAINS A tITLEcASE CHARACTER: \u01C9" 1991 | assert(test.ops.swapCase.contains(expect)) 1992 | } 1993 | 1994 | test("test string to code points") { 1995 | val orphanedHighSurrogate = 0xd801 1996 | val orphanedLowSurrogate = 0xdc00 1997 | val supplementary = 0x2070e 1998 | 1999 | val codePoints: Array[Int] = Array('a', orphanedHighSurrogate, 'b', 'c', supplementary, 'd', orphanedLowSurrogate, 'e') 2000 | val s = new String(codePoints, 0, codePoints.length) 2001 | assert(Some(s).ops.toCodePoints.exists(e => Objects.deepEquals(e, codePoints))) 2002 | 2003 | assert(noneString.ops.toCodePoints.isEmpty) 2004 | assert("".ops.toCodePoints.exists(e => Objects.deepEquals(e, ArrayUtils.EMPTY_INT_ARRAY))) 2005 | } 2006 | 2007 | test("test string truncate with max width") { 2008 | assert(noneString.ops.truncate(12).isEmpty) 2009 | assertThrows[IllegalArgumentException] { 2010 | nullString.ops.truncate(-1) 2011 | } 2012 | assertThrows[IllegalArgumentException] { 2013 | noneString.ops.truncate(-10) 2014 | } 2015 | assertThrows[IllegalArgumentException] { 2016 | noneString.ops.truncate(Integer.MIN_VALUE) 2017 | } 2018 | 2019 | assert("".ops.truncate(10).contains("")) 2020 | assert("".ops.truncate(10).contains("")) 2021 | assert(Some("abcdefghij").ops.truncate(3).contains("abc")) 2022 | assert("abcdefghij".ops.truncate(6).contains("abcdef")) 2023 | assert("abcdefghij".ops.truncate(0).contains("")) 2024 | assertThrows[IllegalArgumentException] { 2025 | "abcdefghij".ops.truncate(-1) 2026 | } 2027 | assertThrows[IllegalArgumentException] { 2028 | "abcdefghij".ops.truncate(-100) 2029 | } 2030 | assertThrows[IllegalArgumentException] { 2031 | Some("abcdefghij").ops.truncate(Integer.MIN_VALUE) 2032 | } 2033 | assert("abcdefghijklmno".ops.truncate(10).contains("abcdefghij")) 2034 | assert("abcdefghijklmno".ops.truncate(Integer.MAX_VALUE).contains("abcdefghijklmno")) 2035 | assert("abcdefghijklmno".ops.truncate(5).contains("abcde")) 2036 | assert("abcdefghijklmno".ops.truncate(3).contains("abc")) 2037 | } 2038 | 2039 | test("test string truncate with offset and max width") { 2040 | assert(nullString.ops.truncate(0, 12).isEmpty) 2041 | assertThrows[IllegalArgumentException] { 2042 | nullString.ops.truncate(-1, 0) 2043 | } 2044 | assertThrows[IllegalArgumentException] { 2045 | noneString.ops.truncate(-10, -4) 2046 | } 2047 | assertThrows[IllegalArgumentException] { 2048 | noneString.ops.truncate(Integer.MIN_VALUE, Integer.MIN_VALUE) 2049 | } 2050 | assert(nullString.ops.truncate(10, 12).isEmpty) 2051 | assert("".ops.truncate(0, 10).contains("")) 2052 | assert("".ops.truncate(2, 10).contains("")) 2053 | assert(Some("abcdefghij").ops.truncate(0, 3).contains("abc")) 2054 | assert("abcdefghij".ops.truncate(5, 6).contains("fghij")) 2055 | assert("abcdefghij".ops.truncate(0, 0).contains("")) 2056 | assertThrows[IllegalArgumentException] { 2057 | "abcdefghij".ops.truncate(0, -1) 2058 | } 2059 | assertThrows[IllegalArgumentException] { 2060 | "abcdefghij".ops.truncate(0, -10) 2061 | } 2062 | assertThrows[IllegalArgumentException] { 2063 | "abcdefghij".ops.truncate(0, -100) 2064 | } 2065 | assertThrows[IllegalArgumentException] { 2066 | Some("abcdefghij").ops.truncate(1, -100) 2067 | } 2068 | assertThrows[IllegalArgumentException] { 2069 | "abcdefghij".ops.truncate(0, Integer.MIN_VALUE) 2070 | } 2071 | assertThrows[IllegalArgumentException] { 2072 | "abcdefghij".ops.truncate(-1, 0) 2073 | } 2074 | assertThrows[IllegalArgumentException] { 2075 | "abcdefghij".ops.truncate(-10, 0) 2076 | } 2077 | assertThrows[IllegalArgumentException] { 2078 | "abcdefghij".ops.truncate(-100, 1) 2079 | } 2080 | assertThrows[IllegalArgumentException] { 2081 | "abcdefghij".ops.truncate(Integer.MIN_VALUE, 0) 2082 | } 2083 | assertThrows[IllegalArgumentException] { 2084 | "abcdefghij".ops.truncate(-1, -1) 2085 | } 2086 | assertThrows[IllegalArgumentException] { 2087 | "abcdefghij".ops.truncate(-10, -10) 2088 | } 2089 | assertThrows[IllegalArgumentException] { 2090 | "abcdefghij".ops.truncate(-100, -100) 2091 | } 2092 | assertThrows[IllegalArgumentException] { 2093 | "abcdefghij".ops.truncate(Integer.MIN_VALUE, Integer.MIN_VALUE) 2094 | } 2095 | val raspberry = "raspberry peach" 2096 | assert(raspberry.ops.truncate(10, 15).contains("peach")) 2097 | assert(Some("abcdefghijklmno").ops.truncate(0, 10).contains("abcdefghij")) 2098 | assert("abcdefghijklmno".ops.truncate(0, Integer.MAX_VALUE).contains("abcdefghijklmno")) 2099 | assert("abcdefghijklmno".ops.truncate(1, 10).contains("bcdefghijk")) 2100 | assert(Some("abcdefghijklmno").ops.truncate(2, 10).contains("cdefghijkl")) 2101 | assert("abcdefghijklmno".ops.truncate(3, 10).contains("defghijklm")) 2102 | assert("abcdefghijklmno".ops.truncate(4, 10).contains("efghijklmn")) 2103 | assert("abcdefghijklmno".ops.truncate(5, 10).contains("fghijklmno")) 2104 | assert("abcdefghijklmno".ops.truncate(5, 5).contains("fghij")) 2105 | assert("abcdefghijklmno".ops.truncate(5, 3).contains("fgh")) 2106 | assert("abcdefghijklmno".ops.truncate(10, 3).contains("klm")) 2107 | assert("abcdefghijklmno".ops.truncate(10, Integer.MAX_VALUE).contains("klmno")) 2108 | assert("abcdefghijklmno".ops.truncate(13, 1).contains("n")) 2109 | assert("abcdefghijklmno".ops.truncate(13, Integer.MAX_VALUE).contains("no")) 2110 | assert("abcdefghijklmno".ops.truncate(14, 1).contains("o")) 2111 | assert("abcdefghijklmno".ops.truncate(14, Integer.MAX_VALUE).contains("o")) 2112 | assert("abcdefghijklmno".ops.truncate(15, 1).contains("")) 2113 | assert("abcdefghijklmno".ops.truncate(15, Integer.MAX_VALUE).contains("")) 2114 | assert("abcdefghijklmno".ops.truncate(Integer.MAX_VALUE, Integer.MAX_VALUE).contains("")) 2115 | } 2116 | 2117 | test("test string uncapitalize") { 2118 | assert(noneString.ops.uncapitalize.isEmpty) 2119 | 2120 | assert(FOO_CAP.ops.uncapitalize.contains(FOO_UNCAP), "uncapitalize(String) failed") 2121 | assert(FOO_UNCAP.ops.uncapitalize.contains(FOO_UNCAP), "uncapitalize(string) failed") 2122 | assert("".ops.uncapitalize.contains(""), "uncapitalize(empty-string) failed") 2123 | assert(Some("X").ops.uncapitalize.contains("x"), "uncapitalize(single-char-string) failed") 2124 | 2125 | // Examples from uncapitalize Javadoc 2126 | assert("cat".ops.uncapitalize.contains("cat")) 2127 | assert("Cat".ops.uncapitalize.contains("cat")) 2128 | assert("CAT".ops.uncapitalize.contains("cAT")) 2129 | } 2130 | 2131 | test("test string unwrap with wrap token") { 2132 | assert(noneString.ops.unwrap(nullString).isEmpty) 2133 | assert(nullString.ops.unwrap(CharUtils.NUL).isEmpty) 2134 | assert(nullString.ops.unwrap('1').isEmpty) 2135 | 2136 | assert(Some("abc").ops.unwrap(noneString).contains("abc")) 2137 | assert("a".ops.unwrap(Some("a")).contains("a")) 2138 | assert("aa".ops.unwrap("a").contains("")) 2139 | assert("\'abc\'".ops.unwrap('\'').contains("abc")) 2140 | assert(Some("AabcA").ops.unwrap('A').contains("abc")) 2141 | assert("AAabcAA".ops.unwrap('A').contains("AabcA")) 2142 | assert("abc".ops.unwrap('b').contains("abc")) 2143 | assert("#A".ops.unwrap('#').contains("#A")) 2144 | assert("A#".ops.unwrap('#').contains("A#")) 2145 | assert("AABAA".ops.unwrap('A').contains("ABA")) 2146 | } 2147 | 2148 | test("test string unwrap with wrap token string") { 2149 | assert(nullString.ops.unwrap(noneString).isEmpty) 2150 | assert(noneString.ops.unwrap("").isEmpty) 2151 | assert(nullString.ops.unwrap(Some("1")).isEmpty) 2152 | 2153 | assert("abc".ops.unwrap(nullString).contains("abc")) 2154 | assert("abc".ops.unwrap("").contains("abc")) 2155 | assert(Some("a").ops.unwrap("a").contains("a")) 2156 | assert("ababa".ops.unwrap(Some("aba")).contains("ababa")) 2157 | assert("aa".ops.unwrap("a").contains("")) 2158 | assert("\'abc\'".ops.unwrap("\'").contains("abc")) 2159 | assert("\"abc\"".ops.unwrap("\"").contains("abc")) 2160 | assert(Some("\"abc\"xyz\"").ops.unwrap("\"").contains("abc\"xyz")) 2161 | assert("\"abc\"xyz\"\"".ops.unwrap("\"").contains("abc\"xyz\"")) 2162 | assert("\"abc\'xyz\'\"".ops.unwrap("\"").contains("abc\'xyz\'")) 2163 | assert("AA\"abc\'xyz\'\"AA".ops.unwrap("AA").contains("\"abc\'xyz\'\"")) 2164 | assert("123\"abc\'xyz\'\"123".ops.unwrap("123").contains("\"abc\'xyz\'\"")) 2165 | assert("AA\"abc\'xyz\'\"".ops.unwrap("AA").contains("AA\"abc\'xyz\'\"")) 2166 | assert("AAA\"abc\'xyz\'\"AAA".ops.unwrap("A").contains("AA\"abc\'xyz\'\"AA")) 2167 | assert("\"abc\'xyz\'\"AA".ops.unwrap("AA").contains("\"abc\'xyz\'\"AA")) 2168 | } 2169 | 2170 | test("test string upper case") { 2171 | assert(nullString.ops.upperCase.isEmpty) 2172 | assert(noneString.ops.upperCase(Locale.ENGLISH).isEmpty) 2173 | assert(Some("fOo test THING").ops.upperCase.contains("FOO TEST THING"), "upperCase(String) failed") 2174 | assert("".ops.upperCase.contains(""), "upperCase(empty-string) failed") 2175 | assert("fOo test THING".ops.upperCase(Locale.ENGLISH).contains("FOO TEST THING"), "upperCase(String, Locale) failed") 2176 | assert("".ops.upperCase(Locale.ENGLISH).contains(""), "upperCase(empty-string, Locale) failed") 2177 | } 2178 | 2179 | test("test string wrap with char") { 2180 | assert(nullString.ops.wrap(CharUtils.NUL).isEmpty) 2181 | assert(noneString.ops.wrap('1').isEmpty) 2182 | 2183 | assert("".ops.wrap(CharUtils.NUL).contains("")) 2184 | assert("ab".ops.wrap('x').contains("xabx")) 2185 | assert(Some("ab").ops.wrap('\"').contains("\"ab\"")) 2186 | assert("\"ab\"".ops.wrap('\"').contains("\"\"ab\"\"")) 2187 | assert("ab".ops.wrap('\'').contains("'ab'")) 2188 | assert("'abcd'".ops.wrap('\'').contains("''abcd''")) 2189 | assert("\"abcd\"".ops.wrap('\'').contains("'\"abcd\"'")) 2190 | assert("'abcd'".ops.wrap('\"').contains("\"'abcd'\"")) 2191 | } 2192 | 2193 | test("test string wrap with string") { 2194 | assert(noneString.ops.wrap(nullString).isEmpty) 2195 | assert(nullString.ops.wrap("").isEmpty) 2196 | assert(noneString.ops.wrap("1").isEmpty) 2197 | 2198 | assert(nullString.ops.wrap(noneString).isEmpty) 2199 | assert(Some("").ops.wrap("").contains("")) 2200 | assert("ab".ops.wrap(nullString).contains("ab")) 2201 | assert(Some("ab").ops.wrap(Some("x")).contains("xabx")) 2202 | assert("ab".ops.wrap("\"").contains("\"ab\"")) 2203 | assert("\"ab\"".ops.wrap("\"").contains("\"\"ab\"\"")) 2204 | assert("ab".ops.wrap(Some("'")).contains("'ab'")) 2205 | assert("'abcd'".ops.wrap("'").contains("''abcd''")) 2206 | assert("\"abcd\"".ops.wrap("'").contains("'\"abcd\"'")) 2207 | assert("'abcd'".ops.wrap("\"").contains("\"'abcd'\"")) 2208 | } 2209 | 2210 | test("test string wrap if missing char") { 2211 | assert(noneString.ops.wrapIfMissing(CharUtils.NUL).isEmpty) 2212 | assert(nullString.ops.wrapIfMissing('1').isEmpty) 2213 | 2214 | assert(Some("").ops.wrapIfMissing(CharUtils.NUL).contains("")) 2215 | assert("ab".ops.wrapIfMissing('x').contains("xabx")) 2216 | assert("ab".ops.wrapIfMissing('\"').contains("\"ab\"")) 2217 | assert("\"ab\"".ops.wrapIfMissing('\"').contains("\"ab\"")) 2218 | assert("ab".ops.wrapIfMissing('\'').contains("'ab'")) 2219 | assert("'abcd'".ops.wrapIfMissing('\'').contains("'abcd'")) 2220 | assert("\"abcd\"".ops.wrapIfMissing('\'').contains("'\"abcd\"'")) 2221 | assert(Some("'abcd'").ops.wrapIfMissing('\"').contains("\"'abcd'\"")) 2222 | assert("x".ops.wrapIfMissing('/').contains("/x/")) 2223 | assert("x/y/z".ops.wrapIfMissing('/').contains("/x/y/z/")) 2224 | assert("/x/y/z".ops.wrapIfMissing('/').contains("/x/y/z/")) 2225 | assert("x/y/z/".ops.wrapIfMissing('/').contains("/x/y/z/")) 2226 | 2227 | assert("/".ops.wrapIfMissing('/').contains("/")) 2228 | assert("/x/".ops.wrapIfMissing('/').contains("/x/")) 2229 | } 2230 | 2231 | test("test string wrap if missing string") { 2232 | assert(nullString.ops.wrapIfMissing(Some("\u0000")).isEmpty) 2233 | assert(noneString.ops.wrapIfMissing("1").isEmpty) 2234 | 2235 | assert(Some("").ops.wrapIfMissing("\u0000").contains("")) 2236 | assert(Some("ab").ops.wrapIfMissing(Some("x")).contains("xabx")) 2237 | assert("ab".ops.wrapIfMissing("\"").contains("\"ab\"")) 2238 | assert("\"ab\"".ops.wrapIfMissing("\"").contains("\"ab\"")) 2239 | assert("ab".ops.wrapIfMissing("\'").contains("'ab'")) 2240 | assert("'abcd'".ops.wrapIfMissing("\'").contains("'abcd'")) 2241 | assert("\"abcd\"".ops.wrapIfMissing("\'").contains("'\"abcd\"'")) 2242 | assert(Some("'abcd'").ops.wrapIfMissing("\"").contains("\"'abcd'\"")) 2243 | assert("x".ops.wrapIfMissing("/").contains("/x/")) 2244 | assert("x/y/z".ops.wrapIfMissing("/").contains("/x/y/z/")) 2245 | assert("/x/y/z".ops.wrapIfMissing("/").contains("/x/y/z/")) 2246 | assert("x/y/z/".ops.wrapIfMissing(Some("/")).contains("/x/y/z/")) 2247 | assert("/".ops.wrapIfMissing("/").contains("/")) 2248 | assert("/".ops.wrapIfMissing("ab").contains("ab/ab")) 2249 | 2250 | assert("ab/ab".ops.wrapIfMissing("ab").contains("ab/ab")) 2251 | assert("//x//".ops.wrapIfMissing("//").contains("//x//")) 2252 | } 2253 | 2254 | test("test string to root lower case") { 2255 | assert(noneString.ops.toRootLowerCase.isEmpty) 2256 | assert(Some("A").ops.toRootLowerCase.contains("a")) 2257 | assert(Some("a").ops.toRootLowerCase.contains("a")) 2258 | val TURKISH = Locale.forLanguageTag("tr") 2259 | // Sanity checks: 2260 | assert("TITLE".toLowerCase(TURKISH) != "title") 2261 | assert("TITLE".toLowerCase(Locale.ROOT) == "title") 2262 | assert("TITLE".ops.toRootLowerCase.contains("title")) 2263 | // Make sure we are not using the default Locale: 2264 | val defaultLocale = Locale.getDefault 2265 | try { 2266 | Locale.setDefault(TURKISH) 2267 | assert("TITLE".ops.toRootLowerCase.contains("title")) 2268 | } finally Locale.setDefault(defaultLocale) 2269 | } 2270 | 2271 | test("test string to root upper case") { 2272 | assert(noneString.ops.toRootUpperCase.isEmpty) 2273 | assert(Some("a").ops.toRootUpperCase.contains("A")) 2274 | assert("A".ops.toRootUpperCase.contains("A")) 2275 | val TURKISH = Locale.forLanguageTag("tr") 2276 | // Sanity checks: 2277 | assert("TITLE" != "title".toUpperCase(TURKISH)) 2278 | assert("TITLE" == "title".toUpperCase(Locale.ROOT)) 2279 | assert(Some("title").ops.toRootUpperCase.contains("TITLE")) 2280 | // Make sure we are not using the default Locale: 2281 | val defaultLocale = Locale.getDefault(); 2282 | try { 2283 | Locale.setDefault(TURKISH) 2284 | assert("title".ops.toRootUpperCase.contains("TITLE")); 2285 | } finally { 2286 | Locale.setDefault(defaultLocale); 2287 | } 2288 | } 2289 | 2290 | test("test string georgian") { 2291 | val arrayI = Array[Char]( // Latin Small Letter dotless I 2292 | 0x0131.toChar, // Greek Capital Letter Theta 2293 | 0x03f4.toChar 2294 | ) 2295 | val arrayJ = Array[Char]( // Latin Capital Letter I with dot above 2296 | 0x0130.toChar, // Greek Theta Symbol 2297 | 0x03d1.toChar 2298 | ) 2299 | for (i <- arrayI) { 2300 | for (j <- arrayJ) { 2301 | val si = String.valueOf(i) 2302 | val sj = String.valueOf(j) 2303 | val res1 = si.equalsIgnoreCase(sj) 2304 | val ci = new mutable.StringBuilder(si) 2305 | val cj = new mutable.StringBuilder(sj) 2306 | var res2 = ci.toString().ops.startsWithIgnoreCase(cj.toString()) 2307 | assert(res1 == res2, "si : " + si + " sj : " + sj) 2308 | res2 = ci.toString().ops.endsWithIgnoreCase(cj.toString()) 2309 | assert(res1 == res2, "si : " + si + " sj : " + sj) 2310 | res2 = ci.toString.ops.compareIgnoreCase(cj.toString) == 0 2311 | assert(res1 == res2, "si : " + si + " sj : " + sj) 2312 | res2 = ci.toString.ops.indexOfIgnoreCase(cj.toString) == 0 2313 | assert(res1 == res2, "si : " + si + " sj : " + sj) 2314 | res2 = ci.toString.ops.indexOfIgnoreCase(cj.toString) == 0 2315 | assert(res1 == res2, "si : " + si + " sj : " + sj) 2316 | } 2317 | } 2318 | } 2319 | } 2320 | 2321 | object StringUtilsSpec { 2322 | val (whitespace: String, non_whitespace: String, hard_space: String, trimmable: String, non_trimmable: String) = { 2323 | val ws: mutable.StringBuilder = new mutable.StringBuilder 2324 | val nws: mutable.StringBuilder = new mutable.StringBuilder 2325 | val hs: String = String.valueOf(160.toChar) 2326 | val tr: mutable.StringBuilder = new mutable.StringBuilder 2327 | val ntr: mutable.StringBuilder = new mutable.StringBuilder 2328 | 2329 | for (i <- 0 until Character.MAX_VALUE) { 2330 | if (Character.isWhitespace(i.toChar)) { 2331 | ws.append(String.valueOf(i.toChar)) 2332 | if (i > 32) ntr.append(String.valueOf(i.toChar)) 2333 | } else if (i < 40) nws.append(String.valueOf(i.toChar)) 2334 | } 2335 | for (i <- 0 to 32) { 2336 | tr.append(String.valueOf(i.toChar)) 2337 | } 2338 | (ws.toString, nws.toString, hs, tr.toString, ntr.toString) 2339 | } 2340 | val WHITESPACE: String = whitespace 2341 | val NON_WHITESPACE: String = non_whitespace 2342 | val HARD_SPACE: String = hard_space 2343 | val TRIMMABLE: String = trimmable 2344 | val NON_TRIMMABLE: String = non_trimmable 2345 | 2346 | val ARRAY_LIST: Array[String] = Array("foo", "bar", "baz") 2347 | val EMPTY_ARRAY_LIST: Array[String] = Array() 2348 | val NULL_ARRAY_LIST: Array[String] = Array(null) 2349 | val NULL_TO_STRING_LIST: Array[Object] = Array(new Object() { 2350 | override def toString: String = null 2351 | }) 2352 | val MIXED_ARRAY_LIST: Array[String] = Array(null, "", "foo") 2353 | val MIXED_TYPE_LIST: Array[Any] = Array("foo", 2L) 2354 | val LONG_PRIM_LIST: Array[Long] = Array(1, 2) 2355 | val INT_PRIM_LIST: Array[Int] = Array(1, 2) 2356 | val BYTE_PRIM_LIST: Array[Byte] = Array(1, 2) 2357 | val SHORT_PRIM_LIST: Array[Short] = Array(1, 2) 2358 | val CHAR_PRIM_LIST: Array[Char] = Array('1', '2') 2359 | val FLOAT_PRIM_LIST: Array[Float] = Array(1, 2) 2360 | val DOUBLE_PRIM_LIST: Array[Double] = Array(1, 2) 2361 | val MIXED_STRING_LIST: util.List[String] = util.Arrays.asList(null, "", "foo") 2362 | val MIXED_TYPE_OBJECT_LIST: util.List[Any] = util.Arrays.asList[Any]("foo", 2L) 2363 | val STRING_LIST: util.List[String] = util.Arrays.asList("foo", "bar", "baz") 2364 | val EMPTY_STRING_LIST: List[String] = List.empty 2365 | val NULL_STRING_LIST: util.List[String] = Collections.singletonList(null) 2366 | 2367 | val SEPARATOR: String = "," 2368 | val SEPARATOR_CHAR: Char = ';' 2369 | val COMMA_SEPARATOR_CHAR: Char = ',' 2370 | 2371 | val TEXT_LIST: String = "foo,bar,baz" 2372 | val TEXT_LIST_CHAR: String = "foo;bar;baz" 2373 | val TEXT_LIST_NOSEP: String = "foobarbaz" 2374 | 2375 | val FOO_UNCAP: String = "foo" 2376 | val FOO_CAP: String = "Foo" 2377 | 2378 | val SENTENCE_UNCAP: String = "foo bar baz" 2379 | val SENTENCE_CAP: String = "Foo Bar Baz" 2380 | 2381 | val EMPTY: Array[Boolean] = Array() 2382 | val ARRAY_FALSE_FALSE: Array[Boolean] = Array(false, false) 2383 | val ARRAY_FALSE_TRUE: Array[Boolean] = Array(false, true) 2384 | val ARRAY_FALSE_TRUE_FALSE: Array[Boolean] = Array(false, true, false) 2385 | 2386 | val noneString: Option[String] = None 2387 | val nullString: String = null 2388 | val noneStrings: Option[Array[String]] = None 2389 | } 2390 | -------------------------------------------------------------------------------- /modules/bridge/src/test/scala/commons/lang3/bridge/StringUtilsStartsEndsWithSpec.scala: -------------------------------------------------------------------------------- 1 | package commons.lang3.bridge 2 | 3 | import commons.lang3.bridge.StringUtils.ops.StringOptExt 4 | import org.scalatest.funsuite.AnyFunSuite 5 | 6 | import scala.collection.mutable 7 | 8 | /** TODO 9 | * 10 | * @author 11 | * mars 12 | * @version 1.0.0 13 | * @since 2022/09/11 14 | * 17:08 15 | */ 16 | class StringUtilsStartsEndsWithSpec extends AnyFunSuite { 17 | private val foo = "foo" 18 | private val bar = "bar" 19 | private val foobar = "foobar" 20 | private val FOO = "FOO" 21 | private val BAR = "BAR" 22 | private val FOOBAR = "FOOBAR" 23 | 24 | import StringUtilsSpec.{noneString, nullString} 25 | 26 | test("test string starts with") { 27 | assert(nullString.ops.startsWith(nullString), "startsWith(null, null)") 28 | assert(!FOOBAR.ops.startsWith(noneString), "startsWith(FOOBAR, null)") 29 | assert(!nullString.ops.startsWith(FOO), "startsWith(null, FOO)") 30 | assert(FOOBAR.ops.startsWith(""), "startsWith(FOOBAR, \"\")") 31 | 32 | assert(foobar.ops.startsWith(foo), "startsWith(foobar, foo)") 33 | assert(FOOBAR.ops.startsWith(FOO), "startsWith(FOOBAR, FOO)") 34 | assert(!foobar.ops.startsWith(FOO), "startsWith(foobar, FOO)") 35 | assert(!FOOBAR.ops.startsWith(foo), "startsWith(FOOBAR, foo)") 36 | 37 | assert(!foo.ops.startsWith(foobar), "startsWith(foo, foobar)") 38 | assert(!bar.ops.startsWith(foobar), "startsWith(foo, foobar)") 39 | 40 | assert(!foobar.ops.startsWith(bar), "startsWith(foobar, bar)") 41 | assert(!FOOBAR.ops.startsWith(BAR), "startsWith(FOOBAR, BAR)") 42 | assert(!foobar.ops.startsWith(BAR), "startsWith(foobar, BAR)") 43 | assert(!FOOBAR.ops.startsWith(bar), "startsWith(FOOBAR, bar)") 44 | } 45 | 46 | test("test string starts with ignore case") { 47 | assert(noneString.ops.startsWithIgnoreCase(nullString), "startsWithIgnoreCase(null, null)") 48 | assert(!FOOBAR.ops.startsWithIgnoreCase(noneString), "startsWithIgnoreCase(FOOBAR, null)") 49 | assert(!nullString.ops.startsWithIgnoreCase(FOO), "startsWithIgnoreCase(null, FOO)") 50 | assert(FOOBAR.ops.startsWithIgnoreCase(""), "startsWithIgnoreCase(FOOBAR, \"\")") 51 | 52 | assert(foobar.ops.startsWithIgnoreCase(foo), "startsWithIgnoreCase(foobar, foo)") 53 | assert(FOOBAR.ops.startsWithIgnoreCase(FOO), "startsWithIgnoreCase(FOOBAR, FOO)") 54 | assert(foobar.ops.startsWithIgnoreCase(FOO), "startsWithIgnoreCase(foobar, FOO)") 55 | assert(FOOBAR.ops.startsWithIgnoreCase(foo), "startsWithIgnoreCase(FOOBAR, foo)") 56 | 57 | assert(!foo.ops.startsWithIgnoreCase(foobar), "startsWithIgnoreCase(foo, foobar)") 58 | assert(!bar.ops.startsWithIgnoreCase(foobar), "startsWithIgnoreCase(foo, foobar)") 59 | 60 | assert(!foobar.ops.startsWithIgnoreCase(bar), "startsWithIgnoreCase(foobar, bar)") 61 | assert(!FOOBAR.ops.startsWithIgnoreCase(BAR), "startsWithIgnoreCase(FOOBAR, BAR)") 62 | assert(!foobar.ops.startsWithIgnoreCase(BAR), "startsWithIgnoreCase(foobar, BAR)") 63 | assert(!FOOBAR.ops.startsWithIgnoreCase(bar), "startsWithIgnoreCase(FOOBAR, bar)") 64 | } 65 | 66 | test("test starts with any") { 67 | assert(!nullString.ops.startsWithAny(null.asInstanceOf[Array[String]]: _*)) 68 | assert(!noneString.ops.startsWithAny("abc")) 69 | assert(!"abcxyz".ops.startsWithAny(null.asInstanceOf[Array[String]]: _*)) 70 | assert(!"abcxyz".ops.startsWithAny[String]()) 71 | assert("abcxyz".ops.startsWithAny("abc")) 72 | assert("abcxyz".ops.startsWithAny(null, "xyz", "abc")) 73 | assert(!Some("abcxyz").ops.startsWithAny(null, "xyz", "abcd")) 74 | assert(Some("abcxyz").ops.startsWithAny(Some(""))) 75 | assert(!"abcxyz".ops.startsWithAny(null, "xyz", "ABCX")) 76 | assert(!"ABCXYZ".ops.startsWithAny(null, "xyz", "abc")) 77 | 78 | assert( 79 | "abcxyz".ops.startsWithAny(new mutable.StringBuilder("xyz"), new StringBuffer("abc")), 80 | "StringUtils.startsWithAny(abcxyz, StringBuilder(xyz), StringBuffer(abc))" 81 | ) 82 | 83 | } 84 | 85 | test("test ends with") { 86 | assert(nullString.ops.endsWith(noneString), "endsWith(null, null)") 87 | assert(!FOOBAR.ops.endsWith(nullString), "endsWith(FOOBAR, null)") 88 | assert(!noneString.ops.endsWith(FOO), "endsWith(null, FOO)") 89 | assert(FOOBAR.ops.endsWith(""), "endsWith(FOOBAR, \"\")") 90 | 91 | assert(!foobar.ops.endsWith(foo), "endsWith(foobar, foo)") 92 | assert(!FOOBAR.ops.endsWith(FOO), "endsWith(FOOBAR, FOO)") 93 | assert(!foobar.ops.endsWith(FOO), "endsWith(foobar, FOO)") 94 | assert(!FOOBAR.ops.endsWith(foo), "endsWith(FOOBAR, foo)") 95 | 96 | assert(!foo.ops.endsWith(foobar), "endsWith(foo, foobar)") 97 | assert(!bar.ops.endsWith(foobar), "endsWith(foo, foobar)") 98 | 99 | assert(foobar.ops.endsWith(bar), "endsWith(foobar, bar)") 100 | assert(FOOBAR.ops.endsWith(BAR), "endsWith(FOOBAR, BAR)") 101 | assert(!foobar.ops.endsWith(BAR), "endsWith(foobar, BAR)") 102 | assert(!FOOBAR.ops.endsWith(bar), "endsWith(FOOBAR, bar)") 103 | 104 | // "alpha, beta, gamma, delta".endsWith("delta") 105 | assert("\u03B1\u03B2\u03B3\u03B4".ops.endsWith("\u03B4"), "endsWith(\u03B1\u03B2\u03B3\u03B4, \u03B4)") 106 | // "alpha, beta, gamma, delta".endsWith("gamma, DELTA") 107 | assert(!Some("\u03B1\u03B2\u03B3\u03B4").ops.endsWith("\u03B3\u0394"), "endsWith(\u03B1\u03B2\u03B3\u03B4, \u03B3\u0394)") 108 | } 109 | 110 | test("test ends with ignore case") { 111 | assert(nullString.ops.endsWithIgnoreCase(noneString), "endsWithIgnoreCase(null, null)") 112 | assert(!FOOBAR.ops.endsWithIgnoreCase(nullString), "endsWithIgnoreCase(FOOBAR, null)") 113 | assert(!nullString.ops.endsWithIgnoreCase(FOO), "endsWithIgnoreCase(null, FOO)") 114 | assert(FOOBAR.ops.endsWithIgnoreCase(""), "endsWithIgnoreCase(FOOBAR, \"\")") 115 | 116 | assert(!foobar.ops.endsWithIgnoreCase(foo), "endsWithIgnoreCase(foobar, foo)") 117 | assert(!FOOBAR.ops.endsWithIgnoreCase(FOO), "endsWithIgnoreCase(FOOBAR, FOO)") 118 | assert(!foobar.ops.endsWithIgnoreCase(FOO), "endsWithIgnoreCase(foobar, FOO)") 119 | assert(!FOOBAR.ops.endsWithIgnoreCase(foo), "endsWithIgnoreCase(FOOBAR, foo)") 120 | 121 | assert(!foo.ops.endsWithIgnoreCase(foobar), "endsWithIgnoreCase(foo, foobar)") 122 | assert(!bar.ops.endsWithIgnoreCase(Some(foobar)), "endsWithIgnoreCase(foo, foobar)") 123 | 124 | assert(foobar.ops.endsWithIgnoreCase(bar), "endsWithIgnoreCase(foobar, bar)") 125 | assert(Some(FOOBAR).ops.endsWithIgnoreCase(BAR), "endsWithIgnoreCase(FOOBAR, BAR)") 126 | assert(foobar.ops.endsWithIgnoreCase(BAR), "endsWithIgnoreCase(foobar, BAR)") 127 | assert(FOOBAR.ops.endsWithIgnoreCase(bar), "endsWithIgnoreCase(FOOBAR, bar)") 128 | 129 | // javadoc 130 | assert("abcdef".ops.endsWithIgnoreCase("def")) 131 | assert("ABCDEF".ops.endsWithIgnoreCase("def")) 132 | assert(!Some("ABCDEF").ops.endsWithIgnoreCase("cde")) 133 | 134 | // "alpha, beta, gamma, delta".endsWith("DELTA") 135 | assert("\u03B1\u03B2\u03B3\u03B4".ops.endsWithIgnoreCase("\u0394"), "endsWith(\u03B1\u03B2\u03B3\u03B4, \u0394)") 136 | // "alpha, beta, gamma, delta".endsWith("GAMMA") 137 | assert(!"\u03B1\u03B2\u03B3\u03B4".ops.endsWithIgnoreCase("\u0393"), "endsWith(\u03B1\u03B2\u03B3\u03B4, \u0393)") 138 | } 139 | 140 | test("test ends with any") { 141 | assert(!nullString.ops.endsWithAny(null.asInstanceOf[String]), "StringUtils.endsWithAny(null, null)") 142 | assert(!noneString.ops.endsWithAny("abc"), "StringUtils.endsWithAny(null, new String[] {abc})") 143 | assert(!"abcxyz".ops.endsWithAny(null.asInstanceOf[String]), "StringUtils.endsWithAny(abcxyz, null)") 144 | assert("abcxyz".ops.endsWithAny(""), "StringUtils.endsWithAny(abcxyz, new String[] {\"\"})") 145 | assert("abcxyz".ops.endsWithAny("xyz"), "StringUtils.endsWithAny(abcxyz, new String[] {xyz})") 146 | assert("abcxyz".ops.endsWithAny(null, "xyz", "abc"), "StringUtils.endsWithAny(abcxyz, new String[] {null, xyz, abc})") 147 | assert(!"defg".ops.endsWithAny(null, "xyz", "abc"), "StringUtils.endsWithAny(defg, new String[] {null, xyz, abc})") 148 | assert("abcXYZ".ops.endsWithAny("def", "XYZ")) 149 | assert(!"abcXYZ".ops.endsWithAny("def", "xyz")) 150 | assert("abcXYZ".ops.endsWithAny(Some("def"), Some("YZ"))) 151 | 152 | /* 153 | * Type null of the last argument to method endsWithAny(CharSequence, CharSequence...) 154 | * doesn't exactly match the vararg parameter type. 155 | * Cast to CharSequence[] to confirm the non-varargs invocation, 156 | * or pass individual arguments of type CharSequence for a varargs invocation. 157 | * 158 | * assertFalse(StringUtils.endsWithAny("abcXYZ", null)); // replace with specific types to avoid warning 159 | */ 160 | assert(!Some("abcXYZ").ops.endsWithAny(null.asInstanceOf[CharSequence])) 161 | assert(!"abcXYZ".ops.endsWithAny(null.asInstanceOf[Array[CharSequence]]: _*)) 162 | assert("abcXYZ".ops.endsWithAny("")) 163 | 164 | assert( 165 | "abcxyz".ops.endsWithAny(new mutable.StringBuilder("abc"), new StringBuffer("xyz")), 166 | "StringUtils.endsWithAny(abcxyz, StringBuilder(abc), StringBuffer(xyz))" 167 | ) 168 | 169 | } 170 | } 171 | -------------------------------------------------------------------------------- /modules/bridge/src/test/scala/commons/lang3/bridge/StringUtilsSubstringSpec.scala: -------------------------------------------------------------------------------- 1 | package commons.lang3.bridge 2 | 3 | import commons.lang3.bridge.StringUtils.ops.StringOptExt 4 | import org.scalatest.funsuite.AnyFunSuite 5 | 6 | /** TODO 7 | * 8 | * @author 9 | * mars 10 | * @version 1.0.0 11 | * @since 2022/09/11 12 | * 18:14 13 | */ 14 | class StringUtilsSubstringSpec extends AnyFunSuite { 15 | private val FOO = "foo" 16 | private val BAR = "bar" 17 | private val BAZ = "baz" 18 | private val FOOBAR = "foobar" 19 | private val SENTENCE = "foo bar baz" 20 | 21 | import StringUtilsSpec.{noneString, nullString} 22 | test("test substring with start") { 23 | assert(noneString.ops.substring(0).isEmpty) 24 | assert(Some("").ops.substring(0).contains("")) 25 | assert("".ops.substring(2).contains("")) 26 | 27 | assert(SENTENCE.ops.substring(80).contains("")) 28 | assert(SENTENCE.ops.substring(8).contains(BAZ)) 29 | assert(SENTENCE.ops.substring(-3).contains(BAZ)) 30 | assert(SENTENCE.ops.substring(0).contains(SENTENCE)) 31 | assert(Some("abc").ops.substring(-4).contains("abc")) 32 | assert("abc".ops.substring(-3).contains("abc")) 33 | assert("abc".ops.substring(-2).contains("bc")) 34 | assert("abc".ops.substring(-1).contains("c")) 35 | assert("abc".ops.substring(0).contains("abc")) 36 | assert("abc".ops.substring(1).contains("bc")) 37 | assert(Some("abc").ops.substring(2).contains("c")) 38 | assert("abc".ops.substring(3).contains("")) 39 | assert("abc".ops.substring(4).contains("")) 40 | } 41 | 42 | test("test substring with start and end") { 43 | assert(nullString.ops.substring(0, 0).isEmpty) 44 | assert(noneString.ops.substring(1, 2).isEmpty) 45 | assert("".ops.substring(0, 0).contains("")) 46 | assert(Some("").ops.substring(1, 2).contains("")) 47 | assert("".ops.substring(-2, -1).contains("")) 48 | 49 | assert("" == SENTENCE.ops.substring(8, 6).get) 50 | assert(FOO == SENTENCE.ops.substring(0, 3).get) 51 | assert("o" == SENTENCE.ops.substring(-9, 3).get) 52 | assert(FOO == SENTENCE.ops.substring(0, -8).get) 53 | assert("o" == SENTENCE.ops.substring(-9, -8).get) 54 | assert(SENTENCE == SENTENCE.ops.substring(0, 80).get) 55 | assert("" == SENTENCE.ops.substring(2, 2).get) 56 | assert("b" == "abc".ops.substring(-2, -1).get) 57 | } 58 | 59 | test("test string left") { 60 | assert(noneString.ops.left(-1).isEmpty) 61 | assert(nullString.ops.left(0).isEmpty) 62 | assert(noneString.ops.left(2).isEmpty) 63 | 64 | assert("".ops.left(-1).contains("")) 65 | assert("".ops.left(0).contains("")) 66 | assert("".ops.left(2).contains("")) 67 | 68 | assert(FOOBAR.ops.left(-1).contains("")) 69 | assert(FOOBAR.ops.left(0).contains("")) 70 | assert(FOOBAR.ops.left(3).contains(FOO)) 71 | assert(FOOBAR.ops.left(80).contains(FOOBAR)) 72 | } 73 | 74 | test("test string right") { 75 | assert(nullString.ops.right(-1).isEmpty) 76 | assert(noneString.ops.right(0).isEmpty) 77 | assert(nullString.ops.right(2).isEmpty) 78 | 79 | assert("".ops.right(-1).contains("")) 80 | assert("".ops.right(0).contains("")) 81 | assert("".ops.right(2).contains("")) 82 | 83 | assert(FOOBAR.ops.right(-1).contains("")) 84 | assert(FOOBAR.ops.right(0).contains("")) 85 | assert(Some(FOOBAR).ops.right(3).contains(BAR)) 86 | assert(FOOBAR.ops.right(80).contains(FOOBAR)) 87 | } 88 | 89 | test("test string mid") { 90 | assert(nullString.ops.mid(-1, 0).isEmpty) 91 | assert(noneString.ops.mid(0, -1).isEmpty) 92 | assert(nullString.ops.mid(3, 0).isEmpty) 93 | assert(noneString.ops.mid(3, 2).isEmpty) 94 | 95 | assert("".ops.mid(0, -1).contains("")) 96 | assert("".ops.mid(0, 0).contains("")) 97 | assert("".ops.mid(0, 2).contains("")) 98 | 99 | assert(FOOBAR.ops.mid(3, -1).contains("")) 100 | assert(FOOBAR.ops.mid(3, 0).contains("")) 101 | assert(FOOBAR.ops.mid(3, 1).contains("b")) 102 | assert(FOOBAR.ops.mid(0, 3).contains(FOO)) 103 | assert(FOOBAR.ops.mid(3, 3).contains(BAR)) 104 | assert(FOOBAR.ops.mid(0, 80).contains(FOOBAR)) 105 | assert(FOOBAR.ops.mid(3, 80).contains(BAR)) 106 | assert(FOOBAR.ops.mid(9, 3).contains("")) 107 | assert(FOOBAR.ops.mid(-1, 3).contains(FOO)) 108 | } 109 | 110 | test("test string substring before separator char") { 111 | assert("fooXXbarXXbaz".ops.substringBefore('X').contains("foo")) 112 | 113 | assert(nullString.ops.substringBefore(0).isEmpty) 114 | assert(noneString.ops.substringBefore('X').isEmpty) 115 | assert("".ops.substringBefore(0).contains("")) 116 | assert("".ops.substringBefore('X').contains("")) 117 | 118 | assert(Some("foo").ops.substringBefore(0).contains("foo")) 119 | assert("foo".ops.substringBefore('b').contains("foo")) 120 | assert("foot".ops.substringBefore('o').contains("f")) 121 | assert("abc".ops.substringBefore('a').contains("")) 122 | assert("abcba".ops.substringBefore('b').contains("a")) 123 | assert("abc".ops.substringBefore('c').contains("ab")) 124 | assert("abc".ops.substringBefore(0).contains("abc")) 125 | } 126 | 127 | test("test string substring before separator string") { 128 | assert(Some("fooXXbarXXbaz").ops.substringBefore("XX").contains("foo")) 129 | 130 | assert(noneString.ops.substringBefore(noneString).isEmpty) 131 | assert(nullString.ops.substringBefore("").isEmpty) 132 | assert(noneString.ops.substringBefore("XX").isEmpty) 133 | assert("".ops.substringBefore(nullString).contains("")) 134 | assert("".ops.substringBefore("").contains("")) 135 | assert("".ops.substringBefore("XX").contains("")) 136 | 137 | assert(Some("foo").ops.substringBefore[String](null).contains("foo")) 138 | assert("foo".ops.substringBefore("b").contains("foo")) 139 | assert("foot".ops.substringBefore("o").contains("f")) 140 | assert("abc".ops.substringBefore("a").contains("")) 141 | assert("abcba".ops.substringBefore("b").contains("a")) 142 | assert("abc".ops.substringBefore("c").contains("ab")) 143 | assert("abc".ops.substringBefore("").contains("")) 144 | assert("abc".ops.substringBefore("X").contains("abc")) 145 | } 146 | 147 | test("test string substring after separator string") { 148 | assert("fooXXbarXXbaz".ops.substringAfter("XX").contains("barXXbaz")) 149 | 150 | assert(noneString.ops.substringAfter[String](null).isEmpty) 151 | assert(noneString.ops.substringAfter("").isEmpty) 152 | assert(nullString.ops.substringAfter("XX").isEmpty) 153 | assert("".ops.substringAfter[String](null).contains("")) 154 | assert("".ops.substringAfter("").contains("")) 155 | assert(Some("").ops.substringAfter(Some("XX")).contains("")) 156 | 157 | assert("foo".ops.substringAfter(noneString).contains("")) 158 | assert("foot".ops.substringAfter("o").contains("ot")) 159 | assert("abc".ops.substringAfter(Some("a")).contains("bc")) 160 | assert(Some("abcba").ops.substringAfter("b").contains("cba")) 161 | assert("abc".ops.substringAfter("c").contains("")) 162 | assert("abc".ops.substringAfter("").contains("abc")) 163 | assert("abc".ops.substringAfter("d").contains("")) 164 | } 165 | 166 | test("test string substring after separator char") { 167 | assert(noneString.ops.substringAfter(0).isEmpty) 168 | assert(nullString.ops.substringAfter('X').isEmpty) 169 | assert("".ops.substringAfter(0).contains("")) 170 | assert(Some("").ops.substringAfter('X').contains("")) 171 | 172 | assert("foo".ops.substringAfter(0).contains("")) 173 | assert("foot".ops.substringAfter('o').contains("ot")) 174 | assert("abc".ops.substringAfter('a').contains("bc")) 175 | assert("abcba".ops.substringAfter('b').contains("cba")) 176 | assert("abc".ops.substringAfter('c').contains("")) 177 | assert("abc".ops.substringAfter('d').contains("")) 178 | } 179 | 180 | test("test string substring before last separator") { 181 | assert("fooXXbarXXbaz".ops.substringBeforeLast("XX").contains("fooXXbar")) 182 | 183 | assert(nullString.ops.substringBeforeLast(noneString).isEmpty) 184 | assert(noneString.ops.substringBeforeLast("").isEmpty) 185 | assert(nullString.ops.substringBeforeLast("XX").isEmpty) 186 | assert("".ops.substringBeforeLast(noneString).contains("")) 187 | assert(Some("").ops.substringBeforeLast("").contains("")) 188 | assert("".ops.substringBeforeLast(Some("XX")).contains("")) 189 | 190 | assert("foo".ops.substringBeforeLast(nullString).contains("foo")) 191 | assert(Some("foo").ops.substringBeforeLast("b").contains("foo")) 192 | assert("foo".ops.substringBeforeLast("o").contains("fo")) 193 | assert("abc\r\n".ops.substringBeforeLast("d").contains("abc\r\n")) 194 | assert("abcdabc".ops.substringBeforeLast("d").contains("abc")) 195 | assert("abcdabcd".ops.substringBeforeLast(Some("d")).contains("abcdabc")) 196 | assert("abc".ops.substringBeforeLast("b").contains("a")) 197 | assert("abc \n".ops.substringBeforeLast("\n").contains("abc ")) 198 | assert("a".ops.substringBeforeLast(noneString).contains("a")) 199 | assert("a".ops.substringBeforeLast("").contains("a")) 200 | assert("a".ops.substringBeforeLast("a").contains("")) 201 | } 202 | 203 | test("test string substring after last separator") { 204 | assert("fooXXbarXXbaz".ops.substringAfterLast("XX").contains("baz")) 205 | 206 | assert(nullString.ops.substringAfterLast(nullString).isEmpty) 207 | assert(nullString.ops.substringAfterLast(Some("")).isEmpty) 208 | assert(noneString.ops.substringAfterLast("XX").isEmpty) 209 | assert("".ops.substringAfterLast(noneString).contains("")) 210 | assert("".ops.substringAfterLast("").contains("")) 211 | assert("".ops.substringAfterLast("a").contains("")) 212 | 213 | assert("foo".ops.substringAfterLast(nullString).contains("")) 214 | assert("foo".ops.substringAfterLast("b").contains("")) 215 | assert(Some("foot").ops.substringAfterLast("o").contains("t")) 216 | assert("abc".ops.substringAfterLast(Some("a")).contains("bc")) 217 | assert("abcba".ops.substringAfterLast("b").contains("a")) 218 | assert("abc".ops.substringAfterLast("c").contains("")) 219 | assert("".ops.substringAfterLast("d").contains("")) 220 | assert("abc".ops.substringAfterLast("").contains("")) 221 | } 222 | 223 | test("test string substring after last separator char") { 224 | assert(nullString.ops.substringAfterLast(0).isEmpty) 225 | assert(noneString.ops.substringAfterLast('X').isEmpty) 226 | assert("".ops.substringAfterLast(0).contains("")) 227 | assert(Some("").ops.substringAfterLast('a').contains("")) 228 | 229 | assert("foo".ops.substringAfterLast(0).contains("")) 230 | assert("foo".ops.substringAfterLast('b').contains("")) 231 | assert(Some("foot").ops.substringAfterLast('o').contains("t")) 232 | assert("abc".ops.substringAfterLast('a').contains("bc")) 233 | assert("abcba".ops.substringAfterLast('b').contains("a")) 234 | assert("abc".ops.substringAfterLast('c').contains("")) 235 | assert("".ops.substringAfterLast('d').contains("")) 236 | } 237 | 238 | test("test string substring between tag") { 239 | assert(noneString.ops.substringBetween("tag").isEmpty) 240 | assert(Some("").ops.substringBetween("").contains("")) 241 | assert("".ops.substringBetween(Some("abc")).isEmpty) 242 | assert(" ".ops.substringBetween(" ").contains("")) 243 | assert("abc".ops.substringBetween(noneString).isEmpty) 244 | assert("abc".ops.substringBetween("").contains("")) 245 | assert("abc".ops.substringBetween(Some("a")).isEmpty) 246 | assert(Some("abca").ops.substringBetween("a").contains("bc")) 247 | assert("abcabca".ops.substringBetween("a").contains("bc")) 248 | assert("\nbar\n".ops.substringBetween("\n").contains("bar")) 249 | } 250 | 251 | test("test string substring between open and close string") { 252 | assert(noneString.ops.substringBetween("", "").isEmpty) 253 | assert("".ops.substringBetween(nullString, "").isEmpty) 254 | assert(Some("").ops.substringBetween(Some(""), noneString).isEmpty) 255 | assert("".ops.substringBetween("", "").contains("")) 256 | assert("foo".ops.substringBetween("", "").contains("")) 257 | assert("foo".ops.substringBetween(Some(""), Some("]")).isEmpty) 258 | assert("foo".ops.substringBetween("[", "]").isEmpty) 259 | assert(" ".ops.substringBetween(" ", " ").contains("")) 260 | assert("bar".ops.substringBetween("", "").contains("bar")) 261 | } 262 | 263 | test("test strings substring between open and close") { 264 | var results = "[one], [two], [three]".ops.substringsBetween("[", "]").get 265 | assert(3 == results.length) 266 | assert("one" == results(0)) 267 | assert("two" == results(1)) 268 | assert("three" == results(2)) 269 | 270 | results = "[one], [two], three".ops.substringsBetween(Some("["), Some("]")).get 271 | assert(2 == results.length) 272 | assert("one" == results(0)) 273 | assert("two" == results(1)) 274 | 275 | results = "[one], [two], three]".ops.substringsBetween("[", "]").get 276 | assert(2 == results.length) 277 | assert("one" == results(0)) 278 | assert("two" == results(1)) 279 | 280 | results = "[one], two], three]".ops.substringsBetween("[", "]").get 281 | assert(1 == results.length) 282 | assert("one" == results(0)) 283 | 284 | results = "one], two], [three]".ops.substringsBetween("[", "]").get 285 | assert(1 == results.length) 286 | assert("three" == results(0)) 287 | 288 | // 'ab hello ba' will match, but 'ab non ba' won't 289 | // this is because the 'a' is shared between the two and can't be matched twice 290 | results = "aabhellobabnonba".ops.substringsBetween("ab", "ba").get 291 | assert(1 == results.length) 292 | assert("hello" == results(0)) 293 | 294 | results = "one, two, three".ops.substringsBetween("[", "]").orNull 295 | assert(results == null) 296 | 297 | results = "[one, two, three".ops.substringsBetween("[", "]").orNull 298 | assert(results == null) 299 | 300 | results = "one, two, three]".ops.substringsBetween("[", "]").orNull 301 | assert(results == null) 302 | 303 | results = "[one], [two], [three]".ops.substringsBetween("[", null).orNull 304 | assert(results == null) 305 | 306 | results = "[one], [two], [three]".ops.substringsBetween(noneString, Some("]")).orNull 307 | assert(results == null) 308 | 309 | results = "[one], [two], [three]".ops.substringsBetween("", "").orNull 310 | assert(results == null) 311 | 312 | results = noneString.ops.substringsBetween("[", "]").orNull 313 | assert(results == null) 314 | 315 | results = "".ops.substringsBetween("[", "]").get 316 | assert(0 == results.length) 317 | } 318 | 319 | test("test string count matches with string") { 320 | assert(0 == nullString.ops.countMatches(noneString)) 321 | assert(0 == Some("blah").ops.countMatches(nullString)) 322 | assert(0 == nullString.ops.countMatches("DD")) 323 | 324 | assert(0 == "x".ops.countMatches("")) 325 | assert(0 == "".ops.countMatches("")) 326 | 327 | assert(3 == "one long someone sentence of one".ops.countMatches("one")) 328 | assert(0 == "one long someone sentence of one".ops.countMatches("two")) 329 | assert(4 == "oooooooooooo".ops.countMatches("ooo")) 330 | assert(0 == noneString.ops.countMatches("?")) 331 | assert(0 == "".ops.countMatches(Some("?"))) 332 | assert(0 == "abba".ops.countMatches(noneString)) 333 | assert(0 == "abba".ops.countMatches("")) 334 | assert(2 == Some("abba").ops.countMatches("a")) 335 | assert(1 == "abba".ops.countMatches("ab")) 336 | assert(0 == "abba".ops.countMatches("xxx")) 337 | assert(1 == "ababa".ops.countMatches("aba")) 338 | } 339 | 340 | test("test string count matches with char") { 341 | assert(0 == nullString.ops.countMatches('D')) 342 | assert(5 == "one long someone sentence of one".ops.countMatches(' ')) 343 | assert(6 == "one long someone sentence of one".ops.countMatches('o')) 344 | assert(4 == "oooooooooooo".ops.countMatches("ooo")) 345 | } 346 | } 347 | -------------------------------------------------------------------------------- /modules/bridge/src/test/scala/commons/lang3/bridge/StringUtilsTrimStripSpec.scala: -------------------------------------------------------------------------------- 1 | package commons.lang3.bridge 2 | 3 | import commons.lang3.bridge.StringUtils.ops.StringOptExt 4 | import commons.lang3.bridge.StringUtilsSpec._ 5 | import org.scalatest.funsuite.AnyFunSuite 6 | 7 | /** TODO 8 | * 9 | * @author 10 | * mars 11 | * @version 1.0.0 12 | * @since 2022/09/11 13 | * 23:26 14 | */ 15 | class StringUtilsTrimStripSpec extends AnyFunSuite { 16 | private val FOO = "foo" 17 | 18 | test("test trim") { 19 | assert(FOO == (FOO + " ").ops.trim.get) 20 | assert(FOO == (" " + FOO + " ").ops.trim.get) 21 | assert(FOO == (" " + FOO).ops.trim.get) 22 | assert(FOO == (FOO + "").ops.trim.get) 23 | assert(" \t\r\n\b ".ops.trim.contains("")) 24 | assert(TRIMMABLE.ops.trim.contains("")) 25 | assert(NON_TRIMMABLE == NON_TRIMMABLE.ops.trim.get) 26 | assert(Some("").ops.trim.contains("")) 27 | assert(noneString.ops.trim.isEmpty) 28 | } 29 | 30 | test("test string trim to null") { 31 | assert(FOO == (FOO + " ").ops.trimToNone.get) 32 | assert(FOO == (" " + FOO + " ").ops.trimToNone.get) 33 | assert(FOO == (" " + FOO).ops.trimToNone.get) 34 | assert(FOO == (FOO + "").ops.trimToNone.get) 35 | assert(Some(" \t\r\n\b ").ops.trimToNone.isEmpty) 36 | assert(TRIMMABLE.ops.trimToNone.isEmpty) 37 | assert(NON_TRIMMABLE == NON_TRIMMABLE.ops.trimToNone.get) 38 | assert("".ops.trimToNone.isEmpty) 39 | assert(noneString.ops.trimToNone.isEmpty) 40 | } 41 | 42 | test("test string trim to empty") { 43 | assert(FOO == (FOO + " ").ops.trimToEmpty.get) 44 | assert(FOO == (" " + FOO + " ").ops.trimToEmpty.get) 45 | assert(FOO == Some(" " + FOO).ops.trimToEmpty.get) 46 | assert(FOO == (FOO + "").ops.trimToEmpty.get) 47 | assert("" == " \t\r\n\b ".ops.trimToEmpty.get) 48 | assert("" == TRIMMABLE.ops.trimToEmpty.get) 49 | assert(NON_TRIMMABLE == NON_TRIMMABLE.ops.trimToEmpty.get) 50 | assert("" == "".ops.trimToEmpty.get) 51 | assert("" == noneString.ops.trimToEmpty.get) 52 | } 53 | 54 | test("test string strip") { 55 | assert(nullString.ops.strip.isEmpty) 56 | assert(Some("").ops.strip.contains("")) 57 | assert(" ".ops.strip.contains("")) 58 | assert(" abc ".ops.strip.contains("abc")) 59 | assert(NON_WHITESPACE == (WHITESPACE + NON_WHITESPACE + WHITESPACE).ops.strip.get) 60 | } 61 | 62 | test("test string strip to null") { 63 | assert(noneString.ops.stripToNone.isEmpty) 64 | assert("".ops.stripToNone.isEmpty) 65 | assert(Some(" ").ops.stripToNone.isEmpty) 66 | assert(WHITESPACE.ops.stripToNone.isEmpty) 67 | assert(" ab c ".ops.stripToNone.contains("ab c")) 68 | assert((WHITESPACE + NON_WHITESPACE + WHITESPACE).ops.stripToNone.contains(NON_WHITESPACE)) 69 | } 70 | 71 | test("test strip to empty") { 72 | assert("" == noneString.ops.stripToEmpty.get) 73 | assert("" == Some("").ops.stripToEmpty.get) 74 | assert("" == " ".ops.stripToEmpty.get) 75 | assert(WHITESPACE.ops.stripToEmpty.contains("")) 76 | assert(" ab c ".ops.stripToEmpty.contains("ab c")) 77 | assert((WHITESPACE + NON_WHITESPACE + WHITESPACE).ops.stripToEmpty.contains(NON_WHITESPACE)) 78 | } 79 | 80 | test("test string strip with strip chars") { 81 | // null strip 82 | assert(nullString.ops.strip(nullString).isEmpty) 83 | assert("".ops.strip(nullString).contains("")) 84 | assert(" ".ops.strip(noneString).contains("")) 85 | assert(" abc ".ops.strip(noneString).contains("abc")) 86 | assert(Some(WHITESPACE + NON_WHITESPACE + WHITESPACE).ops.strip[String](null).contains(NON_WHITESPACE)) 87 | 88 | // "" strip 89 | assert(nullString.ops.strip("").isEmpty) 90 | assert(Some("").ops.strip("").contains("")) 91 | assert(" ".ops.strip("").contains(" ")) 92 | assert(Some(" abc ").ops.strip(Some("")).contains(" abc ")) 93 | assert(WHITESPACE.ops.strip("").contains(WHITESPACE)) 94 | 95 | // " " strip 96 | assert(noneString.ops.strip(" ").isEmpty) 97 | assert("".ops.strip(" ").contains("")) 98 | assert(" ".ops.strip(" ").contains("")) 99 | assert(" abc ".ops.strip(" ").contains("abc")) 100 | 101 | // "ab" strip 102 | assert(nullString.ops.strip("ab").isEmpty) 103 | assert("".ops.strip("ab").contains("")) 104 | assert(" ".ops.strip("ab").contains(" ")) 105 | assert(" abc ".ops.strip("ab").contains(" abc ")) 106 | assert("abcabab".ops.strip("ab").contains("c")) 107 | assert(WHITESPACE.ops.strip("").contains(WHITESPACE)) 108 | } 109 | 110 | test("test string strip start with strip chars string") { 111 | // null stripStart 112 | assert(noneString.ops.stripStart(nullString).isEmpty) 113 | assert("".ops.stripStart(nullString).contains("")) 114 | assert(Some(" ").ops.stripStart(nullString).contains("")) 115 | assert(" abc ".ops.stripStart(noneString).contains("abc ")) 116 | assert((WHITESPACE + NON_WHITESPACE + WHITESPACE).ops.stripStart(nullString).contains(NON_WHITESPACE + WHITESPACE)) 117 | 118 | // "" stripStart 119 | assert(noneString.ops.stripStart("").isEmpty) 120 | assert("".ops.stripStart("").contains("")) 121 | assert(Some(" ").ops.stripStart("").contains(" ")) 122 | assert(" abc ".ops.stripStart("").contains(" abc ")) 123 | assert(WHITESPACE.ops.stripStart("").contains(WHITESPACE)) 124 | 125 | // " " stripStart 126 | assert(nullString.ops.stripStart(" ").isEmpty) 127 | assert("".ops.stripStart(" ").contains("")) 128 | assert(Some(" ").ops.stripStart(" ").contains("")) 129 | assert(" abc ".ops.stripStart(" ").contains("abc ")) 130 | 131 | // "ab" stripStart 132 | assert(nullString.ops.stripStart("ab").isEmpty) 133 | assert("".ops.stripStart("ab").contains("")) 134 | assert(" ".ops.stripStart("ab").contains(" ")) 135 | assert(" abc ".ops.stripStart(Some("ab")).contains(" abc ")) 136 | assert("abcabab".ops.stripStart("ab").contains("cabab")) 137 | assert(Some(WHITESPACE).ops.stripStart("").contains(WHITESPACE)) 138 | } 139 | 140 | test("test string strip end with strip chars string") { 141 | // null stripEnd 142 | assert(nullString.ops.stripEnd(nullString).isEmpty) 143 | assert("".ops.stripEnd(nullString).contains("")) 144 | assert(" ".ops.stripEnd(noneString).contains("")) 145 | assert(" abc ".ops.stripEnd(null).contains(" abc")) 146 | assert(Some(WHITESPACE + NON_WHITESPACE + WHITESPACE).ops.stripEnd(noneString).contains(WHITESPACE + NON_WHITESPACE)) 147 | 148 | // "" stripEnd 149 | assert(nullString.ops.stripEnd("").isEmpty) 150 | assert(Some("").ops.stripEnd("").contains("")) 151 | assert(" ".ops.stripEnd(Some("")).contains(" ")) 152 | assert(Some(" abc ").ops.stripEnd("").contains(" abc ")) 153 | assert(WHITESPACE.ops.stripEnd("").contains(WHITESPACE)) 154 | 155 | // " " stripEnd 156 | assert(nullString.ops.stripEnd(" ").isEmpty) 157 | assert("".ops.stripEnd(" ").contains("")) 158 | assert(" ".ops.stripEnd(" ").contains("")) 159 | assert(" abc ".ops.stripEnd(" ").contains(" abc")) 160 | 161 | // "ab" stripEnd 162 | assert(noneString.ops.stripEnd("ab").isEmpty) 163 | assert("".ops.stripEnd("ab").contains("")) 164 | assert(" ".ops.stripEnd(Some("ab")).contains(" ")) 165 | assert(" abc ".ops.stripEnd(Some("ab")).contains(" abc ")) 166 | assert(Some("abcabab").ops.stripEnd("ab").contains("abc")) 167 | assert(WHITESPACE.ops.stripEnd("").contains(WHITESPACE)) 168 | } 169 | 170 | test("test string strip accents") { 171 | val cue = "\u00C7\u00FA\u00EA" 172 | assert(cue.ops.stripAccents.contains("Cue"), "Failed to strip accents from " + cue) 173 | 174 | val lots = 175 | "\u00C0\u00C1\u00C2\u00C3\u00C4\u00C5\u00C7\u00C8\u00C9" + "\u00CA\u00CB\u00CC\u00CD\u00CE\u00CF\u00D1\u00D2\u00D3" + "\u00D4\u00D5\u00D6\u00D9\u00DA\u00DB\u00DC\u00DD" 176 | assert(lots.ops.stripAccents.contains("AAAAAACEEEEIIIINOOOOOUUUUY"), "Failed to strip accents from " + lots) 177 | 178 | assert(nullString.ops.stripAccents.isEmpty, "Failed null safety") 179 | assert(Some("").ops.stripAccents.contains(""), "Failed empty String") 180 | assert("control".ops.stripAccents.contains("control"), "Failed to handle non-accented text") 181 | assert("\u00E9clair".ops.stripAccents.contains("eclair"), "Failed to handle easy example") 182 | assert( 183 | ("\u0104\u0141\u00D3\u015A\u017B\u0179\u0106\u0143 " + "\u0105\u0142\u00F3\u015B\u017C\u017A\u0107\u0144").ops.stripAccents 184 | .contains("ALOSZZCN aloszzcn") 185 | ) 186 | } 187 | } 188 | -------------------------------------------------------------------------------- /project/CommonSettings.scala: -------------------------------------------------------------------------------- 1 | import sbt._ 2 | import sbt.Keys._ 3 | import ProjectKeys._ 4 | 5 | import djx.sbt.depts.output.Djx314DeptsPlugin.autoImport.scalaV 6 | 7 | object CommonSettings { 8 | 9 | // See https://www.scala-sbt.org/1.x/docs/Using-Sonatype.html for instructions on how to publish to Sonatype. 10 | private def scalacOptionsVersion(scalaVersion: Option[(Long, Long)]): Seq[String] = { 11 | val common = Seq( 12 | "-unchecked", 13 | "-deprecation", 14 | // "-Xfatal-warnings", 15 | "-encoding", 16 | "UTF-8" 17 | ) 18 | val compat = scalaVersion match { 19 | case Some((2, scalaMajor)) if scalaMajor == 11 => Seq("-Xexperimental", "-Xlint", "-Ywarn-dead-code") 20 | case Some((3, scalaMajor)) => Seq("-Ykind-projector") 21 | case _ => Nil 22 | } 23 | common ++ compat 24 | } 25 | 26 | private def genDirectory(sourceFile: File, c: String, parVersion: Option[(Long, Long)]): Seq[File] = { 27 | val common = sourceFile / c / "scala" 28 | val compat = parVersion match { 29 | case Some((2, 11)) => 30 | Seq(sourceFile / c / "scala-2", sourceFile / c / "scala-2.11", sourceFile / c / "scala-2.11-2.12") 31 | case Some((2, 12)) => 32 | Seq( 33 | sourceFile / c / "scala-2", 34 | sourceFile / c / "scala-2.11-2.12", 35 | sourceFile / c / "scala-2.12", 36 | sourceFile / c / "scala-2.12-2.13" 37 | ) 38 | case Some((2, 13)) => 39 | Seq(sourceFile / c / "scala-2", sourceFile / c / "scala-2.12-2.13", sourceFile / c / "scala-2.13") 40 | case Some((2, _)) => Seq(sourceFile / c / "scala-2") 41 | case Some((3, _)) => Seq(sourceFile / c / "scala-3") 42 | case _ => Seq.empty 43 | } 44 | common +: compat 45 | } 46 | 47 | val supportedScalaVersions = Seq(scalaV.v211, scalaV.v212, scalaV.v213, scalaV.v3) 48 | 49 | val pushSettings = Seq( 50 | version := "0.1.0", 51 | organization := "net.scalax", 52 | organizationName := "Scala Workers", 53 | organizationHomepage := Some(url("https://github.com/scala-workers")), 54 | scmInfo := Some( 55 | ScmInfo( 56 | url("https://github.com/scala-workers/commons-lang3-bridge"), 57 | "scm:git@github.com:scala-workers/commons-lang3-bridge.git" 58 | ) 59 | ), 60 | developers := List( 61 | Developer( 62 | id = "Mars Liu", 63 | name = "Liu Xin", 64 | email = "mars.liu@outlook.com", 65 | url = url("https://marchliu.github.io/") 66 | ), 67 | Developer( 68 | id = "djx314", 69 | name = "djx314", 70 | email = "djx314@sina.cn", 71 | url = url("https://github.com/djx314") 72 | ) 73 | ), 74 | description := "Scala Bridge For Apache Commons Lang3 Library", 75 | licenses := List("Apache" -> new URL("https://github.com/scala-workers/commons-lang3-bridge/blob/master/LICENSE")), 76 | homepage := Some(url("https://github.com/scala-workers/commons-lang3-bridge")), 77 | // Remove all additional repository other than Maven Central from POM 78 | pomIncludeRepository := { _ => false }, 79 | publishTo := { 80 | val nexus = "https://s01.oss.sonatype.org/" 81 | if (isSnapshot.value) Some("snapshots" at nexus + "content/repositories/snapshots") 82 | else Some("releases" at nexus + "service/local/staging/deploy/maven2") 83 | }, 84 | publishMavenStyle := true 85 | ) 86 | 87 | private val commonSetting = Seq( 88 | parVersion := CrossVersion.partialVersion(scalaVersion.value), 89 | scalaVersion := scalaV.v213, 90 | scalacOptions := scalacOptionsVersion(parVersion.value), 91 | org.scalafmt.sbt.ScalafmtPlugin.autoImport.scalafmtOnCompile := true, 92 | Compile / unmanagedSourceDirectories ++= { 93 | val addToMain = genDirectory(sourceDirectory.value, "main", parVersion.value) 94 | val addToCodeGen = genDirectory(sourceDirectory.value, "codegen", parVersion.value) 95 | addToMain ++: addToCodeGen 96 | }, 97 | Test / unmanagedSourceDirectories ++= genDirectory(sourceDirectory.value, "test", parVersion.value) 98 | ) 99 | 100 | val commonProjectSettings = pushSettings ++ commonSetting ++ Seq(crossScalaVersions := supportedScalaVersions) 101 | val codegenProjectSettings = commonSetting 102 | 103 | } 104 | -------------------------------------------------------------------------------- /project/ProjectKeys.scala: -------------------------------------------------------------------------------- 1 | import sbt._ 2 | import sbt.Keys._ 3 | 4 | object ProjectKeys { 5 | val parVersion = settingKey[Option[(Long, Long)]]("parVersion") 6 | } 7 | -------------------------------------------------------------------------------- /project/build.properties: -------------------------------------------------------------------------------- 1 | sbt.version=1.9.6 2 | -------------------------------------------------------------------------------- /project/plugins.sbt: -------------------------------------------------------------------------------- 1 | import djx.sbt.depts.plugins.{PluginsCollection => projectPlugins} 2 | 3 | addSbtPlugin(projectPlugins.`sbt-scalafmt`) 4 | addSbtPlugin(projectPlugins.`sbt-twirl`) 5 | addSbtPlugin(projectPlugins.`sbt-sonatype`) 6 | addSbtPlugin(projectPlugins.`sbt-pgp`) 7 | -------------------------------------------------------------------------------- /project/project/sbt-depts-djx314-lib.sbt: -------------------------------------------------------------------------------- 1 | libraryDependencies += "net.scalax.djx314" %% "sbt-depts-djx314-plugins" % "0.0.1-M768" 2 | -------------------------------------------------------------------------------- /project/sbt-depts-plugin.sbt: -------------------------------------------------------------------------------- 1 | addSbtPlugin("net.scalax.djx314" % "sbt-depts-djx314" % "0.0.1-M768") 2 | --------------------------------------------------------------------------------