BooleanExpressionRule fixes

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter3/BooleanExpressionsRuleFixTest.kt

@@ -25,4 +25,22 @@ class BooleanExpressionsRuleFixTest : FixTestBase("test/paragraph3/boolean_expre
     fun `check same expressions`() {
         fixAndCompare("SameExpressionsInConditionExpected.kt", "SameExpressionsInConditionTest.kt")
     }
+
+    @Test
+    @Tag(WarningNames.COMPLEX_BOOLEAN_EXPRESSION)
+    fun `check substitution works properly`() {
+        fixAndCompare("SubstitutionIssueExpected.kt", "SubstitutionIssueTest.kt")
+    }
+
+    @Test
+    @Tag(WarningNames.COMPLEX_BOOLEAN_EXPRESSION)
+    fun `check ordering is persisted`() {
+        fixAndCompare("OrderIssueExpected.kt", "OrderIssueTest.kt")
+    }
+
+    @Test
+    @Tag(WarningNames.COMPLEX_BOOLEAN_EXPRESSION)
+    fun `check handling of negative expression`() {
+        fixAndCompare("NegativeExpressionExpected.kt", "NegativeExpressionTest.kt")
+    }
 }

diktat-rules/src/test/kotlin/org/cqfn/diktat/ruleset/chapter3/BooleanExpressionsRuleWarnTest.kt

@@ -234,7 +234,7 @@ class BooleanExpressionsRuleWarnTest : LintTestBase(::BooleanExpressionsRule) {
                     // nested boolean expressions in lambdas
                     if (currentProperty.nextSibling { it.elementType == PROPERTY } == nextProperty) {}
 
-                    if (!(rightSide == null || leftSide == null) &&
+                    if (rightSide != null && leftSide != null &&
                         rightSide.size == leftSide.size &&
                         rightSide.zip(leftSide).all { (first, second) -> first.text == second.text }) {}
 
@@ -283,10 +283,11 @@ class BooleanExpressionsRuleWarnTest : LintTestBase(::BooleanExpressionsRule) {
         val stream = ByteArrayOutputStream()
         System.setErr(PrintStream(stream))
         val node = KotlinParser().createNode(expression)
-        val map: java.util.HashMap<String, Char> = HashMap()
-        val result = BooleanExpressionsRule(emptyList()).formatBooleanExpressionAsString(node, map)
+        val rule = BooleanExpressionsRule(emptyList())
+        val map: BooleanExpressionsRule.ExpressionsReplacement = rule.ExpressionsReplacement()
+        val result = rule.formatBooleanExpressionAsString(node, map)
         Assertions.assertEquals(expectedRepresentation, result)
-        Assertions.assertEquals(expectedMapSize, map.size)
+        Assertions.assertEquals(expectedMapSize, map.size())
         System.setErr(System.err)
         val stderr = stream.toString()
         Assertions.assertTrue(stderr.isEmpty()) {

diktat-rules/src/test/resources/test/paragraph3/boolean_expressions/NegativeExpressionExpected.kt

@@ -0,0 +1,8 @@
+package test.paragraph3.boolean_expressions
+
+fun foo() {
+    if (bar) {
+    }
+    if (bar) {
+    }
+}

diktat-rules/src/test/resources/test/paragraph3/boolean_expressions/NegativeExpressionTest.kt

@@ -0,0 +1,8 @@
+package test.paragraph3.boolean_expressions
+
+fun foo() {
+    if (bar && (!isEmpty() || isEmpty())) {
+    }
+    if (bar && (isEmpty() || !isEmpty())) {
+    }
+}

diktat-rules/src/test/resources/test/paragraph3/boolean_expressions/OrderIssueExpected.kt

@@ -0,0 +1,6 @@
+package test.paragraph3.boolean_expressions
+
+fun foo() {
+    if (isB && isA && isC) {
+    }
+}

diktat-rules/src/test/resources/test/paragraph3/boolean_expressions/OrderIssueTest.kt

@@ -0,0 +1,6 @@
+package test.paragraph3.boolean_expressions
+
+fun foo() {
+    if (isB && isA && isC && (isEmpty() || !isEmpty())) {
+    }
+}

diktat-rules/src/test/resources/test/paragraph3/boolean_expressions/SubstitutionIssueExpected.kt

@@ -0,0 +1,8 @@
+package test.paragraph3.boolean_expressions
+
+fun foo() {
+    if (isABC_A && isABC_B && isABC_C) {
+    }
+    if (isAdd && isAdded()) {
+    }
+}

diktat-rules/src/test/resources/test/paragraph3/boolean_expressions/SubstitutionIssueTest.kt

@@ -0,0 +1,8 @@
+package test.paragraph3.boolean_expressions
+
+fun foo() {
+    if (isABC_A && isABC_B && isABC_C && (isEmpty() || !isEmpty())) {
+    }
+    if (isAdd && isAdded() && (isEmpty() || !isEmpty())) {
+    }
+}