#813 Fix PR suggestions.

Author: yruslan

cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/decoders/DecoderSelector.scala

@@ -217,7 +217,7 @@ object DecoderSelector {
             StringDecoders.decodeAsciiInt(_, !isSigned, isSigned || !strictSignOverpunch, !strictSignOverpunch, improvedNullDetection)
         } else if (integralType.precision <= Constants.maxLongPrecision) {
           if (isEbcidic)
-            StringDecoders.decodeEbcdicLong(_, !isSigned, isSigned || !strictSignOverpunch, improvedNullDetection, !strictSignOverpunch)
+            StringDecoders.decodeEbcdicLong(_, !isSigned, isSigned || !strictSignOverpunch, !strictSignOverpunch, improvedNullDetection)
           else
             StringDecoders.decodeAsciiLong(_, !isSigned, isSigned || !strictSignOverpunch, !strictSignOverpunch, improvedNullDetection)
         } else {

cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/decoders/StringDecoders.scala

@@ -162,7 +162,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @return A string representation of the binary data
     */
@@ -235,7 +235,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed in first or last position
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @return A string representation of the binary data
     */
@@ -303,7 +303,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @return A boxed integer
     */
@@ -321,7 +321,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed in first or last position
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @return A boxed integer
     */
@@ -339,11 +339,11 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
     * @return A boxed long
     */
-  final def decodeEbcdicLong(bytes: Array[Byte], isUnsigned: Boolean, allowSignOverpunch: Boolean, improvedNullDetection: Boolean, relaxedOvepunch: Boolean): java.lang.Long = {
+  final def decodeEbcdicLong(bytes: Array[Byte], isUnsigned: Boolean, allowSignOverpunch: Boolean, relaxedOvepunch: Boolean, improvedNullDetection: Boolean): java.lang.Long = {
     try {
       decodeEbcdicNumber(bytes, isUnsigned, allowSignOverpunch, relaxedOvepunch, improvedNullDetection).toLong
     } catch {
@@ -357,7 +357,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed in first or last position
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @return A boxed long
     */
@@ -375,7 +375,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @param scale                 A decimal scale in case decimal number with implicit decimal point is expected
     * @param scaleFactor           Additional zeros to be added before of after the decimal point
@@ -395,7 +395,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed in first or last position
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @param scale                 A decimal scale in case decimal number with implicit decimal point is expected
     * @param scaleFactor           Additional zeros to be added before of after the decimal point
@@ -416,7 +416,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed in first or last position
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @return A big decimal containing a big integral number
     */
@@ -435,7 +435,7 @@ object StringDecoders {
     * @param bytes                 A byte array that represents the binary data
     * @param isUnsigned            If true, negative numbers will be considered invalid and return null
     * @param allowSignOverpunch    If true, sign overpunching is allowed in first or last position
-    * @param relaxedOvepunch       If true, multiple published signs are allowed. The last is going to be effective
+    * @param relaxedOvepunch       If true, multiple sign overpunching characters are allowed. The last one is going to be effective
     * @param improvedNullDetection If true, return null if all bytes are zero
     * @return A big decimal containing a big integral number
     */

cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/decoders/StringDecodersSpec.scala

@@ -785,28 +785,28 @@ class StringDecodersSpec extends AnyWordSpec {
 
   "decodeEbcdicLong()" should {
     "decode parsable longs" in {
-      assert(decodeEbcdicLong(toEbcdic("+1000000000000000"), isUnsigned = false, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == 1000000000000000L)
-      assert(decodeEbcdicLong(toEbcdic("1000000000000000+"), isUnsigned = false, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == 1000000000000000L)
-      assert(decodeEbcdicLong(toEbcdic("-1000000000000000"), isUnsigned = false, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == -1000000000000000L)
-      assert(decodeEbcdicLong(toEbcdic("1000000000000000-"), isUnsigned = false, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == -1000000000000000L)
+      assert(decodeEbcdicLong(toEbcdic("+1000000000000000"), isUnsigned = false, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == 1000000000000000L)
+      assert(decodeEbcdicLong(toEbcdic("1000000000000000+"), isUnsigned = false, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == 1000000000000000L)
+      assert(decodeEbcdicLong(toEbcdic("-1000000000000000"), isUnsigned = false, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == -1000000000000000L)
+      assert(decodeEbcdicLong(toEbcdic("1000000000000000-"), isUnsigned = false, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == -1000000000000000L)
     }
 
     "decode unsigned numbers with sign" in {
-      assert(decodeEbcdicLong(toEbcdic("+1000000000000000"), isUnsigned = true, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == 1000000000000000L)
-      assert(decodeEbcdicLong(toEbcdic("1000000000000000+"), isUnsigned = true, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == 1000000000000000L)
-      assert(decodeEbcdicLong(toEbcdic("-1000000000000000"), isUnsigned = true, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == null)
-      assert(decodeEbcdicLong(toEbcdic("1000000000000000-"), isUnsigned = true, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == null)
+      assert(decodeEbcdicLong(toEbcdic("+1000000000000000"), isUnsigned = true, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == 1000000000000000L)
+      assert(decodeEbcdicLong(toEbcdic("1000000000000000+"), isUnsigned = true, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == 1000000000000000L)
+      assert(decodeEbcdicLong(toEbcdic("-1000000000000000"), isUnsigned = true, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == null)
+      assert(decodeEbcdicLong(toEbcdic("1000000000000000-"), isUnsigned = true, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == null)
     }
 
     "return null on non-ints longs" in {
-      assert(decodeEbcdicLong(toEbcdic("+1000000000000000,0"), isUnsigned = true, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == null)
-      assert(decodeEbcdicLong(toEbcdic("1000000000000000.00+"), isUnsigned = false, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == null)
-      assert(decodeEbcdicLong(toEbcdic("-1000000000000000,000"), isUnsigned = false, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == null)
-      assert(decodeEbcdicLong(toEbcdic("1000000000000000.000-"), isUnsigned = false, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == null)
+      assert(decodeEbcdicLong(toEbcdic("+1000000000000000,0"), isUnsigned = true, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == null)
+      assert(decodeEbcdicLong(toEbcdic("1000000000000000.00+"), isUnsigned = false, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == null)
+      assert(decodeEbcdicLong(toEbcdic("-1000000000000000,000"), isUnsigned = false, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == null)
+      assert(decodeEbcdicLong(toEbcdic("1000000000000000.000-"), isUnsigned = false, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == null)
     }
 
     "return null on unparsable longs" in {
-      assert(decodeEbcdicLong(toEbcdic("AAA"), isUnsigned = false, allowSignOverpunch = true, improvedNullDetection = false, relaxedOvepunch = false) == null)
+      assert(decodeEbcdicLong(toEbcdic("AAA"), isUnsigned = false, allowSignOverpunch = true, relaxedOvepunch = false, improvedNullDetection = false) == null)
     }
 
   }

spark-cobol/src/test/scala/za/co/absa/cobrix/spark/cobol/source/regression/Test19SignOverpunching.scala

@@ -168,7 +168,7 @@ class Test19SignOverpunching extends AnyWordSpec with SparkTestBase with BinaryF
       }
     }
 
-    "Test relaxed overpunchiung" when {
+    "Test relaxed sign overpunching" when {
       val copybook =
         """         01  R.
            05  A    PIC S9(5)V9.