diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/Logger.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/Logger.kt
index 852ad103..c4fff9bf 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/Logger.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/Logger.kt
@@ -1,5 +1,8 @@
 package org.hisp.dhis.rules
 
-data class Logger(val severe: (String) -> Unit, val fine: (String) -> Unit)
+data class Logger(
+    val severe: (String) -> Unit,
+    val fine: (String) -> Unit,
+)
 
-expect fun createLogger(className: String): Logger
\ No newline at end of file
+expect fun createLogger(className: String): Logger
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/api/DataItem.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/api/DataItem.kt
index 3c54ded0..2f7ed1f8 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/api/DataItem.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/api/DataItem.kt
@@ -4,4 +4,7 @@ package org.hisp.dhis.rules.api
  * Class is place holder for program rule variable, Constant and program environment variable display name and type.
  * @author Zubair Asghar
  */
-data class DataItem(val displayName: String, val valueType: ItemValueType)
\ No newline at end of file
+data class DataItem(
+    val displayName: String,
+    val valueType: ItemValueType,
+)
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/api/EnvironmentVariables.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/api/EnvironmentVariables.kt
index 165dac95..dfed951b 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/api/EnvironmentVariables.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/api/EnvironmentVariables.kt
@@ -3,25 +3,26 @@ package org.hisp.dhis.rules.api
 import org.hisp.dhis.rules.utils.RuleEngineUtils
 
 object EnvironmentVariables {
-    val ENV_VARIABLES = mapOf(
-        Pair(RuleEngineUtils.ENV_VAR_COMPLETED_DATE, ItemValueType.DATE),
-        Pair(RuleEngineUtils.ENV_VAR_CURRENT_DATE, ItemValueType.DATE),
-        Pair(RuleEngineUtils.ENV_VAR_EVENT_DATE, ItemValueType.DATE),
-        Pair(RuleEngineUtils.ENV_VAR_INCIDENT_DATE, ItemValueType.DATE),
-        Pair(RuleEngineUtils.ENV_VAR_ENROLLMENT_DATE, ItemValueType.DATE),
-        Pair(RuleEngineUtils.ENV_VAR_DUE_DATE, ItemValueType.DATE),
-        Pair(RuleEngineUtils.ENV_VAR_EVENT_COUNT, ItemValueType.NUMBER),
-        Pair(RuleEngineUtils.ENV_VAR_TEI_COUNT, ItemValueType.NUMBER),
-        Pair(RuleEngineUtils.ENV_VAR_ENROLLMENT_COUNT, ItemValueType.NUMBER),
-        Pair(RuleEngineUtils.ENV_VAR_EVENT_ID, ItemValueType.NUMBER),
-        Pair(RuleEngineUtils.ENV_VAR_PROGRAM_STAGE_ID, ItemValueType.NUMBER),
-        Pair(RuleEngineUtils.ENV_VAR_ENROLLMENT_ID, ItemValueType.NUMBER),
-        Pair(RuleEngineUtils.ENV_VAR_ENROLLMENT_STATUS, ItemValueType.TEXT),
-        Pair(RuleEngineUtils.ENV_VAR_EVENT_STATUS, ItemValueType.TEXT),
-        Pair(RuleEngineUtils.ENV_VAR_OU, ItemValueType.TEXT),
-        Pair(RuleEngineUtils.ENV_VAR_OU_CODE, ItemValueType.TEXT),
-        Pair(RuleEngineUtils.ENV_VAR_ENVIRONMENT, ItemValueType.TEXT),
-        Pair(RuleEngineUtils.ENV_VAR_PROGRAM_NAME, ItemValueType.TEXT),
-        Pair(RuleEngineUtils.ENV_VAR_PROGRAM_STAGE_NAME, ItemValueType.TEXT)
-    )
-}
\ No newline at end of file
+    val ENV_VARIABLES =
+        mapOf(
+            Pair(RuleEngineUtils.ENV_VAR_COMPLETED_DATE, ItemValueType.DATE),
+            Pair(RuleEngineUtils.ENV_VAR_CURRENT_DATE, ItemValueType.DATE),
+            Pair(RuleEngineUtils.ENV_VAR_EVENT_DATE, ItemValueType.DATE),
+            Pair(RuleEngineUtils.ENV_VAR_INCIDENT_DATE, ItemValueType.DATE),
+            Pair(RuleEngineUtils.ENV_VAR_ENROLLMENT_DATE, ItemValueType.DATE),
+            Pair(RuleEngineUtils.ENV_VAR_DUE_DATE, ItemValueType.DATE),
+            Pair(RuleEngineUtils.ENV_VAR_EVENT_COUNT, ItemValueType.NUMBER),
+            Pair(RuleEngineUtils.ENV_VAR_TEI_COUNT, ItemValueType.NUMBER),
+            Pair(RuleEngineUtils.ENV_VAR_ENROLLMENT_COUNT, ItemValueType.NUMBER),
+            Pair(RuleEngineUtils.ENV_VAR_EVENT_ID, ItemValueType.NUMBER),
+            Pair(RuleEngineUtils.ENV_VAR_PROGRAM_STAGE_ID, ItemValueType.NUMBER),
+            Pair(RuleEngineUtils.ENV_VAR_ENROLLMENT_ID, ItemValueType.NUMBER),
+            Pair(RuleEngineUtils.ENV_VAR_ENROLLMENT_STATUS, ItemValueType.TEXT),
+            Pair(RuleEngineUtils.ENV_VAR_EVENT_STATUS, ItemValueType.TEXT),
+            Pair(RuleEngineUtils.ENV_VAR_OU, ItemValueType.TEXT),
+            Pair(RuleEngineUtils.ENV_VAR_OU_CODE, ItemValueType.TEXT),
+            Pair(RuleEngineUtils.ENV_VAR_ENVIRONMENT, ItemValueType.TEXT),
+            Pair(RuleEngineUtils.ENV_VAR_PROGRAM_NAME, ItemValueType.TEXT),
+            Pair(RuleEngineUtils.ENV_VAR_PROGRAM_STAGE_NAME, ItemValueType.TEXT),
+        )
+}
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/api/RuleEngine.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/api/RuleEngine.kt
index d2e5852a..90f60bd2 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/api/RuleEngine.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/api/RuleEngine.kt
@@ -5,16 +5,37 @@ import org.hisp.dhis.rules.models.*
 import kotlin.jvm.JvmStatic
 
 interface RuleEngine {
-    fun validate(expression: String, dataItemStore: Map<String, DataItem>): RuleValidationResult
-    fun validateDataFieldExpression(expression: String, dataItemStore: Map<String, DataItem>): RuleValidationResult
-    fun evaluateAll(enrollmentTarget: RuleEnrollment?, eventsTarget: List<RuleEvent>, executionContext: RuleEngineContext): List<RuleEffects>
-    fun evaluate(target: RuleEnrollment, ruleEvents: List<RuleEvent>, executionContext: RuleEngineContext): List<RuleEffect>
-    fun evaluate(target: RuleEvent, ruleEnrollment: RuleEnrollment?, ruleEvents: List<RuleEvent>, executionContext: RuleEngineContext): List<RuleEffect>
+    fun validate(
+        expression: String,
+        dataItemStore: Map<String, DataItem>,
+    ): RuleValidationResult
+
+    fun validateDataFieldExpression(
+        expression: String,
+        dataItemStore: Map<String, DataItem>,
+    ): RuleValidationResult
+
+    fun evaluateAll(
+        enrollmentTarget: RuleEnrollment?,
+        eventsTarget: List<RuleEvent>,
+        executionContext: RuleEngineContext,
+    ): List<RuleEffects>
+
+    fun evaluate(
+        target: RuleEnrollment,
+        ruleEvents: List<RuleEvent>,
+        executionContext: RuleEngineContext,
+    ): List<RuleEffect>
+
+    fun evaluate(
+        target: RuleEvent,
+        ruleEnrollment: RuleEnrollment?,
+        ruleEvents: List<RuleEvent>,
+        executionContext: RuleEngineContext,
+    ): List<RuleEffect>
 
     companion object {
         @JvmStatic
-        fun getInstance(): RuleEngine {
-            return DefaultRuleEngine()
-        }
+        fun getInstance(): RuleEngine = DefaultRuleEngine()
     }
-}
\ No newline at end of file
+}
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/api/RuleEngineContext.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/api/RuleEngineContext.kt
index eb2e973b..71d45e40 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/api/RuleEngineContext.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/api/RuleEngineContext.kt
@@ -7,5 +7,5 @@ data class RuleEngineContext(
     val rules: List<Rule>,
     val ruleVariables: List<RuleVariable> = emptyList(),
     val supplementaryData: Map<String, List<String>> = emptyMap(),
-    val constantsValues: Map<String, String> = emptyMap()
+    val constantsValues: Map<String, String> = emptyMap(),
 )
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/DefaultRuleEngine.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/DefaultRuleEngine.kt
index c3a7d7b9..edd37edf 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/DefaultRuleEngine.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/DefaultRuleEngine.kt
@@ -10,42 +10,88 @@ import org.hisp.dhis.rules.api.RuleEngine
 import org.hisp.dhis.rules.api.RuleEngineContext
 import org.hisp.dhis.rules.models.*
 
-internal class DefaultRuleEngine: RuleEngine {
-    override fun evaluate(target: RuleEvent, ruleEnrollment: RuleEnrollment?, ruleEvents: List<RuleEvent>, executionContext: RuleEngineContext): List<RuleEffect> {
-        val valueMap = RuleVariableValueMapBuilder().build(executionContext.constantsValues, executionContext.ruleVariables, ruleEvents.toSet(), ruleEnrollment, target)
+internal class DefaultRuleEngine : RuleEngine {
+    override fun evaluate(
+        target: RuleEvent,
+        ruleEnrollment: RuleEnrollment?,
+        ruleEvents: List<RuleEvent>,
+        executionContext: RuleEngineContext,
+    ): List<RuleEffect> {
+        val valueMap =
+            RuleVariableValueMapBuilder().build(
+                executionContext.constantsValues,
+                executionContext.ruleVariables,
+                ruleEvents.toSet(),
+                ruleEnrollment,
+                target,
+            )
         return RuleConditionEvaluator().getRuleEffects(
-            TrackerObjectType.EVENT, target.event, valueMap,
-            executionContext.supplementaryData, executionContext.rules
+            TrackerObjectType.EVENT,
+            target.event,
+            valueMap,
+            executionContext.supplementaryData,
+            executionContext.rules,
         )
     }
 
-    override fun evaluate(target: RuleEnrollment, ruleEvents: List<RuleEvent>, executionContext: RuleEngineContext): List<RuleEffect> {
-        val valueMap = RuleVariableValueMapBuilder().build(executionContext.constantsValues, executionContext.ruleVariables, ruleEvents.toSet(), target)
+    override fun evaluate(
+        target: RuleEnrollment,
+        ruleEvents: List<RuleEvent>,
+        executionContext: RuleEngineContext,
+    ): List<RuleEffect> {
+        val valueMap =
+            RuleVariableValueMapBuilder().build(
+                executionContext.constantsValues,
+                executionContext.ruleVariables,
+                ruleEvents.toSet(),
+                target,
+            )
         return RuleConditionEvaluator().getRuleEffects(
-            TrackerObjectType.ENROLLMENT, target.enrollment, valueMap,
-            executionContext.supplementaryData, executionContext.rules
+            TrackerObjectType.ENROLLMENT,
+            target.enrollment,
+            valueMap,
+            executionContext.supplementaryData,
+            executionContext.rules,
         )
     }
 
-    override fun evaluateAll(enrollmentTarget: RuleEnrollment?, eventsTarget: List<RuleEvent>, executionContext: RuleEngineContext): List<RuleEffects> {
-        val valueMap = RuleVariableValueMapBuilder()
+    override fun evaluateAll(
+        enrollmentTarget: RuleEnrollment?,
+        eventsTarget: List<RuleEvent>,
+        executionContext: RuleEngineContext,
+    ): List<RuleEffects> {
+        val valueMap =
+            RuleVariableValueMapBuilder()
                 .multipleBuild(executionContext.constantsValues, executionContext.ruleVariables, eventsTarget.toSet(), enrollmentTarget)
-        return RuleEngineMultipleExecution().execute(executionContext.rules, valueMap,
-                executionContext.supplementaryData)
+        return RuleEngineMultipleExecution().execute(
+            executionContext.rules,
+            valueMap,
+            executionContext.supplementaryData,
+        )
     }
 
-    override fun validate(expression: String, dataItemStore: Map<String, DataItem>): RuleValidationResult {
+    override fun validate(
+        expression: String,
+        dataItemStore: Map<String, DataItem>,
+    ): RuleValidationResult {
         // Rule condition expression should be evaluated against Boolean
         return getExpressionDescription(expression, ExpressionMode.RULE_ENGINE_CONDITION, dataItemStore)
     }
 
-    override fun validateDataFieldExpression(expression: String, dataItemStore: Map<String, DataItem>): RuleValidationResult {
+    override fun validateDataFieldExpression(
+        expression: String,
+        dataItemStore: Map<String, DataItem>,
+    ): RuleValidationResult {
         // Rule action data field should be evaluated against all i.e Boolean, String, Date and Numerical value
         return getExpressionDescription(expression, ExpressionMode.RULE_ENGINE_ACTION, dataItemStore)
     }
 
-    private fun getExpressionDescription(expression: String, mode: ExpressionMode, dataItemStore: Map<String, DataItem>): RuleValidationResult {
-        return try {
+    private fun getExpressionDescription(
+        expression: String,
+        mode: ExpressionMode,
+        dataItemStore: Map<String, DataItem>,
+    ): RuleValidationResult =
+        try {
             val validationMap: Map<String, ValueType> = dataItemStore.mapValues { e -> e.value.valueType.toValueType() }
             Expression(expression, mode, false).validate(validationMap)
             val displayNames: Map<String, String> = dataItemStore.mapValues { e -> e.value.displayName }
@@ -55,14 +101,13 @@ internal class DefaultRuleEngine: RuleEngine {
             RuleValidationResult(
                 valid = false,
                 exception = RuleEngineValidationException(ex),
-                errorMessage = ex.message
+                errorMessage = ex.message,
             )
         } catch (ex: ParseException) {
             RuleValidationResult(
                 valid = false,
                 exception = RuleEngineValidationException(ex),
-                errorMessage = ex.message
+                errorMessage = ex.message,
             )
         }
-    }
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleConditionEvaluator.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleConditionEvaluator.kt
index 4f744b57..0ef0743f 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleConditionEvaluator.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleConditionEvaluator.kt
@@ -17,7 +17,7 @@ internal class RuleConditionEvaluator {
         targetUid: String,
         valueMap: Map<String, RuleVariableValue>,
         supplementaryData: Map<String, List<String>>,
-        rules: List<Rule>
+        rules: List<Rule>,
     ): List<RuleEffect> {
         val ruleEvaluationResults = getRuleEvaluationResults(targetType, targetUid, valueMap, supplementaryData, rules)
         return ruleEvaluationResults
@@ -29,25 +29,27 @@ internal class RuleConditionEvaluator {
         targetUid: String,
         valueMap: Map<String, RuleVariableValue>,
         supplementaryData: Map<String, List<String>>,
-        rules: List<Rule>
+        rules: List<Rule>,
     ): List<RuleEffect> {
-        val ruleEvaluationResults = getRuleEvaluationResults(
-            targetType,
-            targetUid,
-            valueMap,
-            supplementaryData,
-            rules
-        )
+        val ruleEvaluationResults =
+            getRuleEvaluationResults(
+                targetType,
+                targetUid,
+                valueMap,
+                supplementaryData,
+                rules,
+            )
         return ruleEvaluationResults
             .filter { result -> !result.error }
             .flatMap { result -> result.ruleEffects }
     }
 
     fun getRuleEvaluationResults(
-        targetType: TrackerObjectType, targetUid: String,
+        targetType: TrackerObjectType,
+        targetUid: String,
         valueMap: Map<String, RuleVariableValue>,
         supplementaryData: Map<String, List<String>>,
-        rules: List<Rule>
+        rules: List<Rule>,
     ): List<RuleEvaluationResult> {
         val mutableValueMap = valueMap.toMutableMap()
         val ruleEvaluationResults: MutableList<RuleEvaluationResult> = ArrayList()
@@ -59,12 +61,12 @@ internal class RuleConditionEvaluator {
                         rule.condition,
                         mutableValueMap,
                         supplementaryData,
-                        ExpressionMode.RULE_ENGINE_CONDITION
+                        ExpressionMode.RULE_ENGINE_CONDITION,
                     ).toBoolean()
                 ) {
                     for (action in rule.actions) {
                         try {
-                            //Check if action is assigning value to calculated variable
+                            // Check if action is assigning value to calculated variable
                             if (isAssignToCalculatedValue(action)) {
                                 updateValueMap(
                                     unwrapVariableName(action.content()!!),
@@ -72,9 +74,9 @@ internal class RuleConditionEvaluator {
                                         RuleValueType.TEXT,
                                         process(action.data, mutableValueMap, supplementaryData, ExpressionMode.RULE_ENGINE_ACTION),
                                         listOf(),
-                                        null
+                                        null,
                                     ),
-                                    mutableValueMap
+                                    mutableValueMap,
                                 )
                             } else {
                                 ruleEffects.add(create(rule, action, mutableValueMap, supplementaryData))
@@ -94,83 +96,92 @@ internal class RuleConditionEvaluator {
         for ((rule, _, evaluatedAs) in ruleEvaluationResults) {
             log.fine(
                 "Rule " + rule.name + " with id " + rule.uid +
-                        " executed for " + targetType.name + "(" + targetUid + ")" +
-                        " with condition (" + rule.condition + ")" +
-                        " was evaluated " + evaluatedAs
+                    " executed for " + targetType.name + "(" + targetUid + ")" +
+                    " with condition (" + rule.condition + ")" +
+                    " was evaluated " + evaluatedAs,
             )
         }
         return ruleEvaluationResults
     }
 
     private fun addRuleErrorResult(
-        rule: Rule, ruleAction: RuleAction?, e: Exception, targetType: TrackerObjectType,
-        targetUid: String, ruleEvaluationResults: MutableList<RuleEvaluationResult>
+        rule: Rule,
+        ruleAction: RuleAction?,
+        e: Exception,
+        targetType: TrackerObjectType,
+        targetUid: String,
+        ruleEvaluationResults: MutableList<RuleEvaluationResult>,
     ) {
         val errorMessage: String
-        errorMessage = if (ruleAction != null && e is IllegalExpressionException) {
-            "Action " + ruleAction::class.simpleName +
+        errorMessage =
+            if (ruleAction != null && e is IllegalExpressionException) {
+                "Action " + ruleAction::class.simpleName +
                     " from rule " + rule.name + " with id " + rule.uid +
                     " executed for " + targetType.name + "(" + targetUid + ")" +
                     " with condition (" + rule.condition + ")" +
                     " raised an error: " + e.message
-        } else if (ruleAction != null) {
-            "Action " + ruleAction::class.simpleName +
+            } else if (ruleAction != null) {
+                "Action " + ruleAction::class.simpleName +
                     " from rule " + rule.name + " with id " + rule.uid +
                     " executed for " + targetType.name + "(" + targetUid + ")" +
                     " with condition (" + rule.condition + ")" +
                     " raised an unexpected exception: " + e.message
-        } else if (e is IllegalExpressionException) {
-            "Rule " + rule.name + " with id " + rule.uid +
+            } else if (e is IllegalExpressionException) {
+                "Rule " + rule.name + " with id " + rule.uid +
                     " executed for " + targetType.name + "(" + targetUid + ")" +
                     " with condition (" + rule.condition + ")" +
                     " raised an error: " + e.message
-        } else {
-            "Rule " + rule.name + " with id " + rule.uid +
+            } else {
+                "Rule " + rule.name + " with id " + rule.uid +
                     " executed for " + targetType.name + "(" + targetUid + ")" +
                     " with condition (" + rule.condition + ")" +
                     " raised an unexpected exception: " + e.message
-        }
+            }
         log.severe(errorMessage)
         ruleEvaluationResults.add(errorRule(rule, errorMessage))
     }
 
     private fun process(
-        condition: String?, valueMap: Map<String, RuleVariableValue>,
-        supplementaryData: Map<String, List<String>>, mode: ExpressionMode
+        condition: String?,
+        valueMap: Map<String, RuleVariableValue>,
+        supplementaryData: Map<String, List<String>>,
+        mode: ExpressionMode,
     ): String {
         if (condition.isNullOrEmpty()) {
             return ""
         }
         val expression = Expression(condition, mode, false)
 
-        val build = ExpressionData(
-            valueMap.mapValues { v -> v.value.toVariableValue() },
-            emptyMap(),
-            supplementaryData,
-            emptyMap(),
-            emptyMap()
-        )
-        return convertInteger(expression.evaluate({ name: String ->
-            throw UnsupportedOperationException(
-                "function not supported: $name"
+        val build =
+            ExpressionData(
+                valueMap.mapValues { v -> v.value.toVariableValue() },
+                emptyMap(),
+                supplementaryData,
+                emptyMap(),
+                emptyMap(),
             )
-        }, build)).toString()
+        return convertInteger(
+            expression.evaluate({ name: String ->
+                throw UnsupportedOperationException(
+                    "function not supported: $name",
+                )
+            }, build),
+        ).toString()
     }
 
-    private fun convertInteger(result: Any?): Any? {
-        return if (result is Double && result % 1 == 0.0) {
+    private fun convertInteger(result: Any?): Any? =
+        if (result is Double && result % 1 == 0.0) {
             result.toInt()
-        } else result
-    }
+        } else {
+            result
+        }
 
-    private fun isAssignToCalculatedValue(ruleAction: RuleAction): Boolean {
-        return ruleAction.type == "ASSIGN" && ruleAction.field() == null
-    }
+    private fun isAssignToCalculatedValue(ruleAction: RuleAction): Boolean = ruleAction.type == "ASSIGN" && ruleAction.field() == null
 
     private fun updateValueMap(
         variable: String,
         value: RuleVariableValue,
-        valueMap: MutableMap<String, RuleVariableValue>
+        valueMap: MutableMap<String, RuleVariableValue>,
     ) {
         valueMap[variable] = value
     }
@@ -179,7 +190,7 @@ internal class RuleConditionEvaluator {
         rule: Rule,
         ruleAction: RuleAction,
         valueMap: MutableMap<String, RuleVariableValue>,
-        supplementaryData: Map<String, List<String>>
+        supplementaryData: Map<String, List<String>>,
     ): RuleEffect {
         if (ruleAction.type == "ASSIGN") {
             val data = process(ruleAction.data, valueMap, supplementaryData, ExpressionMode.RULE_ENGINE_ACTION)
@@ -190,11 +201,21 @@ internal class RuleConditionEvaluator {
                 RuleEffect(rule.uid, ruleAction, data)
             }
         }
-        val data = if (!ruleAction.data.isNullOrEmpty()) process(ruleAction.data, valueMap, supplementaryData, ExpressionMode.RULE_ENGINE_ACTION) else ""
+        val data =
+            if (!ruleAction.data.isNullOrEmpty()) {
+                process(
+                    ruleAction.data,
+                    valueMap,
+                    supplementaryData,
+                    ExpressionMode.RULE_ENGINE_ACTION,
+                )
+            } else {
+                ""
+            }
         return RuleEffect(
             rule.uid,
             ruleAction,
-            data
+            data,
         )
     }
 
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleEngineMultipleExecution.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleEngineMultipleExecution.kt
index b2cd9227..0aa1f343 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleEngineMultipleExecution.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleEngineMultipleExecution.kt
@@ -3,31 +3,43 @@ package org.hisp.dhis.rules.engine
 import org.hisp.dhis.rules.models.*
 
 internal class RuleEngineMultipleExecution {
-    fun execute(rules: List<Rule>, ruleVariableValueMap: RuleVariableValueMap,
-                supplementaryData: Map<String, List<String>>): List<RuleEffects> {
+    fun execute(
+        rules: List<Rule>,
+        ruleVariableValueMap: RuleVariableValueMap,
+        supplementaryData: Map<String, List<String>>,
+    ): List<RuleEffects> {
         val ruleEffects: MutableList<RuleEffects> = ArrayList()
         for ((enrollment, valueMap) in ruleVariableValueMap.enrollmentMap) {
-            val enrollmentRuleEffects = RuleConditionEvaluator()
-                .getEvaluatedAndErrorRuleEffects(
-                    TrackerObjectType.ENROLLMENT, enrollment.enrollment, valueMap,
-                    supplementaryData, filterRules(rules)
-                )
+            val enrollmentRuleEffects =
+                RuleConditionEvaluator()
+                    .getEvaluatedAndErrorRuleEffects(
+                        TrackerObjectType.ENROLLMENT,
+                        enrollment.enrollment,
+                        valueMap,
+                        supplementaryData,
+                        filterRules(rules),
+                    )
             ruleEffects.add(
                 RuleEffects(
-                    TrackerObjectType.ENROLLMENT, enrollment.enrollment,
-                    enrollmentRuleEffects
-                )
+                    TrackerObjectType.ENROLLMENT,
+                    enrollment.enrollment,
+                    enrollmentRuleEffects,
+                ),
             )
         }
         for ((event, valueMap) in ruleVariableValueMap.eventMap) {
             ruleEffects.add(
                 RuleEffects(
-                    TrackerObjectType.EVENT, event.event,
+                    TrackerObjectType.EVENT,
+                    event.event,
                     RuleConditionEvaluator().getEvaluatedAndErrorRuleEffects(
-                        TrackerObjectType.EVENT, event.event, valueMap,
-                        supplementaryData, filterRules(rules, event)
-                    )
-                )
+                        TrackerObjectType.EVENT,
+                        event.event,
+                        valueMap,
+                        supplementaryData,
+                        filterRules(rules, event),
+                    ),
+                ),
             )
         }
         return ruleEffects
@@ -38,35 +50,46 @@ internal class RuleEngineMultipleExecution {
         for (rule in rules) {
             val programStage: String? = rule.programStage
             if (programStage.isNullOrEmpty()) {
-                val ruleActions = filterActionRules(
-                    rule.actions,
-                    AttributeType.TRACKED_ENTITY_ATTRIBUTE
-                )
+                val ruleActions =
+                    filterActionRules(
+                        rule.actions,
+                        AttributeType.TRACKED_ENTITY_ATTRIBUTE,
+                    )
                 filteredRules.add(rule.copy(actions = ruleActions))
             }
         }
         return filteredRules
     }
 
-    private fun filterRules(rules: List<Rule>, ruleEvent: RuleEvent): List<Rule> {
+    private fun filterRules(
+        rules: List<Rule>,
+        ruleEvent: RuleEvent,
+    ): List<Rule> {
         val filteredRules: MutableList<Rule> = mutableListOf()
         for (rule in rules) {
             val programStage: String? = rule.programStage
             if (programStage.isNullOrEmpty() || programStage == ruleEvent.programStage) {
-                val ruleActions = filterActionRules(
-                    rule.actions,
-                    AttributeType.DATA_ELEMENT
-                )
+                val ruleActions =
+                    filterActionRules(
+                        rule.actions,
+                        AttributeType.DATA_ELEMENT,
+                    )
                 filteredRules.add(rule.copy(actions = ruleActions))
             }
         }
         return filteredRules
     }
 
-    private fun filterActionRules(ruleActions: List<RuleAction>, attributeType: AttributeType): List<RuleAction> {
+    private fun filterActionRules(
+        ruleActions: List<RuleAction>,
+        attributeType: AttributeType,
+    ): List<RuleAction> {
         val filteredRuleActions: MutableList<RuleAction> = mutableListOf()
         for (ruleAction in ruleActions) {
-            if (ruleAction.attributeType() == null || ruleAction.attributeType() == attributeType.name || ruleAction.attributeType() == AttributeType.UNKNOWN.name) {
+            if (ruleAction.attributeType() == null ||
+                ruleAction.attributeType() == attributeType.name ||
+                ruleAction.attributeType() == AttributeType.UNKNOWN.name
+            ) {
                 filteredRuleActions.add(ruleAction)
             }
         }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleEvaluationResult.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleEvaluationResult.kt
index b20385a0..1e5a91ac 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleEvaluationResult.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleEvaluationResult.kt
@@ -8,25 +8,28 @@ internal data class RuleEvaluationResult(
     val rule: Rule,
     val ruleEffects: List<RuleEffect>,
     val evaluatedAs: Boolean,
-    val error: Boolean
+    val error: Boolean,
 ) {
     companion object {
-        fun evaluatedResult(rule: Rule, ruleEffects: List<RuleEffect>): RuleEvaluationResult {
-            return RuleEvaluationResult(rule, ruleEffects, true, false)
-        }
+        fun evaluatedResult(
+            rule: Rule,
+            ruleEffects: List<RuleEffect>,
+        ): RuleEvaluationResult = RuleEvaluationResult(rule, ruleEffects, true, false)
 
-        fun notEvaluatedResult(rule: Rule): RuleEvaluationResult {
-            return RuleEvaluationResult(rule, emptyList(), false, false)
-        }
+        fun notEvaluatedResult(rule: Rule): RuleEvaluationResult = RuleEvaluationResult(rule, emptyList(), false, false)
 
-        fun errorRule(rule: Rule, errorMessage: String): RuleEvaluationResult {
-            val effects = listOf(
-                RuleEffect(
-                    rule.uid,
-                    RuleAction(errorMessage, "ERROR"),
-                    errorMessage
+        fun errorRule(
+            rule: Rule,
+            errorMessage: String,
+        ): RuleEvaluationResult {
+            val effects =
+                listOf(
+                    RuleEffect(
+                        rule.uid,
+                        RuleAction(errorMessage, "ERROR"),
+                        errorMessage,
+                    ),
                 )
-            )
             return RuleEvaluationResult(rule, effects, false, true)
         }
     }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValue.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValue.kt
index ee6c7c2e..f30e7db1 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValue.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValue.kt
@@ -8,18 +8,15 @@ data class RuleVariableValue(
     val type: RuleValueType,
     val value: String? = null,
     val candidates: List<String> = listOf(),
-    val eventDate: String? = null
+    val eventDate: String? = null,
 ) {
-    fun toVariableValue(): VariableValue {
-        return VariableValue(valueType(), value, candidates, eventDate)
-    }
+    fun toVariableValue(): VariableValue = VariableValue(valueType(), value, candidates, eventDate)
 
-    private fun valueType(): ValueType {
-        return when (type) {
+    private fun valueType(): ValueType =
+        when (type) {
             RuleValueType.DATE -> ValueType.DATE
             RuleValueType.NUMERIC -> ValueType.NUMBER
             RuleValueType.BOOLEAN -> ValueType.BOOLEAN
             else -> ValueType.STRING
         }
-    }
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValueMap.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValueMap.kt
index 9546726b..1a53d3b3 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValueMap.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValueMap.kt
@@ -5,5 +5,5 @@ import org.hisp.dhis.rules.models.RuleEvent
 
 internal data class RuleVariableValueMap(
     val enrollmentMap: Map<RuleEnrollment, Map<String, RuleVariableValue>>,
-    val eventMap: Map<RuleEvent, Map<String, RuleVariableValue>>
-)
\ No newline at end of file
+    val eventMap: Map<RuleEvent, Map<String, RuleVariableValue>>,
+)
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValueMapBuilder.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValueMapBuilder.kt
index ba36333c..b9756264 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValueMapBuilder.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/engine/RuleVariableValueMapBuilder.kt
@@ -8,27 +8,54 @@ import org.hisp.dhis.rules.utils.RuleEngineUtils
 import org.hisp.dhis.rules.utils.currentDate
 
 internal class RuleVariableValueMapBuilder {
-
-    fun build(allConstantValues: Map<String, String>, ruleVariables: List<RuleVariable>, ruleEvents: Set<RuleEvent>, ruleEnrollment: RuleEnrollment? = null, ruleEvent: RuleEvent? = null): Map<String, RuleVariableValue> {
-        val allEvents = ruleEvent?.let { val set = HashSet(ruleEvents); set.add(it); set.toSet() } ?: ruleEvents
-        return buildEnvironmentVariables(allEvents, ruleEnrollment, ruleEvent) + buildRuleVariableValues(ruleVariables, allEvents, ruleEnrollment, ruleEvent) + buildConstantsValues(allConstantValues)
+    fun build(
+        allConstantValues: Map<String, String>,
+        ruleVariables: List<RuleVariable>,
+        ruleEvents: Set<RuleEvent>,
+        ruleEnrollment: RuleEnrollment? = null,
+        ruleEvent: RuleEvent? = null,
+    ): Map<String, RuleVariableValue> {
+        val allEvents =
+            ruleEvent?.let {
+                val set = HashSet(ruleEvents)
+                set.add(it)
+                set.toSet()
+            } ?: ruleEvents
+        return buildEnvironmentVariables(allEvents, ruleEnrollment, ruleEvent) +
+            buildRuleVariableValues(ruleVariables, allEvents, ruleEnrollment, ruleEvent) +
+            buildConstantsValues(allConstantValues)
     }
 
-    fun multipleBuild(allConstantValues: Map<String, String>, ruleVariables: List<RuleVariable>, ruleEvents: Set<RuleEvent>, ruleEnrollment: RuleEnrollment? = null): RuleVariableValueMap {
-        val enrollmentMap = ruleEnrollment?.let { enrollment -> mapOf(Pair(enrollment, build(allConstantValues, ruleVariables, ruleEvents, ruleEnrollment))) }.orEmpty()
-        return RuleVariableValueMap(enrollmentMap, ruleEvents.associateBy( {it}, {build(allConstantValues, ruleVariables, ruleEvents, ruleEnrollment, it)} ))
+    fun multipleBuild(
+        allConstantValues: Map<String, String>,
+        ruleVariables: List<RuleVariable>,
+        ruleEvents: Set<RuleEvent>,
+        ruleEnrollment: RuleEnrollment? = null,
+    ): RuleVariableValueMap {
+        val enrollmentMap =
+            ruleEnrollment
+                ?.let { enrollment ->
+                    mapOf(Pair(enrollment, build(allConstantValues, ruleVariables, ruleEvents, ruleEnrollment)))
+                }.orEmpty()
+        return RuleVariableValueMap(
+            enrollmentMap,
+            ruleEvents.associateBy({
+                it
+            }, { build(allConstantValues, ruleVariables, ruleEvents, ruleEnrollment, it) }),
+        )
     }
 
-    private fun buildCurrentEnrollmentValues(ruleEnrollment: RuleEnrollment): Map<String, RuleAttributeValue> {
-        return ruleEnrollment.attributeValues.associateBy { it.trackedEntityAttribute }
-    }
+    private fun buildCurrentEnrollmentValues(ruleEnrollment: RuleEnrollment): Map<String, RuleAttributeValue> =
+        ruleEnrollment.attributeValues.associateBy {
+            it.trackedEntityAttribute
+        }
 
     private fun buildAllEventValues(ruleEvents: Set<RuleEvent>): Map<String, List<RuleDataValueHistory>> {
         val allEventsValues: MutableMap<String, MutableList<RuleDataValueHistory>> = HashMap()
         val events: MutableList<RuleEvent> = ArrayList(ruleEvents)
 
         // sort list of events by eventDate and createdDate:
-        events.sortWith(compareBy<RuleEvent>({ it.eventDate}, {it.createdDate }).reversed())
+        events.sortWith(compareBy<RuleEvent>({ it.eventDate }, { it.createdDate }).reversed())
 
         // aggregating values by data element uid
         for (i in events.indices) {
@@ -42,17 +69,24 @@ internal class RuleVariableValueMapBuilder {
                 }
 
                 // append data value to the list
-                allEventsValues[ruleDataValue.dataElement]?.add(RuleDataValueHistory(ruleDataValue.value, events[i].eventDate, events[i].createdDate, events[i].programStage))
+                allEventsValues[ruleDataValue.dataElement]?.add(
+                    RuleDataValueHistory(ruleDataValue.value, events[i].eventDate, events[i].createdDate, events[i].programStage),
+                )
             }
         }
         return allEventsValues.toMap()
     }
 
-    private fun buildConstantsValues(allConstantValues: Map<String, String>): Map<String, RuleVariableValue> {
-        return allConstantValues.mapValues { RuleVariableValue(RuleValueType.NUMERIC, it.value) }
-    }
+    private fun buildConstantsValues(allConstantValues: Map<String, String>): Map<String, RuleVariableValue> =
+        allConstantValues.mapValues {
+            RuleVariableValue(RuleValueType.NUMERIC, it.value)
+        }
 
-    private fun buildEnvironmentVariables(ruleEvents: Set<RuleEvent>, ruleEnrollment: RuleEnrollment?, ruleEvent: RuleEvent?): Map<String, RuleVariableValue> {
+    private fun buildEnvironmentVariables(
+        ruleEvents: Set<RuleEvent>,
+        ruleEnrollment: RuleEnrollment?,
+        ruleEvent: RuleEvent?,
+    ): Map<String, RuleVariableValue> {
         val currentDate = LocalDate.Companion.currentDate()
 
         val environmentVariablesValuesMap = buildEnvironmentVariables(ruleEvents, currentDate)
@@ -62,67 +96,103 @@ internal class RuleVariableValueMapBuilder {
         return environmentVariablesValuesMap + enrollmentVariableValueMap + eventVariableValueMap
     }
 
-    private fun buildEnvironmentVariables(ruleEvents: Set<RuleEvent>, currentDate: LocalDate): Map<String, RuleVariableValue> {
+    private fun buildEnvironmentVariables(
+        ruleEvents: Set<RuleEvent>,
+        currentDate: LocalDate,
+    ): Map<String, RuleVariableValue> {
         val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
-        valueMap[RuleEngineUtils.ENV_VAR_CURRENT_DATE] = RuleVariableValue(
-            RuleValueType.TEXT,
-            currentDate.toString(),
-            listOf(currentDate.toString()),
-            currentDate.toString()
-        )
-        valueMap[RuleEngineUtils.ENV_VAR_EVENT_COUNT] = RuleVariableValue(
-            RuleValueType.NUMERIC, ruleEvents.size.toString(),
-            listOf(ruleEvents.size.toString()), currentDate.toString()
-        )
+        valueMap[RuleEngineUtils.ENV_VAR_CURRENT_DATE] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                currentDate.toString(),
+                listOf(currentDate.toString()),
+                currentDate.toString(),
+            )
+        valueMap[RuleEngineUtils.ENV_VAR_EVENT_COUNT] =
+            RuleVariableValue(
+                RuleValueType.NUMERIC,
+                ruleEvents.size.toString(),
+                listOf(ruleEvents.size.toString()),
+                currentDate.toString(),
+            )
         val environment = TriggerEnvironment.SERVER.clientName
-        valueMap[RuleEngineUtils.ENV_VAR_ENVIRONMENT] = RuleVariableValue(
-            RuleValueType.TEXT,
-            environment,
-            listOf(environment),
-            currentDate.toString()
-        )
+        valueMap[RuleEngineUtils.ENV_VAR_ENVIRONMENT] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                environment,
+                listOf(environment),
+                currentDate.toString(),
+            )
 
         return valueMap.toMap()
     }
 
-    private fun buildEventEnvironmentVariables(ruleEvents: Set<RuleEvent>, ruleEvent: RuleEvent, currentDate: LocalDate): Map<String, RuleVariableValue> {
+    private fun buildEventEnvironmentVariables(
+        ruleEvents: Set<RuleEvent>,
+        ruleEvent: RuleEvent,
+        currentDate: LocalDate,
+    ): Map<String, RuleVariableValue> {
         val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
-        val eventDate = ruleEvent.eventDate.toLocalDateTime(TimeZone.currentSystemDefault()).date.toString()
-        valueMap[RuleEngineUtils.ENV_VAR_EVENT_DATE] = RuleVariableValue(
-            RuleValueType.TEXT, eventDate, listOf(eventDate), currentDate.toString()
-        )
+        val eventDate =
+            ruleEvent.eventDate
+                .toLocalDateTime(TimeZone.currentSystemDefault())
+                .date
+                .toString()
+        valueMap[RuleEngineUtils.ENV_VAR_EVENT_DATE] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                eventDate,
+                listOf(eventDate),
+                currentDate.toString(),
+            )
         if (ruleEvent.dueDate != null) {
             val dueDate = ruleEvent.dueDate
-            valueMap[RuleEngineUtils.ENV_VAR_DUE_DATE] = RuleVariableValue(
-                RuleValueType.TEXT, dueDate.toString(),
-                listOf(dueDate.toString()), currentDate.toString()
-            )
+            valueMap[RuleEngineUtils.ENV_VAR_DUE_DATE] =
+                RuleVariableValue(
+                    RuleValueType.TEXT,
+                    dueDate.toString(),
+                    listOf(dueDate.toString()),
+                    currentDate.toString(),
+                )
         }
         if (ruleEvent.completedDate != null) {
             val completedDate = ruleEvent.completedDate
-            valueMap[RuleEngineUtils.ENV_VAR_COMPLETED_DATE] = RuleVariableValue(
-                RuleValueType.TEXT, completedDate.toString(),
-                listOf(completedDate.toString()), currentDate.toString()
-            )
+            valueMap[RuleEngineUtils.ENV_VAR_COMPLETED_DATE] =
+                RuleVariableValue(
+                    RuleValueType.TEXT,
+                    completedDate.toString(),
+                    listOf(completedDate.toString()),
+                    currentDate.toString(),
+                )
         }
 
         val eventCount = ruleEvents.size.toString()
-        valueMap[RuleEngineUtils.ENV_VAR_EVENT_COUNT] = RuleVariableValue(
-            RuleValueType.NUMERIC, eventCount,
-            listOf(eventCount), currentDate.toString()
-        )
-        valueMap[RuleEngineUtils.ENV_VAR_EVENT_ID] = RuleVariableValue(
-            RuleValueType.TEXT, ruleEvent.event,
-            listOf(ruleEvent.event), currentDate.toString()
-        )
+        valueMap[RuleEngineUtils.ENV_VAR_EVENT_COUNT] =
+            RuleVariableValue(
+                RuleValueType.NUMERIC,
+                eventCount,
+                listOf(eventCount),
+                currentDate.toString(),
+            )
+        valueMap[RuleEngineUtils.ENV_VAR_EVENT_ID] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                ruleEvent.event,
+                listOf(ruleEvent.event),
+                currentDate.toString(),
+            )
         val status = ruleEvent.status.toString()
-        valueMap[RuleEngineUtils.ENV_VAR_EVENT_STATUS] = RuleVariableValue(
-            RuleValueType.TEXT, status, listOf(status), currentDate.toString()
-        )
+        valueMap[RuleEngineUtils.ENV_VAR_EVENT_STATUS] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                status,
+                listOf(status),
+                currentDate.toString(),
+            )
         val organisationUnit = ruleEvent.organisationUnit
         valueMap[RuleEngineUtils.ENV_VAR_OU] = RuleVariableValue(RuleValueType.TEXT, organisationUnit)
         val programStageId = ruleEvent.programStage
-        valueMap[RuleEngineUtils.ENV_VAR_PROGRAM_STAGE_ID] = RuleVariableValue(RuleValueType.TEXT, programStageId )
+        valueMap[RuleEngineUtils.ENV_VAR_PROGRAM_STAGE_ID] = RuleVariableValue(RuleValueType.TEXT, programStageId)
         val programStageName = ruleEvent.programStageName
         valueMap[RuleEngineUtils.ENV_VAR_PROGRAM_STAGE_NAME] = RuleVariableValue(RuleValueType.TEXT, programStageName)
         val organisationUnitCode = ruleEvent.organisationUnitCode
@@ -132,35 +202,56 @@ internal class RuleVariableValueMapBuilder {
         return valueMap.toMap()
     }
 
-    private fun buildEnrollmentEnvironmentVariables(ruleEnrollment: RuleEnrollment, currentDate: LocalDate): Map<String, RuleVariableValue> {
+    private fun buildEnrollmentEnvironmentVariables(
+        ruleEnrollment: RuleEnrollment,
+        currentDate: LocalDate,
+    ): Map<String, RuleVariableValue> {
         val valueMap: MutableMap<String, RuleVariableValue> = HashMap()
-        valueMap[RuleEngineUtils.ENV_VAR_ENROLLMENT_ID] = RuleVariableValue(
-            RuleValueType.TEXT, ruleEnrollment.enrollment,
-            listOf(ruleEnrollment.enrollment), currentDate.toString()
-        )
-        valueMap[RuleEngineUtils.ENV_VAR_ENROLLMENT_COUNT] = RuleVariableValue(
-            RuleValueType.NUMERIC, "1",
-            listOf("1"), currentDate.toString()
-        )
-        valueMap[RuleEngineUtils.ENV_VAR_TEI_COUNT] = RuleVariableValue(
-            RuleValueType.NUMERIC, "1",
-            listOf("1"), currentDate.toString()
-        )
+        valueMap[RuleEngineUtils.ENV_VAR_ENROLLMENT_ID] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                ruleEnrollment.enrollment,
+                listOf(ruleEnrollment.enrollment),
+                currentDate.toString(),
+            )
+        valueMap[RuleEngineUtils.ENV_VAR_ENROLLMENT_COUNT] =
+            RuleVariableValue(
+                RuleValueType.NUMERIC,
+                "1",
+                listOf("1"),
+                currentDate.toString(),
+            )
+        valueMap[RuleEngineUtils.ENV_VAR_TEI_COUNT] =
+            RuleVariableValue(
+                RuleValueType.NUMERIC,
+                "1",
+                listOf("1"),
+                currentDate.toString(),
+            )
         val enrollmentDate = ruleEnrollment.enrollmentDate
-        valueMap[RuleEngineUtils.ENV_VAR_ENROLLMENT_DATE] = RuleVariableValue(
-            RuleValueType.TEXT, enrollmentDate.toString(),
-            listOf(enrollmentDate.toString()), currentDate.toString()
-        )
+        valueMap[RuleEngineUtils.ENV_VAR_ENROLLMENT_DATE] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                enrollmentDate.toString(),
+                listOf(enrollmentDate.toString()),
+                currentDate.toString(),
+            )
         val incidentDate = ruleEnrollment.incidentDate
-        valueMap[RuleEngineUtils.ENV_VAR_INCIDENT_DATE] = RuleVariableValue(
-            RuleValueType.TEXT, incidentDate.toString(),
-            listOf(incidentDate.toString()), currentDate.toString()
-        )
+        valueMap[RuleEngineUtils.ENV_VAR_INCIDENT_DATE] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                incidentDate.toString(),
+                listOf(incidentDate.toString()),
+                currentDate.toString(),
+            )
         val status = ruleEnrollment.status.toString()
-        valueMap[RuleEngineUtils.ENV_VAR_ENROLLMENT_STATUS] = RuleVariableValue(
-            RuleValueType.TEXT, status,
-            listOf(status), currentDate.toString()
-        )
+        valueMap[RuleEngineUtils.ENV_VAR_ENROLLMENT_STATUS] =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                status,
+                listOf(status),
+                currentDate.toString(),
+            )
         val organisationUnit = ruleEnrollment.organisationUnit
         valueMap[RuleEngineUtils.ENV_VAR_OU] = RuleVariableValue(RuleValueType.TEXT, organisationUnit)
         val programName = ruleEnrollment.programName
@@ -172,20 +263,27 @@ internal class RuleVariableValueMapBuilder {
         return valueMap.toMap()
     }
 
-    private fun buildRuleVariableValues(ruleVariables: List<RuleVariable>, ruleEvents: Set<RuleEvent>, ruleEnrollment: RuleEnrollment?, ruleEvent: RuleEvent?): Map<String, RuleVariableValue> {
+    private fun buildRuleVariableValues(
+        ruleVariables: List<RuleVariable>,
+        ruleEvents: Set<RuleEvent>,
+        ruleEnrollment: RuleEnrollment?,
+        ruleEvent: RuleEvent?,
+    ): Map<String, RuleVariableValue> {
         // map data values within all events to data elements
         val allEventValues = buildAllEventValues(ruleEvents)
 
         // map tracked entity attributes to values from enrollment
-        val currentEnrollmentValues = ruleEnrollment?.let {buildCurrentEnrollmentValues(it)}.orEmpty()
+        val currentEnrollmentValues = ruleEnrollment?.let { buildCurrentEnrollmentValues(it) }.orEmpty()
 
         return ruleVariables.associateBy(
-            {it.name},
-            {it.createValues(
-                ruleEvent,
-                allEventValues,
-                currentEnrollmentValues
-            )}
+            { it.name },
+            {
+                it.createValues(
+                    ruleEvent,
+                    allEventValues,
+                    currentEnrollmentValues,
+                )
+            },
         )
     }
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/AttributeType.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/AttributeType.kt
index e5c47be2..caaff902 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/AttributeType.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/AttributeType.kt
@@ -6,5 +6,5 @@ package org.hisp.dhis.rules.models
 enum class AttributeType {
     DATA_ELEMENT,
     TRACKED_ENTITY_ATTRIBUTE,
-    UNKNOWN
+    UNKNOWN,
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/Option.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/Option.kt
index 91f26b2e..f35f850d 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/Option.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/Option.kt
@@ -3,4 +3,7 @@ package org.hisp.dhis.rules.models
 import kotlin.js.JsExport
 
 @JsExport
-data class Option(val name: String, val code: String)
+data class Option(
+    val name: String,
+    val code: String,
+)
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/Rule.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/Rule.kt
index e55042c2..f6dbcd03 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/Rule.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/Rule.kt
@@ -6,10 +6,10 @@ data class Rule(
     val uid: String = "",
     val name: String? = null,
     val programStage: String? = null,
-    val priority: Int? = 0
-):Comparable<Rule>{
-    override fun compareTo(other: Rule): Int {
-        return if (this.priority != null && other.priority != null) {
+    val priority: Int? = 0,
+) : Comparable<Rule> {
+    override fun compareTo(other: Rule): Int =
+        if (this.priority != null && other.priority != null) {
             this.priority.compareTo(other.priority)
         } else if (this.priority != null) {
             -1
@@ -18,5 +18,4 @@ data class Rule(
         } else {
             0
         }
-    }
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleAction.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleAction.kt
index f85a01f4..df748b85 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleAction.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleAction.kt
@@ -3,17 +3,11 @@ package org.hisp.dhis.rules.models
 data class RuleAction(
     val data: String?,
     val type: String,
-    val values: Map<String, String> = emptyMap()
-){
-    fun content():String? {
-        return values["content"]
-    }
+    val values: Map<String, String> = emptyMap(),
+) {
+    fun content(): String? = values["content"]
 
-    fun field():String? {
-        return values["field"]
-    }
+    fun field(): String? = values["field"]
 
-    fun attributeType():String? {
-        return values["attributeType"]
-    }
-}
\ No newline at end of file
+    fun attributeType(): String? = values["attributeType"]
+}
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleAttributeValue.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleAttributeValue.kt
index 3c9e1570..a42f0235 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleAttributeValue.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleAttributeValue.kt
@@ -5,5 +5,5 @@ import kotlin.js.JsExport
 @JsExport
 data class RuleAttributeValue(
     val trackedEntityAttribute: String,
-    val value: String
+    val value: String,
 )
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleDataValue.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleDataValue.kt
index f47342a3..7500ae8c 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleDataValue.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleDataValue.kt
@@ -5,5 +5,5 @@ import kotlin.js.JsExport
 @JsExport
 data class RuleDataValue(
     val dataElement: String,
-    val value: String
+    val value: String,
 )
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleDataValueHistory.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleDataValueHistory.kt
index c9a8b5bd..b8ba40fa 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleDataValueHistory.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleDataValueHistory.kt
@@ -6,5 +6,5 @@ data class RuleDataValueHistory(
     val value: String,
     val eventDate: Instant,
     val createdDate: Instant,
-    val programStage: String
+    val programStage: String,
 )
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEffect.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEffect.kt
index 66f3ca22..c8747ad5 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEffect.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEffect.kt
@@ -3,5 +3,5 @@ package org.hisp.dhis.rules.models
 data class RuleEffect(
     val ruleId: String,
     val ruleAction: RuleAction,
-    val data: String? = ""
-)
\ No newline at end of file
+    val data: String? = "",
+)
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEffects.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEffects.kt
index f7676281..fdd8d442 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEffects.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEffects.kt
@@ -1,8 +1,9 @@
 package org.hisp.dhis.rules.models
+
 data class RuleEffects(
     val trackerObjectType: TrackerObjectType,
     val trackerObjectUid: String,
-    val ruleEffects: List<RuleEffect>
+    val ruleEffects: List<RuleEffect>,
 ) {
     val isEnrollment: Boolean
         get() = trackerObjectType == TrackerObjectType.ENROLLMENT
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEngineValidationException.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEngineValidationException.kt
index 7a7df64d..889d9f10 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEngineValidationException.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEngineValidationException.kt
@@ -1,3 +1,5 @@
 package org.hisp.dhis.rules.models
 
-class RuleEngineValidationException(cause: IllegalArgumentException) : IllegalArgumentException(cause.message) 
\ No newline at end of file
+class RuleEngineValidationException(
+    cause: IllegalArgumentException,
+) : IllegalArgumentException(cause.message) 
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEnrollment.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEnrollment.kt
index 12382f4e..379d9444 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEnrollment.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEnrollment.kt
@@ -10,5 +10,5 @@ data class RuleEnrollment(
     val status: RuleEnrollmentStatus,
     val organisationUnit: String,
     val organisationUnitCode: String?,
-    val attributeValues: List<RuleAttributeValue>
+    val attributeValues: List<RuleAttributeValue>,
 )
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEnrollmentStatus.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEnrollmentStatus.kt
index 11c96d4d..17a9327b 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEnrollmentStatus.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEnrollmentStatus.kt
@@ -6,5 +6,5 @@ import kotlin.js.JsExport
 enum class RuleEnrollmentStatus {
     ACTIVE,
     COMPLETED,
-    CANCELLED
-}
\ No newline at end of file
+    CANCELLED,
+}
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEvent.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEvent.kt
index 8379c06b..08f73b7b 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEvent.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEvent.kt
@@ -14,5 +14,5 @@ data class RuleEvent(
     val completedDate: LocalDate?,
     val organisationUnit: String,
     val organisationUnitCode: String?,
-    val dataValues: List<RuleDataValue>
+    val dataValues: List<RuleDataValue>,
 )
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEventStatus.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEventStatus.kt
index 5476f787..422e16e1 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEventStatus.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleEventStatus.kt
@@ -9,5 +9,5 @@ enum class RuleEventStatus {
     SCHEDULE,
     SKIPPED,
     VISITED,
-    OVERDUE
-}
\ No newline at end of file
+    OVERDUE,
+}
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleValidationResult.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleValidationResult.kt
index 150d4327..347375c3 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleValidationResult.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleValidationResult.kt
@@ -33,24 +33,24 @@ import kotlin.jvm.JvmStatic
 
 @JsExport
 data class RuleValidationResult(
-        val valid: Boolean,
-        val errorMessage: String? = null,
-        val exception: Throwable? = null,
-        val description: String? = null
-){
-        companion object {
-                @JvmStatic
-                fun invalid(errorMessage: String): RuleValidationResult {
-                        return RuleValidationResult(
-                                valid = false, errorMessage = errorMessage
-                        )
-                }
+    val valid: Boolean,
+    val errorMessage: String? = null,
+    val exception: Throwable? = null,
+    val description: String? = null,
+) {
+    companion object {
+        @JvmStatic
+        fun invalid(errorMessage: String): RuleValidationResult =
+            RuleValidationResult(
+                valid = false,
+                errorMessage = errorMessage,
+            )
 
-                @JvmStatic
-                fun valid(description: String): RuleValidationResult {
-                        return RuleValidationResult(
-                                valid = true, description = description
-                        )
-                }
-        }
-}
\ No newline at end of file
+        @JvmStatic
+        fun valid(description: String): RuleValidationResult =
+            RuleValidationResult(
+                valid = true,
+                description = description,
+            )
+    }
+}
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleValueType.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleValueType.kt
index 1df5f8b3..bfb00c60 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleValueType.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleValueType.kt
@@ -3,13 +3,14 @@ package org.hisp.dhis.rules.models
 import kotlin.js.JsExport
 
 @JsExport
-enum class RuleValueType(private val defaultValue: Any) {
+enum class RuleValueType(
+    private val defaultValue: Any,
+) {
     TEXT(""),
     NUMERIC(0.0),
     BOOLEAN(false),
-    DATE("2020-01-01");
+    DATE("2020-01-01"),
+    ;
 
-    fun defaultValue(): Any {
-        return defaultValue
-    }
+    fun defaultValue(): Any = defaultValue
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariable.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariable.kt
index f290fc71..651decba 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariable.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariable.kt
@@ -8,17 +8,18 @@ interface RuleVariable {
     val options: List<Option>
     val field: String
     val fieldType: RuleValueType
+
     fun createValues(
         ruleEvent: RuleEvent?,
         allEventValues: Map<String, List<RuleDataValueHistory>>,
-        currentEnrollmentValues: Map<String, RuleAttributeValue>
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
     ): RuleVariableValue
 
     fun getOptionName(value: String): String {
         // if no option found then existing value in the context will be used
         return options
-            .filter{ (_, code): Option -> value == code }
+            .filter { (_, code): Option -> value == code }
             .map(Option::name)
-            .getOrElse(0) {_ -> value}
+            .getOrElse(0) { _ -> value }
     }
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableAttribute.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableAttribute.kt
index b9ec3bb8..0b85cbf8 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableAttribute.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableAttribute.kt
@@ -9,19 +9,21 @@ data class RuleVariableAttribute(
     override val useCodeForOptionSet: Boolean,
     override val options: List<Option>,
     override val field: String,
-    override val fieldType: RuleValueType
+    override val fieldType: RuleValueType,
 ) : RuleVariable {
     override fun createValues(
         ruleEvent: RuleEvent?,
         allEventValues: Map<String, List<RuleDataValueHistory>>,
-        currentEnrollmentValues: Map<String, RuleAttributeValue>
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
     ): RuleVariableValue {
         val currentDate = LocalDate.Companion.currentDate()
         return currentEnrollmentValues[field]?.let {
             val optionValue = if (useCodeForOptionSet) it.value else getOptionName(it.value)
             RuleVariableValue(
-                fieldType, optionValue,
-                listOf(optionValue), currentDate.toString()
+                fieldType,
+                optionValue,
+                listOf(optionValue),
+                currentDate.toString(),
             )
         } ?: RuleVariableValue(fieldType)
     }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.kt
index 614fc45f..111087cd 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableCalculatedValue.kt
@@ -28,7 +28,9 @@ import org.hisp.dhis.rules.engine.RuleVariableValue
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/ /**
+*/
+
+/**
  * @author Zubair Asghar.
  */
 class RuleVariableCalculatedValue(
@@ -36,13 +38,11 @@ class RuleVariableCalculatedValue(
     override val useCodeForOptionSet: Boolean,
     override val options: List<Option>,
     override val field: String,
-    override val fieldType: RuleValueType
+    override val fieldType: RuleValueType,
 ) : RuleVariable {
     override fun createValues(
         ruleEvent: RuleEvent?,
         allEventValues: Map<String, List<RuleDataValueHistory>>,
-        currentEnrollmentValues: Map<String, RuleAttributeValue>
-    ): RuleVariableValue {
-        return RuleVariableValue(fieldType)
-    }
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+    ): RuleVariableValue = RuleVariableValue(fieldType)
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.kt
index b5746d2b..80ceb4b9 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableCurrentEvent.kt
@@ -9,24 +9,26 @@ class RuleVariableCurrentEvent(
     override val useCodeForOptionSet: Boolean,
     override val options: List<Option>,
     override val field: String,
-    override val fieldType: RuleValueType
+    override val fieldType: RuleValueType,
 ) : RuleVariable {
     override fun createValues(
         ruleEvent: RuleEvent?,
         allEventValues: Map<String, List<RuleDataValueHistory>>,
-        currentEnrollmentValues: Map<String, RuleAttributeValue>
-    ): RuleVariableValue {
-        return ruleEvent?.let {
-            it.dataValues.filter { d -> d.dataElement == field }
-                .map {
-                    val optionValue = if (useCodeForOptionSet) it.value else getOptionName(it.value)
-                    RuleVariableValue(
-                        fieldType,
-                        optionValue,
-                        listOf(optionValue),
-                        ruleEvent.eventDate.toLocalDateTime(TimeZone.currentSystemDefault()).date.toString()
-                    )
-                }.firstOrNull()
-        } ?:RuleVariableValue(fieldType)
-    }
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
+    ): RuleVariableValue =
+        ruleEvent
+            ?.dataValues
+            ?.filter { d -> d.dataElement == field }
+            ?.map {
+                val optionValue = if (useCodeForOptionSet) it.value else getOptionName(it.value)
+                RuleVariableValue(
+                    fieldType,
+                    optionValue,
+                    listOf(optionValue),
+                    ruleEvent.eventDate
+                        .toLocalDateTime(TimeZone.currentSystemDefault())
+                        .date
+                        .toString(),
+                )
+            }?.firstOrNull() ?: RuleVariableValue(fieldType)
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableNewestEvent.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableNewestEvent.kt
index fcd88d16..09a41b6e 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableNewestEvent.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableNewestEvent.kt
@@ -8,22 +8,24 @@ class RuleVariableNewestEvent(
     override val useCodeForOptionSet: Boolean,
     override val options: List<Option>,
     override val field: String,
-    override val fieldType: RuleValueType
+    override val fieldType: RuleValueType,
 ) : RuleVariable {
     override fun createValues(
         ruleEvent: RuleEvent?,
         allEventValues: Map<String, List<RuleDataValueHistory>>,
-        currentEnrollmentValues: Map<String, RuleAttributeValue>
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
     ): RuleVariableValue {
         val ruleDataValues = allEventValues[field]
         return if (ruleDataValues.isNullOrEmpty()) {
-             RuleVariableValue(fieldType)
+            RuleVariableValue(fieldType)
         } else {
             val value = ruleDataValues[0]
             val optionValue = if (useCodeForOptionSet) value.value else getOptionName(value.value)
             RuleVariableValue(
-                fieldType, optionValue,
-                ruleDataValues.map { it.value }, getLastUpdateDate(ruleDataValues)
+                fieldType,
+                optionValue,
+                ruleDataValues.map { it.value },
+                getLastUpdateDate(ruleDataValues),
             )
         }
     }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.kt
index 365dede8..221dfa74 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariableNewestStageEvent.kt
@@ -9,12 +9,12 @@ class RuleVariableNewestStageEvent(
     override val options: List<Option>,
     override val field: String,
     override val fieldType: RuleValueType,
-    val programStage: String
+    val programStage: String,
 ) : RuleVariable {
     override fun createValues(
         ruleEvent: RuleEvent?,
         allEventValues: Map<String, List<RuleDataValueHistory>>,
-        currentEnrollmentValues: Map<String, RuleAttributeValue>
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
     ): RuleVariableValue {
         val stageRuleDataValues = allEventValues[field]?.filter { it.programStage == programStage }.orEmpty()
 
@@ -24,9 +24,10 @@ class RuleVariableNewestStageEvent(
             val value = stageRuleDataValues[0]
             val optionValue = if (useCodeForOptionSet) value.value else getOptionName(value.value)
             RuleVariableValue(
-                fieldType, optionValue,
+                fieldType,
+                optionValue,
                 stageRuleDataValues.map { it.value },
-                getLastUpdateDate(stageRuleDataValues)
+                getLastUpdateDate(stageRuleDataValues),
             )
         }
     }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.kt
index 5bf356ff..a80d0daa 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/RuleVariablePreviousEvent.kt
@@ -9,24 +9,29 @@ class RuleVariablePreviousEvent(
     override val useCodeForOptionSet: Boolean,
     override val options: List<Option>,
     override val field: String,
-    override val fieldType: RuleValueType
+    override val fieldType: RuleValueType,
 ) : RuleVariable {
     override fun createValues(
         ruleEvent: RuleEvent?,
         allEventValues: Map<String, List<RuleDataValueHistory>>,
-        currentEnrollmentValues: Map<String, RuleAttributeValue>
+        currentEnrollmentValues: Map<String, RuleAttributeValue>,
     ): RuleVariableValue {
         val dataValues = allEventValues[field]
         if (ruleEvent != null && !dataValues.isNullOrEmpty()) {
             for (ruleDataValue in dataValues) {
                 if (ruleEvent.eventDate > ruleDataValue.eventDate ||
-                    (ruleEvent.eventDate == ruleDataValue.eventDate && ruleEvent.createdDate > ruleDataValue.createdDate)) {
+                    (ruleEvent.eventDate == ruleDataValue.eventDate && ruleEvent.createdDate > ruleDataValue.createdDate)
+                ) {
                     val optionValue =
                         if (useCodeForOptionSet) ruleDataValue.value else getOptionName(ruleDataValue.value)
                     return RuleVariableValue(
-                        fieldType, optionValue,
+                        fieldType,
+                        optionValue,
                         dataValues.map { it.value },
-                        ruleDataValue.eventDate.toLocalDateTime(TimeZone.currentSystemDefault()).date.toString()
+                        ruleDataValue.eventDate
+                            .toLocalDateTime(TimeZone.currentSystemDefault())
+                            .date
+                            .toString(),
                     )
                 }
             }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/TrackerObjectType.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/TrackerObjectType.kt
index dae11115..56cdc570 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/TrackerObjectType.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/TrackerObjectType.kt
@@ -6,8 +6,9 @@ import kotlin.js.JsExport
  * This Enum specify the type of tracker object.
  */
 @JsExport
-enum class TrackerObjectType(private val type: String) {
+enum class TrackerObjectType(
+    private val type: String,
+) {
     EVENT("event"),
-    ENROLLMENT("enrollment")
-
+    ENROLLMENT("enrollment"),
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/models/TriggerEnvironment.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/models/TriggerEnvironment.kt
index 0ef00de1..f2018724 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/models/TriggerEnvironment.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/models/TriggerEnvironment.kt
@@ -30,8 +30,9 @@ package org.hisp.dhis.rules.models
 /**
  * @author Zubair Asghar.
  */
-enum class TriggerEnvironment(val clientName: String) {
+enum class TriggerEnvironment(
+    val clientName: String,
+) {
     ANDROIDCLIENT("AndroidClient"),
-    SERVER("Server")
-
+    SERVER("Server"),
 }
diff --git a/src/commonMain/kotlin/org/hisp/dhis/rules/utils/Utils.kt b/src/commonMain/kotlin/org/hisp/dhis/rules/utils/Utils.kt
index fe68f79e..ca7df17e 100644
--- a/src/commonMain/kotlin/org/hisp/dhis/rules/utils/Utils.kt
+++ b/src/commonMain/kotlin/org/hisp/dhis/rules/utils/Utils.kt
@@ -5,36 +5,47 @@ import org.hisp.dhis.rules.models.RuleDataValueHistory
 import org.hisp.dhis.rules.models.RuleEvent
 
 fun getLastUpdateDateForPrevious(
-        ruleDataValues: List<RuleDataValueHistory>,
-        ruleEvent: RuleEvent
-    ): String {
-        val dates: MutableList<Instant> = ArrayList()
-        for (date in ruleDataValues) {
-            val d = date.eventDate
-            if (d < ruleEvent.eventDate ||
-                (ruleEvent.eventDate == d && ruleEvent.createdDate > date.createdDate)) {
-                dates.add(d)
-            }
-        }
-        return dates.max().toLocalDateTime(TimeZone.currentSystemDefault()).date.toString()
-    }
-
-    fun getLastUpdateDate(ruleDataValues: List<RuleDataValueHistory>): String {
-        val dates: MutableList<Instant> = ArrayList()
-        for (date in ruleDataValues) {
-            val d = date.eventDate
+    ruleDataValues: List<RuleDataValueHistory>,
+    ruleEvent: RuleEvent,
+): String {
+    val dates: MutableList<Instant> = ArrayList()
+    for (date in ruleDataValues) {
+        val d = date.eventDate
+        if (d < ruleEvent.eventDate ||
+            (ruleEvent.eventDate == d && ruleEvent.createdDate > date.createdDate)
+        ) {
             dates.add(d)
         }
-        return dates.max().toLocalDateTime(TimeZone.currentSystemDefault()).date.toString()
     }
+    return dates
+        .max()
+        .toLocalDateTime(TimeZone.currentSystemDefault())
+        .date
+        .toString()
+}
 
-    fun unwrapVariableName(variable: String): String {
-        if (variable.startsWith("#{") && variable.endsWith("}")) {
-            return variable.substring(2,variable.length-1)
-        }
-        throw IllegalArgumentException("Malformed variable: $variable")
+fun getLastUpdateDate(ruleDataValues: List<RuleDataValueHistory>): String {
+    val dates: MutableList<Instant> = ArrayList()
+    for (date in ruleDataValues) {
+        val d = date.eventDate
+        dates.add(d)
     }
+    return dates
+        .max()
+        .toLocalDateTime(TimeZone.currentSystemDefault())
+        .date
+        .toString()
+}
 
-    fun LocalDate.Companion.currentDate(): LocalDate {
-        return Clock.System.now().toLocalDateTime(TimeZone.currentSystemDefault()).date
+fun unwrapVariableName(variable: String): String {
+    if (variable.startsWith("#{") && variable.endsWith("}")) {
+        return variable.substring(2, variable.length - 1)
     }
+    throw IllegalArgumentException("Malformed variable: $variable")
+}
+
+fun LocalDate.Companion.currentDate(): LocalDate =
+    Clock.System
+        .now()
+        .toLocalDateTime(TimeZone.currentSystemDefault())
+        .date
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/ConstantsValueTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/ConstantsValueTest.kt
index 79522b24..a0ef8ffc 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/ConstantsValueTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/ConstantsValueTest.kt
@@ -37,7 +37,6 @@ import kotlin.test.assertEquals
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 class ConstantsValueTest {
-
     @Test
     fun assignConstantValueFromAssignActionInEnrollment() {
         val assignAction = RuleAction("C{A1234567890}", "ASSIGN", mapOf(Pair("field", "#{test_attribute}")))
@@ -45,16 +44,17 @@ class ConstantsValueTest {
         val constantsValueMap: MutableMap<String, String> = HashMap()
         constantsValueMap["A1234567890"] = "3.14"
         val ruleEngineContext = getRuleEngineContext(listOf(rule), constantsValueMap)
-        val enrollment = RuleEnrollment(
-            enrollment = "test_enrollment",
-            programName = "test_program",
-            incidentDate = LocalDate.Companion.currentDate(),
-            enrollmentDate = LocalDate.Companion.currentDate(),
-            status = RuleEnrollmentStatus.ACTIVE,
-            organisationUnit = "test_ou",
-            organisationUnitCode = "test_ou_code",
-            attributeValues = listOf(RuleAttributeValue("test_attribute", "test_value"))
-        )
+        val enrollment =
+            RuleEnrollment(
+                enrollment = "test_enrollment",
+                programName = "test_program",
+                incidentDate = LocalDate.Companion.currentDate(),
+                enrollmentDate = LocalDate.Companion.currentDate(),
+                status = RuleEnrollmentStatus.ACTIVE,
+                organisationUnit = "test_ou",
+                organisationUnitCode = "test_ou_code",
+                attributeValues = listOf(RuleAttributeValue("test_attribute", "test_value")),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(enrollment, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("3.14", ruleEffects[0].data)
@@ -67,20 +67,22 @@ class ConstantsValueTest {
         val action = RuleAction("#{test_attribute}", "SHOWERROR")
         val rule = Rule("true", listOf(assignAction), "test_program_rule1", "")
         val rule2 = Rule("#{test_attribute} > 3", listOf(action), "test_program_rule2", "")
-        val ruleEngineContext = getRuleEngineContext(
-            listOf(rule, rule2),
-            HashMap()
-        )
-        val enrollment = RuleEnrollment(
-            enrollment = "test_enrollment",
-            programName = "test_program",
-            incidentDate = LocalDate.Companion.currentDate(),
-            enrollmentDate = LocalDate.Companion.currentDate(),
-            status = RuleEnrollmentStatus.ACTIVE,
-            organisationUnit = "test_ou",
-            organisationUnitCode = "test_ou_code",
-            attributeValues = listOf(RuleAttributeValue("test_attribute", "test_value"))
-        )
+        val ruleEngineContext =
+            getRuleEngineContext(
+                listOf(rule, rule2),
+                HashMap(),
+            )
+        val enrollment =
+            RuleEnrollment(
+                enrollment = "test_enrollment",
+                programName = "test_program",
+                incidentDate = LocalDate.Companion.currentDate(),
+                enrollmentDate = LocalDate.Companion.currentDate(),
+                status = RuleEnrollmentStatus.ACTIVE,
+                organisationUnit = "test_ou",
+                organisationUnitCode = "test_ou_code",
+                attributeValues = listOf(RuleAttributeValue("test_attribute", "test_value")),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(enrollment, emptyList(), ruleEngineContext)
         assertEquals(2, ruleEffects.size)
         assertEquals("4", ruleEffects[0].data)
@@ -95,20 +97,22 @@ class ConstantsValueTest {
         val action = RuleAction("#{test_attribute}", "SHOWERROR")
         val rule = Rule("true", listOf(assignAction), "test_program_rule1", "")
         val rule2 = Rule("#{test_attribute} > 3", listOf(action), "test_program_rule2", "")
-        val ruleEngineContext = getRuleEngineContext(
-            listOf(rule, rule2),
-            HashMap()
-        )
-        val enrollment = RuleEnrollment(
-            enrollment = "test_enrollment",
-            programName = "test_program",
-            incidentDate = LocalDate.Companion.currentDate(),
-            enrollmentDate = LocalDate.Companion.currentDate(),
-            status = RuleEnrollmentStatus.ACTIVE,
-            organisationUnit = "test_ou",
-            organisationUnitCode = "test_ou_code",
-            attributeValues = listOf(RuleAttributeValue("test_attribute", "test_value"))
-        )
+        val ruleEngineContext =
+            getRuleEngineContext(
+                listOf(rule, rule2),
+                HashMap(),
+            )
+        val enrollment =
+            RuleEnrollment(
+                enrollment = "test_enrollment",
+                programName = "test_program",
+                incidentDate = LocalDate.Companion.currentDate(),
+                enrollmentDate = LocalDate.Companion.currentDate(),
+                status = RuleEnrollmentStatus.ACTIVE,
+                organisationUnit = "test_ou",
+                organisationUnitCode = "test_ou_code",
+                attributeValues = listOf(RuleAttributeValue("test_attribute", "test_value")),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(enrollment, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("4", ruleEffects[0].data)
@@ -122,25 +126,27 @@ class ConstantsValueTest {
         val constantsValueMap: MutableMap<String, String> = HashMap()
         constantsValueMap["A1234567890"] = "3.14"
         val ruleEngineContext = getRuleEngineContext(listOf(rule), constantsValueMap)
-        val ruleEvent = RuleEvent(
-            event = "test_event",
-            programStage = "test_program_stage",
-            programStageName = "",
-            status = RuleEventStatus.ACTIVE,
-            eventDate = Clock.System.now(),
-            createdDate = Clock.System.now(),
-            dueDate = LocalDate.currentDate(),
-            organisationUnit = "",
-            organisationUnitCode = "",
-            completedDate = LocalDate.currentDate(),
-            dataValues =
-            listOf(
-                RuleDataValue(
-                    "test_data_element", "test_value"
-                )
+        val ruleEvent =
+            RuleEvent(
+                event = "test_event",
+                programStage = "test_program_stage",
+                programStageName = "",
+                status = RuleEventStatus.ACTIVE,
+                eventDate = Clock.System.now(),
+                createdDate = Clock.System.now(),
+                dueDate = LocalDate.currentDate(),
+                organisationUnit = "",
+                organisationUnitCode = "",
+                completedDate = LocalDate.currentDate(),
+                dataValues =
+                    listOf(
+                        RuleDataValue(
+                            "test_data_element",
+                            "test_value",
+                        ),
+                    ),
             )
-        )
-        val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(),  ruleEngineContext)
+        val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("3.14", ruleEffects[0].data)
         assertEquals(assignAction, ruleEffects[0].ruleAction)
@@ -148,8 +154,6 @@ class ConstantsValueTest {
 
     private fun getRuleEngineContext(
         rules: List<Rule>,
-        constantsValueMap: Map<String, String>
-    ): RuleEngineContext {
-        return RuleEngineContext(rules = rules, constantsValues = constantsValueMap)
-    }
+        constantsValueMap: Map<String, String>,
+    ): RuleEngineContext = RuleEngineContext(rules = rules, constantsValues = constantsValueMap)
 }
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/ProgramRuleVariableTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/ProgramRuleVariableTest.kt
index 1c7abf58..9a111203 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/ProgramRuleVariableTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/ProgramRuleVariableTest.kt
@@ -49,8 +49,10 @@ class ProgramRuleVariableTest {
     fun testDueDateProgramVariableIsAssigned() {
         val rule = getRule("V{due_date}")
         val ruleEffects = callEventRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            DUE_DATE_STRING
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            DUE_DATE_STRING,
         )
     }
 
@@ -65,8 +67,10 @@ class ProgramRuleVariableTest {
     fun testEnrollmentDateProgramVariableIsAssigned() {
         val rule = getRule("V{enrollment_date}")
         val ruleEffects = callEnrollmentRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            ENROLLMENT_DATE_STRING
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            ENROLLMENT_DATE_STRING,
         )
     }
 
@@ -74,8 +78,10 @@ class ProgramRuleVariableTest {
     fun testEnrollmentIdProgramVariableIsAssigned() {
         val rule = getRule("V{enrollment_id}")
         val ruleEffects = callEnrollmentRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            ENROLLMENT_ID
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            ENROLLMENT_ID,
         )
     }
 
@@ -104,8 +110,10 @@ class ProgramRuleVariableTest {
     fun testEventDateProgramVariableIsAssigned() {
         val rule = getRule("V{event_date}")
         val ruleEffects = callEventRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            EVENT_DATE_STRING
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            EVENT_DATE_STRING,
         )
     }
 
@@ -113,8 +121,10 @@ class ProgramRuleVariableTest {
     fun testEventIdProgramVariableIsAssigned() {
         val rule = getRule("V{event_id}")
         val ruleEffects = callEventRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            EVENT_ID
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            EVENT_ID,
         )
     }
 
@@ -129,8 +139,10 @@ class ProgramRuleVariableTest {
     fun testIncidentDateProgramVariableIsAssigned() {
         val rule = getRule("V{incident_date}")
         val ruleEffects = callEventRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            INCIDENT_DATE_STRING
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            INCIDENT_DATE_STRING,
         )
     }
 
@@ -138,8 +150,10 @@ class ProgramRuleVariableTest {
     fun testOrganisationUnitProgramVariableIsAssigned() {
         val rule = getRule("V{org_unit}")
         val ruleEffects = callEnrollmentRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            ORGANISATION_UNIT
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            ORGANISATION_UNIT,
         )
     }
 
@@ -147,8 +161,10 @@ class ProgramRuleVariableTest {
     fun testOrganisationUnitCodeProgramVariableIsAssigned() {
         val rule = getRule("V{orgunit_code}")
         val ruleEffects = callEventRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            ORGANISATION_UNIT_CODE
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            ORGANISATION_UNIT_CODE,
         )
     }
 
@@ -156,8 +172,10 @@ class ProgramRuleVariableTest {
     fun testProgramNameProgramVariableIsAssigned() {
         val rule = getRule("V{program_name}")
         val ruleEffects = callEnrollmentRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            PROGRAM_NAME
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            PROGRAM_NAME,
         )
     }
 
@@ -165,8 +183,10 @@ class ProgramRuleVariableTest {
     fun testProgramStageIdProgramVariableIsAssigned() {
         val rule = getRule("V{program_stage_id}")
         val ruleEffects = callEventRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            PROGRAM_STAGE
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            PROGRAM_STAGE,
         )
     }
 
@@ -174,8 +194,10 @@ class ProgramRuleVariableTest {
     fun testProgramStageNameProgramVariableIsAssigned() {
         val rule = getRule("V{program_stage_name}")
         val ruleEffects = callEventRuleEngine(rule)
-        assertProgramRuleVariableAssignment(ruleEffects, rule,
-            PROGRAM_STAGE_NAME
+        assertProgramRuleVariableAssignment(
+            ruleEffects,
+            rule,
+            PROGRAM_STAGE_NAME,
         )
     }
 
@@ -187,54 +209,58 @@ class ProgramRuleVariableTest {
     }
 
     private fun getRule(variable: String): Rule {
-        val assignAction = RuleAction(variable, "ASSIGN", mapOf(Pair("field","#{test_data_element}")))
+        val assignAction = RuleAction(variable, "ASSIGN", mapOf(Pair("field", "#{test_data_element}")))
         return Rule("true", listOf(assignAction), "test_program_rule1")
     }
 
-    private fun assertProgramRuleVariableAssignment(ruleEffects: List<RuleEffect>, rule: Rule, variableValue: String) {
+    private fun assertProgramRuleVariableAssignment(
+        ruleEffects: List<RuleEffect>,
+        rule: Rule,
+        variableValue: String,
+    ) {
         assertEquals(1, ruleEffects.size)
         assertEquals(variableValue, ruleEffects[0].data)
         assertEquals(rule.actions[0], ruleEffects[0].ruleAction)
     }
-    
+
     private fun callEnrollmentRuleEngine(rule: Rule): List<RuleEffect> {
         val ruleEngineContext = getRuleEngineContext(listOf(rule))
         return RuleEngine.getInstance().evaluate(enrollment, emptyList(), ruleEngineContext)
     }
-    
+
     private fun callEventRuleEngine(rule: Rule): List<RuleEffect> {
         val ruleEngineContext = getRuleEngineContext(listOf(rule))
-        val event = RuleEvent(
-            event = EVENT_ID,
-            programStage = PROGRAM_STAGE,
-            programStageName = PROGRAM_STAGE_NAME,
-            status = RULE_EVENT_STATUS,
-            eventDate = EVENT_DATE,
-            createdDate = Clock.System.now(),
-            dueDate = DUE_DATE,
-            organisationUnit = ORGANISATION_UNIT,
-            organisationUnitCode = ORGANISATION_UNIT_CODE,
-            completedDate = null,
-            dataValues = emptyList()
-        )
+        val event =
+            RuleEvent(
+                event = EVENT_ID,
+                programStage = PROGRAM_STAGE,
+                programStageName = PROGRAM_STAGE_NAME,
+                status = RULE_EVENT_STATUS,
+                eventDate = EVENT_DATE,
+                createdDate = Clock.System.now(),
+                dueDate = DUE_DATE,
+                organisationUnit = ORGANISATION_UNIT,
+                organisationUnitCode = ORGANISATION_UNIT_CODE,
+                completedDate = null,
+                dataValues = emptyList(),
+            )
         return RuleEngine.getInstance().evaluate(event, enrollment, emptyList(), ruleEngineContext)
     }
 
     private val enrollment: RuleEnrollment
-        get() = RuleEnrollment(
-            ENROLLMENT_ID,
-            PROGRAM_NAME,
-            INCIDENT_DATE,
-            ENROLLMENT_DATE,
-            RuleEnrollmentStatus.ACTIVE,
-            ORGANISATION_UNIT,
-            ORGANISATION_UNIT_CODE,
-            listOf(RuleAttributeValue("test_attribute", "test_value"))
-        )
+        get() =
+            RuleEnrollment(
+                ENROLLMENT_ID,
+                PROGRAM_NAME,
+                INCIDENT_DATE,
+                ENROLLMENT_DATE,
+                RuleEnrollmentStatus.ACTIVE,
+                ORGANISATION_UNIT,
+                ORGANISATION_UNIT_CODE,
+                listOf(RuleAttributeValue("test_attribute", "test_value")),
+            )
 
-    private fun getRuleEngineContext(rules: List<Rule>): RuleEngineContext {
-        return RuleEngineContext(rules)
-    }
+    private fun getRuleEngineContext(rules: List<Rule>): RuleEngineContext = RuleEngineContext(rules)
 
     companion object {
         private val CURRENT_DATE = LocalDate.Companion.currentDate()
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineEffectTypesTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineEffectTypesTest.kt
index 18491109..716b4ff5 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineEffectTypesTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineEffectTypesTest.kt
@@ -13,8 +13,8 @@ import kotlin.test.assertEquals
 // ToDo: function tests (check that function invocations are producing expected values; check nested function invocation)
 // ToDo: various source type tests (referencing variables from different events)
 class RuleEngineEffectTypesTest {
-    private fun getTestRuleEvent(status: RuleEventStatus): RuleEvent {
-        return RuleEvent(
+    private fun getTestRuleEvent(status: RuleEventStatus): RuleEvent =
+        RuleEvent(
             event = "test_event",
             programStage = "test_program_stage",
             programStageName = "",
@@ -25,19 +25,26 @@ class RuleEngineEffectTypesTest {
             organisationUnit = "",
             organisationUnitCode = "",
             completedDate = null,
-            dataValues = listOf(
-                RuleDataValue(
-                    "test_data_element", "test_value"
-                )
-            )
+            dataValues =
+                listOf(
+                    RuleDataValue(
+                        "test_data_element",
+                        "test_value",
+                    ),
+                ),
         )
-    }
 
     @Test
     fun simpleConditionMustResultInAssignEffect() {
         val ruleAction = RuleAction("'test_string'", "ASSIGN", mapOf(Pair("field", "test_data_element")))
         val rule = Rule("true", listOf(ruleAction))
-        val ruleEffects = RuleEngine.getInstance().evaluate(getTestRuleEvent(RuleEventStatus.ACTIVE), null, emptyList(), RuleEngineContext(listOf(rule)))
+        val ruleEffects =
+            RuleEngine.getInstance().evaluate(
+                getTestRuleEvent(RuleEventStatus.ACTIVE),
+                null,
+                emptyList(),
+                RuleEngineContext(listOf(rule)),
+            )
         assertEquals(1, ruleEffects.size)
         assertEquals("test_string", ruleEffects[0].data)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -47,7 +54,12 @@ class RuleEngineEffectTypesTest {
     fun simpleConditionMustResultInAssignEffectMultipleExecution() {
         val ruleAction = RuleAction("'test_string'", "ASSIGN", mapOf(Pair("field", "test_data_element")))
         val rule = Rule("true", listOf(ruleAction))
-        val ruleEffects = RuleEngine.getInstance().evaluateAll(null, listOf(getTestRuleEvent(RuleEventStatus.ACTIVE)), getRuleEngineContext(listOf(rule)))
+        val ruleEffects =
+            RuleEngine.getInstance().evaluateAll(
+                null,
+                listOf(getTestRuleEvent(RuleEventStatus.ACTIVE)),
+                getRuleEngineContext(listOf(rule)),
+            )
         assertEquals(1, ruleEffects.size)
         assertEquals("test_string", ruleEffects[0].ruleEffects[0].data)
         assertEquals(ruleAction, ruleEffects[0].ruleEffects[0].ruleAction)
@@ -57,7 +69,13 @@ class RuleEngineEffectTypesTest {
     fun testEnvironmentVariableExpression() {
         val ruleAction = RuleAction("", "HIDEFIELD", mapOf(Pair("content", "test_action_content"), Pair("field", "test_data_element")))
         val rule = Rule("V{event_status} =='COMPLETED'", listOf(ruleAction))
-        val ruleEffects = RuleEngine.getInstance().evaluate(getTestRuleEvent(RuleEventStatus.COMPLETED), null, emptyList(), RuleEngineContext(listOf(rule)))
+        val ruleEffects =
+            RuleEngine.getInstance().evaluate(
+                getTestRuleEvent(RuleEventStatus.COMPLETED),
+                null,
+                emptyList(),
+                RuleEngineContext(listOf(rule)),
+            )
         assertEquals(1, ruleEffects.size)
         assertEquals("", ruleEffects[0].data)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineFunctionTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineFunctionTest.kt
index f643af74..bac378f3 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineFunctionTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineFunctionTest.kt
@@ -15,17 +15,26 @@ class RuleEngineFunctionTest {
     fun evaluateFailingRule() {
         val enrollmentDate = LocalDate.Companion.currentDate()
         val ruleAction = RuleAction("2 + 2", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val failingRule = Rule(
-            "d2:daysBetween(V{enrollment_date},V{event_date}) < 0",
-            listOf(ruleAction), "", ""
-        )
+        val failingRule =
+            Rule(
+                "d2:daysBetween(V{enrollment_date},V{event_date}) < 0",
+                listOf(ruleAction),
+                "",
+                "",
+            )
         val validRule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(listOf(failingRule, validRule))
-        val ruleEnrollment = RuleEnrollment(
-            "test_enrollment", "",
-            enrollmentDate, enrollmentDate, RuleEnrollmentStatus.ACTIVE,
-            "", "", listOf(),
-        )
+        val ruleEnrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "",
+                enrollmentDate,
+                enrollmentDate,
+                RuleEnrollmentStatus.ACTIVE,
+                "",
+                "",
+                listOf(),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEnrollment, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("4", ruleEffects[0].data)
@@ -37,42 +46,62 @@ class RuleEngineFunctionTest {
         val today = LocalDate.Companion.currentDate()
         val yesterday = today.minus(1, DateTimeUnit.DAY).atStartOfDayIn(TimeZone.currentSystemDefault())
         val ruleAction = RuleAction("2 + 2", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val failingRule = Rule(
-            "d2:daysBetween(V{enrollment_date},V{event_date}) < 0",
-            listOf(ruleAction), "", ""
-        )
-        val ruleEnrollment = RuleEnrollment(
-            "test_enrollment", "",
-            today, today, RuleEnrollmentStatus.ACTIVE, "", "", listOf()
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleNotFailingEvent = RuleEvent(
-            "test_not_failing_event", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, yesterday,yesterday, today, null, "",
-            null, listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
+        val failingRule =
+            Rule(
+                "d2:daysBetween(V{enrollment_date},V{event_date}) < 0",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEnrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "",
+                today,
+                today,
+                RuleEnrollmentStatus.ACTIVE,
+                "",
+                "",
+                listOf(),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleNotFailingEvent =
+            RuleEvent(
+                "test_not_failing_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                yesterday,
+                yesterday,
+                today,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(listOf(failingRule))
         val ruleEffects = RuleEngine.getInstance().evaluateAll(ruleEnrollment, listOf(ruleEvent, ruleNotFailingEvent), ruleEngineContext)
         assertEquals(3, ruleEffects.size)
@@ -82,7 +111,10 @@ class RuleEngineFunctionTest {
         assertFalse(getRuleEffectsByUid(ruleEffects, "test_enrollment")!!.ruleEffects.isEmpty())
     }
 
-    private fun getRuleEffectsByUid(ruleEffects: List<RuleEffects>, uid: String): RuleEffects? {
+    private fun getRuleEffectsByUid(
+        ruleEffects: List<RuleEffects>,
+        uid: String,
+    ): RuleEffects? {
         for (ruleEffect in ruleEffects) {
             if (ruleEffect.trackerObjectUid == uid) {
                 return ruleEffect
@@ -93,30 +125,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateHasValueFunctionMustReturnTrueIfValueSpecified() {
-        val ruleAction = RuleAction("d2:hasValue(#{test_variable})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable", true, emptyList(),"test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:hasValue(#{test_variable})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable",
+                true,
+                emptyList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext =RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "test_value"
-                )
-            )
-        )
+        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "test_value",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("true", ruleEffects[0].data)
@@ -128,29 +171,37 @@ class RuleEngineFunctionTest {
         val option1 = Option("name1", "code1")
         val option2 = Option("name2", "code2")
         val options = listOf(option1, option2)
-        val ruleAction = RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariable: RuleVariable = RuleVariableNewestEvent("test_variable",
-            USE_NAME_FOR_OPTION_SET, options, "test_data_element", RuleValueType.TEXT)
+        val ruleAction =
+            RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleVariable: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_variable",
+                USE_NAME_FOR_OPTION_SET,
+                options,
+                "test_data_element",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext =RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element",
-                    option1.code
-                )
-            )
-        )
+        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element",
+                        option1.code,
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(option1.name, ruleEffects[0].data)
@@ -162,31 +213,37 @@ class RuleEngineFunctionTest {
         val option1 = Option("name1", "code1")
         val option2 = Option("name2", "code2")
         val options = listOf(option1, option2)
-        val ruleAction = RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable",
-            USE_CODE_FOR_OPTION_SET, options, "test_data_element", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable",
+                USE_CODE_FOR_OPTION_SET,
+                options,
+                "test_data_element",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext =RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element",
-                    option2.code
-                )
-            )
-        )
+        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element",
+                        option2.code,
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(option2.code, ruleEffects[0].data)
@@ -196,30 +253,41 @@ class RuleEngineFunctionTest {
     @Test
     @Deprecated("")
     fun evaluateHasValueFunctionWithStringValue() {
-        val ruleAction = RuleAction("d2:hasValue('test_variable')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable", true, ArrayList(),"test_data_element", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:hasValue('test_variable')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable",
+                true,
+                ArrayList(),
+                "test_data_element",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext =RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element",
-                    "test_value"
-                )
-            )
-        )
+        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element",
+                        "test_value",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("true", ruleEffects[0].data)
@@ -228,30 +296,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateHasValueFunctionMustReturnTrueIfNoValueSpecified() {
-        val ruleAction = RuleAction("d2:hasValue(#{test_variable})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:hasValue(#{test_variable})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable",
+                true,
+                ArrayList(),
+                "test_data_element",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext =RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
+        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("false", ruleEffects[0].data)
@@ -260,28 +339,30 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateEnvironmentVariableProgramStageName() {
-        val ruleAction = RuleAction("V{program_stage_name}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleAction =
+            RuleAction("V{program_stage_name}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
         val ruleVariable: RuleVariable = RuleVariableCurrentEvent("variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT)
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext =RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage_id",
-            "test_program_stage_name",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
+        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariable))
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage_id",
+                "test_program_stage_name",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -290,38 +371,54 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateDaysBetweenMustReturnCorrectDiff() {
-        val ruleAction = RuleAction("d2:daysBetween(#{test_var_one}, #{test_var_two})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:daysBetween(#{test_var_one}, #{test_var_two})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext =
             RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne, ruleVariableTwo))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2017-01-01"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "2017-02-01"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2017-01-01",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "2017-02-01",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("31", ruleEffects[0].data)
@@ -330,38 +427,54 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateDaysBetweenWithSingleQuotedDateMustReturnCorrectDiff() {
-        val ruleAction = RuleAction("d2:daysBetween(#{test_var_one}, '2018-01-01')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:daysBetween(#{test_var_one}, '2018-01-01')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext =
             RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne, ruleVariableTwo))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2017-01-01"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "2017-02-01"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2017-01-01",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "2017-02-01",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("365", ruleEffects[0].data)
@@ -373,31 +486,42 @@ class RuleEngineFunctionTest {
         val members = listOf("location1", "location2")
         val supplementaryData: MutableMap<String, List<String>> = HashMap()
         supplementaryData["OU_GROUP_ID"] = members
-        val ruleAction = RuleAction("d2:inOrgUnitGroup(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:inOrgUnitGroup(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext =
-            RuleEngineContext(rules = listOf(rule), ruleVariables = listOf(ruleVariableOne),supplementaryData = supplementaryData)
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "location1",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "OU_GROUP_ID"
-                )
-            )
-        )
+            RuleEngineContext(rules = listOf(rule), ruleVariables = listOf(ruleVariableOne), supplementaryData = supplementaryData)
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "location1",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "OU_GROUP_ID",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -410,31 +534,42 @@ class RuleEngineFunctionTest {
         val members = listOf("location1", "location2")
         val supplementaryData: MutableMap<String, List<String>> = HashMap()
         supplementaryData["OU_GROUP_ID"] = members
-        val ruleAction = RuleAction("d2:inOrgUnitGroup('OU_GROUP_ID')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:inOrgUnitGroup('OU_GROUP_ID')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext =
             RuleEngineContext(rules = listOf(rule), ruleVariables = listOf(ruleVariableOne), supplementaryData = supplementaryData)
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "location1",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "OU_GROUP_ID"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "location1",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "OU_GROUP_ID",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -446,31 +581,42 @@ class RuleEngineFunctionTest {
         val roles = listOf("role1", "role2")
         val supplementaryData: MutableMap<String, List<String>> = HashMap()
         supplementaryData["USER"] = roles
-        val ruleAction = RuleAction("d2:hasUserRole(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:hasUserRole(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext =
             RuleEngineContext(rules = listOf(rule), ruleVariables = listOf(ruleVariableOne), supplementaryData = supplementaryData)
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "location1",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "role1"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "location1",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "role1",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -483,31 +629,42 @@ class RuleEngineFunctionTest {
         val roles = listOf("role1", "role2")
         val supplementaryData: MutableMap<String, List<String>> = HashMap()
         supplementaryData["USER"] = roles
-        val ruleAction = RuleAction("d2:hasUserRole('role1')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:hasUserRole('role1')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext =
             RuleEngineContext(rules = listOf(rule), ruleVariables = listOf(ruleVariableOne), supplementaryData = supplementaryData)
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "location1",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "role1"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "location1",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "role1",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -516,64 +673,81 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2AddDays() {
-        val ruleAction = RuleAction("d2:addDays(#{test_var_one}, #{test_var_two})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:addDays(#{test_var_one}, #{test_var_two})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext =
             RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne, ruleVariableTwo))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2017-01-01"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "2"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2017-01-01",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "2",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(ruleEffects.size, 1)
         assertEquals(ruleEffects[0].ruleAction, ruleAction)
         assertEquals(ruleEffects[0].data, "2017-01-03")
-        val ruleEvent2 = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2017-01-03"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "-2"
-                )
-            )
-        )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2017-01-03",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "-2",
+                    ),
+                ),
+            )
         val ruleEffects2 = RuleEngine.getInstance().evaluate(ruleEvent2, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects2.size)
         assertEquals(ruleAction, ruleEffects2[0].ruleAction)
@@ -582,66 +756,79 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2CountIfValue() {
-        val ruleAction = RuleAction("d2:countIfValue(#{test_var_one}, 'condition')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:countIfValue(#{test_var_one}, 'condition')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2, ruleEvent3), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -651,66 +838,79 @@ class RuleEngineFunctionTest {
     @Test
     @Deprecated("")
     fun evaluateD2CountIfValueWithStringValue() {
-        val ruleAction = RuleAction("d2:countIfValue('test_var_one', 'condition')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:countIfValue('test_var_one', 'condition')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2, ruleEvent3), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -719,87 +919,106 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Count() {
-        val ruleAction = RuleAction("d2:count(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:count(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent4 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_two",
-                    "condition"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent4 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "condition",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2, ruleEvent3, ruleEvent4), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -808,51 +1027,66 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateLogicalAnd() {
-        val ruleAction = RuleAction("d2:count(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:hasValue(V{current_date}) && d2:count(#{test_var_one}) > 0",
-            listOf(ruleAction), "", ""
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:count(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:hasValue(V{current_date}) && d2:count(#{test_var_one}) > 0",
+                listOf(ruleAction),
+                "",
+                "",
+            )
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -861,51 +1095,66 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateLogicalOr() {
-        val ruleAction = RuleAction("d2:count(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:hasValue(V{current_date}) || d2:count(#{test_var_one}) > 0",
-            listOf(ruleAction), "", ""
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:count(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:hasValue(V{current_date}) || d2:count(#{test_var_one}) > 0",
+                listOf(ruleAction),
+                "",
+                "",
+            )
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -915,87 +1164,106 @@ class RuleEngineFunctionTest {
     @Test
     @Deprecated("")
     fun evaluateD2CountWithStringValue() {
-        val ruleAction = RuleAction("d2:count('test_var_one')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:count('test_var_one')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent4 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_two",
-                    "condition"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent4 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "condition",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2, ruleEvent3, ruleEvent4), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1004,31 +1272,42 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Round() {
-        val ruleAction1 = RuleAction("d2:round(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
+        val ruleAction1 =
+            RuleAction(
+                "d2:round(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
         val rule = Rule("true", listOf(ruleAction1), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2.6"
-                )
-            )
-        )
-        val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent,null, emptyList(), ruleEngineContext)
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2.6",
+                    ),
+                ),
+            )
+        val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction1, ruleEffects[0].ruleAction)
         assertEquals("3", ruleEffects[0].data)
@@ -1036,30 +1315,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Modulus() {
-        val ruleAction = RuleAction("d2:modulus(#{test_var_one}, 2)", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:modulus(#{test_var_one}, 2)",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2.6"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2.6",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1068,30 +1358,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2SubString() {
-        val ruleAction = RuleAction("d2:substring(#{test_var_one}, 1, 3)", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:substring(#{test_var_one}, 1, 3)",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "ABCD"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "ABCD",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1100,40 +1401,57 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2WeeksBetween() {
-        val ruleAction = RuleAction("d2:weeksBetween(#{test_var_one}, #{test_var_two})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:weeksBetween(#{test_var_one}, #{test_var_two})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2018-01-01"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "2018-02-01"
-                )
-            )
-        )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2018-01-01",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "2018-02-01",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1142,40 +1460,57 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2MonthsBetween() {
-        val ruleAction = RuleAction("d2:monthsBetween(#{test_var_one}, #{test_var_two})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:monthsBetween(#{test_var_one}, #{test_var_two})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2018-01-01"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "2018-09-01"
-                )
-            )
-        )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2018-01-01",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "2018-09-01",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1184,43 +1519,63 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2YearsBetween() {
-        val ruleAction = RuleAction("d2:yearsBetween(#{test_var_one}, #{test_var_two})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:yearsBetween('2016-01-01', '2018-09-01') == 2", listOf(ruleAction), "",
-            ""
-        )
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "2016-01-01"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "2018-09-01"
-                )
-            )
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:yearsBetween(#{test_var_one}, #{test_var_two})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:yearsBetween('2016-01-01', '2018-09-01') == 2",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "2016-01-01",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "2018-09-01",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1229,34 +1584,56 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Zpvc() {
-        val ruleAction = RuleAction("d2:zpvc( '1', '0', '-1' )", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.NUMERIC
-        )
-        val ruleVariableThree: RuleVariable = RuleVariableNewestEvent(
-            "test_var_three", true, ArrayList(), "test_data_element_two", RuleValueType.NUMERIC
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:zpvc( '1', '0', '-1' )",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableThree: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_three",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.NUMERIC,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf()
-        )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1265,22 +1642,24 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Zing() {
-        val ruleAction = RuleAction("d2:zing( '-1' )", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleAction =
+            RuleAction("d2:zing( '-1' )", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf())
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf()
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1289,22 +1668,24 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Oizp() {
-        val ruleAction = RuleAction("d2:oizp( '0' )", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleAction =
+            RuleAction("d2:oizp( '0' )", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf())
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf()
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1313,66 +1694,79 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2CountIfZeroPos() {
-        val ruleAction = RuleAction("d2:countIfZeroPos(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:countIfZeroPos(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "0"
-                )
-            )
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "1"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event1",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "-3"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "0",
+                    ),
+                ),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "1",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "-3",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1382,66 +1776,79 @@ class RuleEngineFunctionTest {
     @Test
     @Deprecated("")
     fun evaluateD2CountIfZeroPosWithStringValue() {
-        val ruleAction = RuleAction("d2:countIfZeroPos('test_var_one')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:countIfZeroPos('test_var_one')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "0"
-                )
-            )
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "1"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event1",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "-3"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "0",
+                    ),
+                ),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "1",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "-3",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1450,30 +1857,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Left() {
-        val ruleAction = RuleAction("d2:left(#{test_var_one}, 4)", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:left(#{test_var_one}, 4)",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "yyyy-mm-dd"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "yyyy-mm-dd",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1482,30 +1900,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Right() {
-        val ruleAction = RuleAction("d2:right(#{test_var_one}, 2)", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:right(#{test_var_one}, 2)",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "yyyy-mm-dd"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "yyyy-mm-dd",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1514,30 +1943,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Concatenate() {
-        val ruleAction = RuleAction("d2:concatenate(#{test_var_one}, '+days')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:concatenate(#{test_var_one}, '+days')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "weeks"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "weeks",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1546,52 +1986,64 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2ValidatePattern() {
-        val ruleAction = RuleAction("d2:validatePattern(#{test_var_one}, '.*555.*')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:validatePattern(#{test_var_one}, '.*555.*')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "44455545454"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "44455545454",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(ruleEffects.size, 1)
         assertEquals(ruleEffects[0].ruleAction, ruleAction)
         assertEquals("true", ruleEffects[0].data)
-        val ruleEvent2 = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "444887777"
-                )
-            )
-        )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "444887777",
+                    ),
+                ),
+            )
         val ruleEffects2 = RuleEngine.getInstance().evaluate(ruleEvent2, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects2.size)
         assertEquals(ruleAction, ruleEffects2[0].ruleAction)
@@ -1600,30 +2052,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Length() {
-        val ruleAction = RuleAction("d2:length(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:length(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "testString"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "testString",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1632,30 +2095,41 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2Split() {
-        val ruleAction = RuleAction("d2:split(#{test_var_one},'-',2)", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:split(#{test_var_one},'-',2)",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "test-String-for-split"
-                )
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "test-String-for-split",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1664,47 +2138,69 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateNestedFunctionCalls() {
-        val ruleAction = RuleAction("d2:floor(#{test_var_one} + d2:ceil(#{test_var_three})) / 5 * d2:ceil(#{test_var_two})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.NUMERIC
-        )
-        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent(
-            "test_var_three", true, ArrayList(), "test_data_element_three", RuleValueType.NUMERIC
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:floor(#{test_var_one} + d2:ceil(#{test_var_three})) / 5 * d2:ceil(#{test_var_two})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableThree: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_var_three",
+                true,
+                ArrayList(),
+                "test_data_element_three",
+                RuleValueType.NUMERIC,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext =RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo, ruleVariableThree)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "19.9"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "0.9"
-                ),
-                RuleDataValue(
-                    "test_data_element_three",
-                    "10.6"
-                )
-            )
-        )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo, ruleVariableThree),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "19.9",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "0.9",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_three",
+                        "10.6",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("6", ruleEffects[0].data)
@@ -1714,42 +2210,57 @@ class RuleEngineFunctionTest {
     @Test
     fun evaluateD2ZScoreWFA() {
         val ruleAction = RuleAction("true", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:zScoreWFA(1,#{test_var_one},#{test_var_two}) == 0", listOf(ruleAction),
-            "", ""
-        )
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "4.5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:zScoreWFA(1,#{test_var_one},#{test_var_two}) == 0",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "4.5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1758,42 +2269,57 @@ class RuleEngineFunctionTest {
     @Test
     fun evaluateD2ZScoreHFAGirl() {
         val ruleAction = RuleAction("true", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:zScoreHFA(12,#{test_var_one},#{test_var_two}) == -3", listOf(ruleAction),
-            "", ""
-        )
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "66.3"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "1"
-                )
-            )
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:zScoreHFA(12,#{test_var_one},#{test_var_two}) == -3",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "66.3",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "1",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1802,42 +2328,57 @@ class RuleEngineFunctionTest {
     @Test
     fun evaluateD2ZScoreHFABoy() {
         val ruleAction = RuleAction("true", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:zScoreHFA(10,#{test_var_one},#{test_var_two}) == -2", listOf(ruleAction),
-            "", ""
-        )
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "68.7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:zScoreHFA(10,#{test_var_one},#{test_var_two}) == -2",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "68.7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1846,42 +2387,57 @@ class RuleEngineFunctionTest {
     @Test
     fun evaluateD2ZScoreWFHBoy() {
         val ruleAction = RuleAction("true", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:zScoreWFH(52,#{test_var_one},A{test_var_two}) < 2", listOf(ruleAction),
-            "", ""
-        )
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "3"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:zScoreWFH(52,#{test_var_one},A{test_var_two}) < 2",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "3",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1889,43 +2445,63 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateD2ZScoreWFHGirl() {
-        val ruleAction = RuleAction("d2:zScoreWFH(81.5,9.6,'female') == 2", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:zScoreWFH(81.5,#{test_var_one},#{test_var_two}) == 2", listOf(ruleAction),
-            "", ""
-        )
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "12.5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "1"
-                )
-            )
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:zScoreWFH(81.5,9.6,'female') == 2",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:zScoreWFH(81.5,#{test_var_one},#{test_var_two}) == 2",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "12.5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "1",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -1934,83 +2510,97 @@ class RuleEngineFunctionTest {
     @Test
     fun evaluateD2MaxValue() {
         val ruleAction = RuleAction("true", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("d2:maxValue(#{test_var_one}) == 8.0", listOf(ruleAction), "", "")
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "8"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "8",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -2020,83 +2610,97 @@ class RuleEngineFunctionTest {
     @Deprecated("")
     fun evaluateD2MaxValueWithStringValue() {
         val ruleAction = RuleAction("true", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("d2:maxValue('test_var_one') == 8.0", listOf(ruleAction), "", "")
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "8"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "8",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -2104,84 +2708,103 @@ class RuleEngineFunctionTest {
 
     @Test
     fun testMinValue() {
-        val ruleAction = RuleAction("d2:minValue(#{test_var_one})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:minValue(#{test_var_one})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "8"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "8",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -2190,84 +2813,103 @@ class RuleEngineFunctionTest {
 
     @Test
     fun testMinValueWithStringValue() {
-        val ruleAction = RuleAction("d2:minValue('test_var_one')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:minValue('test_var_one')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "8"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
+        val ruleEngineContext =
+            RuleEngineTestUtils.getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "8",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -2276,70 +2918,99 @@ class RuleEngineFunctionTest {
 
     @Test
     fun evaluateLastEventDate() {
-        val yesterday = LocalDate.Companion.currentDate().minus(1, DateTimeUnit.DAY).atStartOfDayIn(TimeZone.currentSystemDefault())
-        val dayBeforeYesterday = LocalDate.Companion.currentDate().minus(2, DateTimeUnit.DAY).atStartOfDayIn(TimeZone.currentSystemDefault())
-        val dayAfterTomorrowInstant = LocalDate.Companion.currentDate().plus(2, DateTimeUnit.DAY).atStartOfDayIn(TimeZone.currentSystemDefault())
+        val yesterday =
+            LocalDate.Companion
+                .currentDate()
+                .minus(1, DateTimeUnit.DAY)
+                .atStartOfDayIn(TimeZone.currentSystemDefault())
+        val dayBeforeYesterday =
+            LocalDate.Companion
+                .currentDate()
+                .minus(
+                    2,
+                    DateTimeUnit.DAY,
+                ).atStartOfDayIn(TimeZone.currentSystemDefault())
+        val dayAfterTomorrowInstant =
+            LocalDate.Companion
+                .currentDate()
+                .plus(
+                    2,
+                    DateTimeUnit.DAY,
+                ).atStartOfDayIn(TimeZone.currentSystemDefault())
         val dayAfterTomorrow = LocalDate.currentDate().plus(2, DateTimeUnit.DAY)
-        val ruleAction = RuleAction("d2:lastEventDate('test_var_one')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_var_one", true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:lastEventDate('test_var_one')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_one",
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "test_rule", "")
         val ruleEngineContext = RuleEngineTestUtils.getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            dayBeforeYesterday,
-            dayBeforeYesterday,
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "value1"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            yesterday,
-            yesterday,
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "value2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            dayAfterTomorrowInstant,
-            dayAfterTomorrowInstant,
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "value3"
-                )
-            )
-        )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                dayBeforeYesterday,
+                dayBeforeYesterday,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "value1",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                yesterday,
+                yesterday,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "value2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                dayAfterTomorrowInstant,
+                dayAfterTomorrowInstant,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "value3",
+                    ),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineGetDescriptionTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineGetDescriptionTest.kt
index bd9b89dc..0ec81672 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineGetDescriptionTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineGetDescriptionTest.kt
@@ -35,57 +35,70 @@ import kotlin.test.*
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/ /**
+*/
+
+/**
  * @author Zubair Asghar
  */
 class RuleEngineGetDescriptionTest {
     private var itemStore: MutableMap<String, DataItem> = HashMap()
     private val ruleAction = RuleAction("", "DISPLAYTEXT")
     private val ruleEngine: RuleEngine = DefaultRuleEngine()
+
     @BeforeTest
     fun setUp() {
         itemStore = HashMap()
-        val var_1 = DataItem(
-            test_var_one,
-            ItemValueType.TEXT
-        )
-        val var_2 = DataItem(
-            test_var_two,
-            ItemValueType.TEXT
-        )
-        val var_8 = DataItem(
-            test_var_three,
-            ItemValueType.TEXT
-        )
-        val var_3 = DataItem(
-            test_var_date_one,
-            ItemValueType.DATE
-        )
-        val var_4 = DataItem(
-            test_var_date_two,
-            ItemValueType.DATE
-        )
-        val var_5 = DataItem(
-            completionDate,
-            ItemValueType.DATE
-        )
-        val var_6 = DataItem(
-            constant,
-            ItemValueType.TEXT
-        )
-        val var_7 = DataItem(
-            currentDate,
-            ItemValueType.DATE
-        )
-        val var_9 = DataItem(
-            test_var_number,
-            ItemValueType.NUMBER
-        )
-
-        val var_10 = DataItem(
-            test_var_four,
-            ItemValueType.TEXT
-        )
+        val var_1 =
+            DataItem(
+                test_var_one,
+                ItemValueType.TEXT,
+            )
+        val var_2 =
+            DataItem(
+                test_var_two,
+                ItemValueType.TEXT,
+            )
+        val var_8 =
+            DataItem(
+                test_var_three,
+                ItemValueType.TEXT,
+            )
+        val var_3 =
+            DataItem(
+                test_var_date_one,
+                ItemValueType.DATE,
+            )
+        val var_4 =
+            DataItem(
+                test_var_date_two,
+                ItemValueType.DATE,
+            )
+        val var_5 =
+            DataItem(
+                completionDate,
+                ItemValueType.DATE,
+            )
+        val var_6 =
+            DataItem(
+                constant,
+                ItemValueType.TEXT,
+            )
+        val var_7 =
+            DataItem(
+                currentDate,
+                ItemValueType.DATE,
+            )
+        val var_9 =
+            DataItem(
+                test_var_number,
+                ItemValueType.NUMBER,
+            )
+
+        val var_10 =
+            DataItem(
+                test_var_four,
+                ItemValueType.TEXT,
+            )
         itemStore["test_var_one"] = var_1
         itemStore["test_var_two"] = var_2
         itemStore["test_var_date_one"] = var_3
@@ -100,11 +113,12 @@ class RuleEngineGetDescriptionTest {
 
     @Test
     fun evaluateGetDescriptionWithIncorrectRules() {
-        val rule= Rule("d2:hasValue(#{test_var_one} + 1)", listOf(ruleAction))
-        val rule1= Rule(
-            "d2:daysBetween((#{test_var_date_one},#{test_var_date_two})",
-            listOf(ruleAction)
-        )
+        val rule = Rule("d2:hasValue(#{test_var_one} + 1)", listOf(ruleAction))
+        val rule1 =
+            Rule(
+                "d2:daysBetween((#{test_var_date_one},#{test_var_date_two})",
+                listOf(ruleAction),
+            )
         var result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertFalse(result.valid)
@@ -125,7 +139,7 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun descriptionForLengthFunction() {
         var rule = Rule("d2:length(#{test_var_one}) > 0", listOf(ruleAction))
-        
+
         var result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -137,15 +151,16 @@ class RuleEngineGetDescriptionTest {
         result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertFalse(result.valid)
-        }
+    }
 
     @Test
     fun testGetDescriptionWithD2FunctionsAndLogicalAnd() {
-        val rule = Rule(
-            "d2:count(#{test_var_one}) > 0 && d2:hasValue(#{test_var_two})",
-            listOf(ruleAction)
-        )
-        
+        val rule =
+            Rule(
+                "d2:count(#{test_var_one}) > 0 && d2:hasValue(#{test_var_two})",
+                listOf(ruleAction),
+            )
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -153,8 +168,8 @@ class RuleEngineGetDescriptionTest {
 
     @Test
     fun testGetDescriptionWithD2FunctionsTEA() {
-        val rule= Rule("d2:hasValue('test_var_three')", listOf(ruleAction))
-        
+        val rule = Rule("d2:hasValue('test_var_three')", listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertEquals("d2:hasValue(Variable_THREE)", result.description)
@@ -163,8 +178,8 @@ class RuleEngineGetDescriptionTest {
 
     @Test
     fun testGetDescriptionWithPlainAttributeComparisonWithName() {
-        val rule= Rule("'test_var_three' == 'email'", listOf(ruleAction))
-        
+        val rule = Rule("'test_var_three' == 'email'", listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertEquals("'test_var_three' == 'email'", result.description)
@@ -173,8 +188,8 @@ class RuleEngineGetDescriptionTest {
 
     @Test
     fun testGetDescriptionWithPlainAttributeComparison() {
-        val rule= Rule("A{test_var_three} == 'email'", listOf(ruleAction))
-        
+        val rule = Rule("A{test_var_three} == 'email'", listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertEquals("Variable_THREE == 'email'", result.description)
@@ -184,8 +199,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionStringLiterals() {
         val condition = " true && false || 1 > 3"
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -194,8 +209,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionD2BetweenFunction() {
         val condition = "d2:daysBetween(#{test_var_date_one},#{test_var_date_two}) > 0"
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -204,8 +219,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionD2BetweenFunctionWithEnvironmentVariables() {
         val condition = "d2:daysBetween(V{completed_date},V{current_date}) > 0"
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -214,8 +229,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionD2FunctionAttribute() {
         val condition = "A{test_var_number} > 0"
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -224,8 +239,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionWithD2FunctionDataElement() {
         val condition = "#{test_var_number} > 0"
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -234,8 +249,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionWithConstant() {
         val condition = "C{NAgjOfWMXg6} == 0"
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -244,8 +259,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionWithProgramEnvironmentVariable() {
         val condition = "d2:hasValue(V{completed_date})"
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -254,8 +269,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionWithSingleD2Function() {
         val condition = "d2:hasValue(#{test_var_one})"
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -264,8 +279,8 @@ class RuleEngineGetDescriptionTest {
     @Test
     fun testGetDescriptionWithMultipleD2FunctionsAndLogicalOROperator() {
         val condition = "d2:hasValue(#{test_var_two}) || d2:count(#{test_var_one}) > 0 "
-        val rule= Rule(condition, listOf(ruleAction))
-        
+        val rule = Rule(condition, listOf(ruleAction))
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -275,7 +290,7 @@ class RuleEngineGetDescriptionTest {
     fun testGetDescriptionWithMultipleD2FunctionsAndLogicalANDOperator() {
         val condition = "d2:hasValue(#{test_var_two}) && d2:count(#{test_var_one}) > 0 "
         val rule = Rule(condition, listOf(ruleAction))
-        
+
         val result = ruleEngine.validate(rule.condition, itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -283,7 +298,6 @@ class RuleEngineGetDescriptionTest {
 
     @Test
     fun testGetDescriptionForDataFieldExpression() {
-        
         var result = ruleEngine.validateDataFieldExpression("1 + 1", itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
@@ -302,7 +316,7 @@ class RuleEngineGetDescriptionTest {
 
     @Test
     fun testGetDescriptionForNestedExpression() {
-        val result = ruleEngine.validate("d2:validatePattern(d2:right(A{test_var_four},1),'\\/202\\d{1}')",itemStore)
+        val result = ruleEngine.validate("d2:validatePattern(d2:right(A{test_var_four},1),'\\/202\\d{1}')", itemStore)
         assertNotNull(result)
         assertTrue(result.valid)
     }
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineTestUtils.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineTestUtils.kt
index 2b693b45..3b017526 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineTestUtils.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineTestUtils.kt
@@ -30,15 +30,16 @@ import org.hisp.dhis.rules.models.RuleVariable
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/ /**
+*/
+
+/**
  * @author Zubair Asghar
  */
 object RuleEngineTestUtils {
-    fun getRuleEngineContext(rule: Rule, ruleVariables: List<RuleVariable>): RuleEngineContext {
-        return RuleEngineContext(listOf(rule), ruleVariables)
-    }
+    fun getRuleEngineContext(
+        rule: Rule,
+        ruleVariables: List<RuleVariable>,
+    ): RuleEngineContext = RuleEngineContext(listOf(rule), ruleVariables)
 
-    fun getRuleEngineContext(rules: List<Rule>): RuleEngineContext {
-        return RuleEngineContext(rules, emptyList())
-    }
+    fun getRuleEngineContext(rules: List<Rule>): RuleEngineContext = RuleEngineContext(rules, emptyList())
 }
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineValueTypesTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineValueTypesTest.kt
index ae90634e..0b75c5e9 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineValueTypesTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineValueTypesTest.kt
@@ -12,23 +12,26 @@ import kotlin.test.assertEquals
 class RuleEngineValueTypesTest {
     @Test
     fun booleanVariableWithoutValueMustFallbackToDefaultBooleanValue() {
-        val ruleAction = RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleAction =
+            RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.BOOLEAN)
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.BOOLEAN)
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            ArrayList()
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                ArrayList(),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("false", ruleEffects[0].data)
@@ -36,25 +39,27 @@ class RuleEngineValueTypesTest {
     }
 
     @Test
-    
     fun numericVariableWithoutValueMustFallbackToDefaultNumericValue() {
-        val ruleAction = RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleAction =
+            RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.NUMERIC)
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.NUMERIC)
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            ArrayList()
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                ArrayList(),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("0", ruleEffects[0].data)
@@ -62,32 +67,35 @@ class RuleEngineValueTypesTest {
     }
 
     @Test
-    
     fun textVariableWithoutValueMustFallbackToDefaultTextValue() {
-        val ruleAction = RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleAction =
+            RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT)
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT)
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            ArrayList()
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                ArrayList(),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("", ruleEffects[0].data)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
     }
 
-    private fun getRuleEngineContext(rule: Rule, ruleVariables: List<RuleVariable>): RuleEngineContext {
-        return RuleEngineContext(listOf(rule), ruleVariables)
-    }
+    private fun getRuleEngineContext(
+        rule: Rule,
+        ruleVariables: List<RuleVariable>,
+    ): RuleEngineContext = RuleEngineContext(listOf(rule), ruleVariables)
 }
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineVariableNameTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineVariableNameTest.kt
index 43b0948c..c35e9334 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineVariableNameTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleEngineVariableNameTest.kt
@@ -12,107 +12,212 @@ import kotlin.test.assertEquals
 class RuleEngineVariableNameTest {
     @Test
     fun evaluateD2Round() {
-        val ruleAction1 = RuleAction("d2:round(#{" + UID01 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction2 = RuleAction("d2:round(#{" + VARIABLE_NAME + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction3 = RuleAction("d2:round(#{" + UID0 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction4 = RuleAction("d2:round(#{" + UID0WILD + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction5 = RuleAction("d2:round(#{" + UID01WILD + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction6 = RuleAction("d2:round(#{" + UID012 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction7 = RuleAction("d2:round(#{" + VARIABLE_NAME + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction8 = RuleAction("d2:round(A{" + UID0 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction9 = RuleAction("d2:round(#{" + UID01 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleAction10 = RuleAction("d2:round(A{" + VARIABLE_NAME + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariable1: RuleVariable = RuleVariableNewestEvent(
-            UID01, true, ArrayList(), "test_data_element1", RuleValueType.NUMERIC
-        )
-        val ruleVariable2: RuleVariable = RuleVariableNewestEvent(
-            VARIABLE_NAME, true, ArrayList(), "test_data_element2", RuleValueType.NUMERIC
-        )
-        val ruleVariable3: RuleVariable = RuleVariableNewestEvent(
-            UID0, true, ArrayList(), "test_data_element3", RuleValueType.NUMERIC
-        )
-        val ruleVariable4: RuleVariable = RuleVariableNewestEvent(
-            UID0WILD, true, ArrayList(), "test_data_element4", RuleValueType.NUMERIC
-        )
-        val ruleVariable5: RuleVariable = RuleVariableNewestEvent(
-            UID01WILD, true, ArrayList(), "test_data_element5", RuleValueType.NUMERIC
-        )
-        val ruleVariable6: RuleVariable = RuleVariableNewestEvent(
-            UID012, true, ArrayList(), "test_data_element6", RuleValueType.NUMERIC
-        )
-        val ruleVariable7: RuleVariable = RuleVariableNewestEvent(
-            UID0WILD2, true, ArrayList(), "test_data_element7", RuleValueType.NUMERIC
-        )
-        val actions = listOf(
-            ruleAction1, ruleAction2, ruleAction3, ruleAction4, ruleAction5, ruleAction6, ruleAction7,
-            ruleAction8, ruleAction9, ruleAction10
-        )
-        val rule = Rule(
-            "true",
-            actions, "", ""
-        )
-        val ruleVariables = listOf(
-            ruleVariable1, ruleVariable2, ruleVariable3, ruleVariable4, ruleVariable5, ruleVariable6,
-            ruleVariable7
-        )
-        val ruleEngineContext = getRuleEngineContext(
-            rule,
-            ruleVariables
-        )
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
+        val ruleAction1 =
+            RuleAction(
+                "d2:round(#{" + UID01 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction2 =
+            RuleAction(
+                "d2:round(#{" + VARIABLE_NAME + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction3 =
+            RuleAction(
+                "d2:round(#{" + UID0 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction4 =
+            RuleAction(
+                "d2:round(#{" + UID0WILD + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction5 =
+            RuleAction(
+                "d2:round(#{" + UID01WILD + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction6 =
+            RuleAction(
+                "d2:round(#{" + UID012 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction7 =
+            RuleAction(
+                "d2:round(#{" + VARIABLE_NAME + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction8 =
+            RuleAction(
+                "d2:round(A{" + UID0 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction9 =
+            RuleAction(
+                "d2:round(#{" + UID01 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleAction10 =
+            RuleAction(
+                "d2:round(A{" + VARIABLE_NAME + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariable1: RuleVariable =
+            RuleVariableNewestEvent(
+                UID01,
+                true,
+                ArrayList(),
+                "test_data_element1",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariable2: RuleVariable =
+            RuleVariableNewestEvent(
+                VARIABLE_NAME,
+                true,
+                ArrayList(),
+                "test_data_element2",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariable3: RuleVariable =
+            RuleVariableNewestEvent(
+                UID0,
+                true,
+                ArrayList(),
+                "test_data_element3",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariable4: RuleVariable =
+            RuleVariableNewestEvent(
+                UID0WILD,
+                true,
+                ArrayList(),
+                "test_data_element4",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariable5: RuleVariable =
+            RuleVariableNewestEvent(
+                UID01WILD,
+                true,
+                ArrayList(),
+                "test_data_element5",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariable6: RuleVariable =
+            RuleVariableNewestEvent(
+                UID012,
+                true,
+                ArrayList(),
+                "test_data_element6",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariable7: RuleVariable =
+            RuleVariableNewestEvent(
+                UID0WILD2,
+                true,
+                ArrayList(),
+                "test_data_element7",
+                RuleValueType.NUMERIC,
+            )
+        val actions =
             listOf(
-                RuleDataValue(
-                    "test_data_element1",
-                    "2.6"
-                ),
-                RuleDataValue(
-                    "test_data_element2",
-                    "2.6"
-                ),
-                RuleDataValue(
-                    "test_data_element3",
-                    "2.6"
-                ),
-                RuleDataValue(
-                    "test_data_element4",
-                    "2.6"
-                ),
-                RuleDataValue(
-                    "test_data_element5",
-                    "2.6"
-                ),
-                RuleDataValue(
-                    "test_data_element6",
-                    "2.6"
-                ),
-                RuleDataValue(
-                    "test_data_element7",
-                    "2.6"
-                ),
-                RuleDataValue(
-                    "test_data_element8",
-                    "2.6"
-                ),
-                RuleDataValue(
-                    "test_data_element9",
-                    "2.6"
+                ruleAction1,
+                ruleAction2,
+                ruleAction3,
+                ruleAction4,
+                ruleAction5,
+                ruleAction6,
+                ruleAction7,
+                ruleAction8,
+                ruleAction9,
+                ruleAction10,
+            )
+        val rule =
+            Rule(
+                "true",
+                actions,
+                "",
+                "",
+            )
+        val ruleVariables =
+            listOf(
+                ruleVariable1,
+                ruleVariable2,
+                ruleVariable3,
+                ruleVariable4,
+                ruleVariable5,
+                ruleVariable6,
+                ruleVariable7,
+            )
+        val ruleEngineContext =
+            getRuleEngineContext(
+                rule,
+                ruleVariables,
+            )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element1",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element2",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element3",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element4",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element5",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element6",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element7",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element8",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element9",
+                        "2.6",
+                    ),
+                    RuleDataValue(
+                        "test_data_element10",
+                        "2.6",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_data_element10",
-                    "2.6"
-                )
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(10, ruleEffects.size)
         assertEquals(ruleAction1, ruleEffects[0].ruleAction)
@@ -139,25 +244,36 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun evaluateHasValueFunctionMustReturnTrueIfVariableIsComposedUIDs() {
-        val ruleAction = RuleAction("d2:hasValue(#{" + UID01 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
-            UID01, true, ArrayList(), "test_data_element", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:hasValue(#{" + UID01 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent(
+                UID01,
+                true,
+                ArrayList(),
+                "test_data_element",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(RuleDataValue("test_data_element", "test_value"))
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(RuleDataValue("test_data_element", "test_value")),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("true", ruleEffects[0].data)
@@ -166,26 +282,38 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun evaluateHasValueFunctionMustReturnTrueIfVariableIsVariableName() {
-        val ruleAction = RuleAction("d2:hasValue(#{" + VARIABLE_NAME + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent(
-            VARIABLE_NAME, true, ArrayList(), "test_data_element", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:hasValue(#{" + VARIABLE_NAME + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent(
+                VARIABLE_NAME,
+                true,
+                ArrayList(),
+                "test_data_element",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariable))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(RuleDataValue("test_data_element", "test_value")
-            )
-        )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue("test_data_element", "test_value"),
+                ),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("true", ruleEffects[0].data)
@@ -194,66 +322,79 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun evaluateD2CountIfValueIsVariableName() {
-        val ruleAction = RuleAction("d2:countIfValue(#{" + VARIABLE_NAME + "}, 'condition')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:countIfValue(#{" + VARIABLE_NAME + "}, 'condition')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                VARIABLE_NAME,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2, ruleEvent3), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -262,66 +403,79 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun evaluateD2CountIfValueIsComposedUid() {
-        val ruleAction = RuleAction("d2:countIfValue(#{" + UID01 + "}, 'condition')", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:countIfValue(#{" + UID01 + "}, 'condition')",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                UID01,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2, ruleEvent3), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -330,87 +484,106 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun evaluateD2CountIfVariableName() {
-        val ruleAction = RuleAction("d2:count(#{" + VARIABLE_NAME + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:count(#{" + VARIABLE_NAME + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                VARIABLE_NAME,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent4 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_two",
-                    "condition"
-                )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent4 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "condition",
+                    ),
+                ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2, ruleEvent3, ruleEvent4), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -419,84 +592,98 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun evaluateD2CountIfVariableNameIfComposedUid() {
-        val ruleAction = RuleAction("d2:count(#{" + UID01 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:count(#{" + UID01 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                UID01,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition2"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "condition"
-                )
-            )
-        )
-        val ruleEvent4 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_two",
-                    "condition"
-                )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition2",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "condition",
+                    ),
+                ),
+            )
+        val ruleEvent4 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "condition",
+                    ),
+                ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent2, ruleEvent3, ruleEvent4), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -505,66 +692,79 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun evaluateD2CountIfZeroPosIfVariableName() {
-        val ruleAction = RuleAction("d2:countIfZeroPos(#{" + VARIABLE_NAME + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:countIfZeroPos(#{" + VARIABLE_NAME + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                VARIABLE_NAME,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "0"
-                )
-            )
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "1"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event1",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "-3"
-                )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "0",
+                    ),
+                ),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "1",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "-3",
+                    ),
+                ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -573,66 +773,79 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun evaluateD2CountIfZeroPosIfComposedUid() {
-        val ruleAction = RuleAction("d2:countIfZeroPos(#{" + UID01 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:countIfZeroPos(#{" + UID01 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                UID01,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariableOne))
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "0"
-                )
-            )
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "1"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event1",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "-3"
-                )
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "0",
+                    ),
+                ),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "1",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "-3",
+                    ),
+                ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -642,88 +855,103 @@ class RuleEngineVariableNameTest {
     @Test
     fun evaluateD2MaxValueIfVariableName() {
         val ruleAction = RuleAction("true", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:maxValue(#{" + VARIABLE_NAME + "}) == 8.0",
-            listOf(ruleAction),
-            "",
-            ""
-        )
-        val ruleEngineContext = getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "8"
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                VARIABLE_NAME,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:maxValue(#{" + VARIABLE_NAME + "}) == 8.0",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEngineContext =
+            getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "8",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -732,88 +960,103 @@ class RuleEngineVariableNameTest {
     @Test
     fun evaluateD2MaxValueIfComposedUid() {
         val ruleAction = RuleAction("true", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
-        val rule = Rule(
-            "d2:maxValue(#{" + UID01 + "}) == 8.0",
-            listOf(ruleAction),
-            "",
-            ""
-        )
-        val ruleEngineContext = getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "8"
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                UID01,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
+        val rule =
+            Rule(
+                "d2:maxValue(#{" + UID01 + "}) == 8.0",
+                listOf(ruleAction),
+                "",
+                "",
+            )
+        val ruleEngineContext =
+            getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "8",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -821,84 +1064,103 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun testMinValueIfVariableName() {
-        val ruleAction = RuleAction("d2:minValue(#{" + VARIABLE_NAME + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            VARIABLE_NAME, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:minValue(#{" + VARIABLE_NAME + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                VARIABLE_NAME,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext = getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "8"
+        val ruleEngineContext =
+            getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "8",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
@@ -907,84 +1169,103 @@ class RuleEngineVariableNameTest {
 
     @Test
     fun testMinValueIfComposedUid() {
-        val ruleAction = RuleAction("d2:minValue(#{" + UID01 + "})", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            UID01, true, ArrayList(), "test_data_element_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_var_two", true, ArrayList(), "test_data_element_two", RuleValueType.TEXT
-        )
+        val ruleAction =
+            RuleAction(
+                "d2:minValue(#{" + UID01 + "})",
+                "DISPLAYTEXT",
+                mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")),
+            )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                UID01,
+                true,
+                ArrayList(),
+                "test_data_element_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_var_two",
+                true,
+                ArrayList(),
+                "test_data_element_two",
+                RuleValueType.TEXT,
+            )
         val rule = Rule("true", listOf(ruleAction), "", "")
-        val ruleEngineContext = getRuleEngineContext(
-            rule,
-            listOf(ruleVariableOne, ruleVariableTwo)
-        )
-        val ruleEvent1 = RuleEvent(
-            "test_event1",
-            "test_program_stage1",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "5"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent2 = RuleEvent(
-            "test_event2",
-            "test_program_stage2",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "7"
-                ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
-            )
-        )
-        val ruleEvent3 = RuleEvent(
-            "test_event3",
-            "test_program_stage3",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_data_element_one",
-                    "8"
+        val ruleEngineContext =
+            getRuleEngineContext(
+                rule,
+                listOf(ruleVariableOne, ruleVariableTwo),
+            )
+        val ruleEvent1 =
+            RuleEvent(
+                "test_event1",
+                "test_program_stage1",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "5",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent2 =
+            RuleEvent(
+                "test_event2",
+                "test_program_stage2",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "7",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
+                ),
+            )
+        val ruleEvent3 =
+            RuleEvent(
+                "test_event3",
+                "test_program_stage3",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_data_element_one",
+                        "8",
+                    ),
+                    RuleDataValue(
+                        "test_data_element_two",
+                        "male",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_data_element_two",
-                    "male"
-                )
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent3, null, listOf(ruleEvent1, ruleEvent2), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals(ruleAction, ruleEffects[0].ruleAction)
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleVariableValueAssert.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleVariableValueAssert.kt
index b253ff38..a6f0d513 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleVariableValueAssert.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleVariableValueAssert.kt
@@ -4,7 +4,9 @@ import org.hisp.dhis.rules.engine.RuleVariableValue
 import org.hisp.dhis.rules.models.RuleValueType
 import kotlin.test.assertEquals
 
-internal class RuleVariableValueAssert private constructor(private val variableValue: RuleVariableValue) {
+internal class RuleVariableValueAssert private constructor(
+    private val variableValue: RuleVariableValue,
+) {
     fun hasValue(value: String?): RuleVariableValueAssert {
         assertEquals(value, variableValue.value)
         return this
@@ -18,14 +20,12 @@ internal class RuleVariableValueAssert private constructor(private val variableV
         return this
     }
 
-    fun isTypeOf( valueType: RuleValueType?): RuleVariableValueAssert {
+    fun isTypeOf(valueType: RuleValueType?): RuleVariableValueAssert {
         assertEquals(valueType, variableValue.type)
         return this
     }
 
     companion object {
-        fun assertThatVariable(variableValue: RuleVariableValue): RuleVariableValueAssert {
-            return RuleVariableValueAssert(variableValue)
-        }
+        fun assertThatVariable(variableValue: RuleVariableValue): RuleVariableValueAssert = RuleVariableValueAssert(variableValue)
     }
 }
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleVariableValueTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleVariableValueTest.kt
index b190a6c8..349de05a 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/RuleVariableValueTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/RuleVariableValueTest.kt
@@ -8,11 +8,16 @@ import kotlin.test.assertEquals
 class RuleVariableValueTest {
     @Test
     fun textValuesMostBeWrapped() {
-        val variableValue = RuleVariableValue(
-            RuleValueType.TEXT, "test_value", listOf(
-                "test_value_candidate_one", "test_value_candidate_two"
-            ), "2023-12-14"
-        )
+        val variableValue =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                "test_value",
+                listOf(
+                    "test_value_candidate_one",
+                    "test_value_candidate_two",
+                ),
+                "2023-12-14",
+            )
         assertEquals("test_value", variableValue.value)
         assertEquals(RuleValueType.TEXT, variableValue.type)
         assertEquals(2, variableValue.candidates.size)
@@ -22,11 +27,16 @@ class RuleVariableValueTest {
 
     @Test
     fun wrappedTextValuesMustNotBeDoubleWrapped() {
-        val variableValue = RuleVariableValue(
-            RuleValueType.TEXT, "test_value", listOf(
-                "test_value_candidate_one", "test_value_candidate_two"
-            ), "2023-12-14"
-        )
+        val variableValue =
+            RuleVariableValue(
+                RuleValueType.TEXT,
+                "test_value",
+                listOf(
+                    "test_value_candidate_one",
+                    "test_value_candidate_two",
+                ),
+                "2023-12-14",
+            )
         assertEquals("test_value", variableValue.value)
         assertEquals(RuleValueType.TEXT, variableValue.type)
         assertEquals(2, variableValue.candidates.size)
@@ -36,9 +46,13 @@ class RuleVariableValueTest {
 
     @Test
     fun numericValuesMostNotBeWrapped() {
-        val variableValue = RuleVariableValue(
-            RuleValueType.NUMERIC, "1", listOf("2", "3"), "2023-12-14"
-        )
+        val variableValue =
+            RuleVariableValue(
+                RuleValueType.NUMERIC,
+                "1",
+                listOf("2", "3"),
+                "2023-12-14",
+            )
         assertEquals("1", variableValue.value)
         assertEquals(RuleValueType.NUMERIC, variableValue.type)
         assertEquals(2, variableValue.candidates.size)
@@ -48,9 +62,13 @@ class RuleVariableValueTest {
 
     @Test
     fun booleanValuesMostNotBeWrapped() {
-        val variableValue = RuleVariableValue(
-            RuleValueType.BOOLEAN, "true", listOf("false", "false"), "2023-12-14"
-        )
+        val variableValue =
+            RuleVariableValue(
+                RuleValueType.BOOLEAN,
+                "true",
+                listOf("false", "false"),
+                "2023-12-14",
+            )
         assertEquals("true", variableValue.value)
         assertEquals(RuleValueType.BOOLEAN, variableValue.type)
         assertEquals(2, variableValue.candidates.size)
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/VariableValueTypeTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/VariableValueTypeTest.kt
index a07fef8b..5f08ea74 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/VariableValueTypeTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/VariableValueTypeTest.kt
@@ -38,28 +38,32 @@ import kotlin.test.assertEquals
 class VariableValueTypeTest {
     @Test
     fun testNumericVariablesAreComparedCorrectly() {
-        val ruleAction = RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleAction =
+            RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
         val rule = Rule("#{test_variable} > #{test_variable2}", listOf(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.NUMERIC)
-        val ruleVariable2: RuleVariable = RuleVariableCurrentEvent("test_variable2", true, ArrayList(), "test_data_element2", RuleValueType.NUMERIC)
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.NUMERIC)
+        val ruleVariable2: RuleVariable =
+            RuleVariableCurrentEvent("test_variable2", true, ArrayList(), "test_data_element2", RuleValueType.NUMERIC)
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariable, ruleVariable2))
         val now = Clock.System.now()
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            now,
-            now,
-            LocalDate.fromEpochDays(1),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue("test_data_element", "30"),
-                RuleDataValue("test_data_element2", "4")
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                now,
+                now,
+                LocalDate.fromEpochDays(1),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue("test_data_element", "30"),
+                    RuleDataValue("test_data_element2", "4"),
+                ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("30", ruleEffects[0].data)
@@ -68,33 +72,38 @@ class VariableValueTypeTest {
 
     @Test
     fun testTextVariablesAreComparedCorrectly() {
-        val ruleAction = RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
+        val ruleAction =
+            RuleAction("#{test_variable}", "DISPLAYTEXT", mapOf(Pair("content", "test_action_content"), Pair("location", "feedback")))
         val rule = Rule("#{test_variable} > #{test_variable2}", listOf(ruleAction), "", "")
-        val ruleVariable: RuleVariable = RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT)
-        val ruleVariable2: RuleVariable = RuleVariableCurrentEvent("test_variable2", true, ArrayList(), "test_data_element2", RuleValueType.TEXT)
+        val ruleVariable: RuleVariable =
+            RuleVariableCurrentEvent("test_variable", true, ArrayList(), "test_data_element", RuleValueType.TEXT)
+        val ruleVariable2: RuleVariable =
+            RuleVariableCurrentEvent("test_variable2", true, ArrayList(), "test_data_element2", RuleValueType.TEXT)
         val ruleEngineContext = getRuleEngineContext(rule, listOf(ruleVariable, ruleVariable2))
         val now = Clock.System.now()
-        val ruleEvent = RuleEvent(
-            "test_event",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            now,
-            now,
-            LocalDate.fromEpochDays(1),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue("test_data_element", "30"),
-                RuleDataValue("test_data_element2", "4")
+        val ruleEvent =
+            RuleEvent(
+                "test_event",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                now,
+                now,
+                LocalDate.fromEpochDays(1),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue("test_data_element", "30"),
+                    RuleDataValue("test_data_element2", "4"),
+                ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, null, emptyList(), ruleEngineContext)
         assertEquals(0, ruleEffects.size)
     }
 
-    private fun getRuleEngineContext(rule: Rule, ruleVariables: List<RuleVariable>): RuleEngineContext {
-        return RuleEngineContext(rules = listOf(rule), ruleVariables = ruleVariables)
-    }
+    private fun getRuleEngineContext(
+        rule: Rule,
+        ruleVariables: List<RuleVariable>,
+    ): RuleEngineContext = RuleEngineContext(rules = listOf(rule), ruleVariables = ruleVariables)
 }
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/models/CalculatedValueTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/models/CalculatedValueTest.kt
index 73c29dcd..74442d59 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/models/CalculatedValueTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/models/CalculatedValueTest.kt
@@ -40,29 +40,31 @@ class CalculatedValueTest {
     fun evaluateOneThousandRulesTest() {
         val i = 1000
         val ruleEngineContext = getRuleEngineContext(createRules(i))
-        val enrollment = RuleEnrollment(
-            "test_enrollment",
-            "test_program",
-            LocalDate.currentDate(),
-            LocalDate.currentDate(),
-            RuleEnrollmentStatus.ACTIVE,
-            "test_ou",
-            "test_ou_code",
-            listOf()
-        )
-        val ruleEvent = RuleEvent(
-            event = "test_event",
-            programStage = "test_program_stage",
-            programStageName = "",
-            status = RuleEventStatus.ACTIVE,
-            eventDate = Clock.System.now(),
-createdDate = Clock.System.now(),
-            dueDate = LocalDate.currentDate(),
-            organisationUnit = "",
-            organisationUnitCode = "",
-            completedDate = null,
-            dataValues = listOf(RuleDataValue("test_data_element", "test_value"))
-        )
+        val enrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "test_program",
+                LocalDate.currentDate(),
+                LocalDate.currentDate(),
+                RuleEnrollmentStatus.ACTIVE,
+                "test_ou",
+                "test_ou_code",
+                listOf(),
+            )
+        val ruleEvent =
+            RuleEvent(
+                event = "test_event",
+                programStage = "test_program_stage",
+                programStageName = "",
+                status = RuleEventStatus.ACTIVE,
+                eventDate = Clock.System.now(),
+                createdDate = Clock.System.now(),
+                dueDate = LocalDate.currentDate(),
+                organisationUnit = "",
+                organisationUnitCode = "",
+                completedDate = null,
+                dataValues = listOf(RuleDataValue("test_data_element", "test_value")),
+            )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, enrollment, emptyList(), ruleEngineContext)
         assertEquals(i, ruleEffects.size)
     }
@@ -72,36 +74,41 @@ createdDate = Clock.System.now(),
         val assignAction = RuleAction("2+2", "ASSIGN", mapOf(Pair("content", "#{test_calculated_value}")))
         val rule = Rule("true", listOf(assignAction), "test_program_rule1")
         val sendMessageAction =
-            RuleAction("4", "SENDMESSAGE",mapOf(Pair("content", "test_notification")))
-        val rule2 = Rule(
-            "#{test_calculated_value}==4",
-            listOf(sendMessageAction),
-            "test_program_rule2"
-        )
-        val enrollment = RuleEnrollment(
-            "test_enrollment",
-            "test_program",
-            LocalDate.currentDate(),
-            LocalDate.currentDate(),
-            RuleEnrollmentStatus.ACTIVE,
-            "test_ou",
-            "test_ou_code",
-            listOf()
-        )
-        val ruleEvent = RuleEvent(
-            event = "test_event",
-            programStage = "test_program_stage",
-            programStageName = "",
-            status = RuleEventStatus.ACTIVE,
-            eventDate = Clock.System.now(),
-createdDate = Clock.System.now(),
-            dueDate = LocalDate.currentDate(),
-            organisationUnit = "",
-            organisationUnitCode = "",
-            completedDate = null,
-            dataValues = listOf(RuleDataValue("test_data_element", "test_value")
+            RuleAction("4", "SENDMESSAGE", mapOf(Pair("content", "test_notification")))
+        val rule2 =
+            Rule(
+                "#{test_calculated_value}==4",
+                listOf(sendMessageAction),
+                "test_program_rule2",
+            )
+        val enrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "test_program",
+                LocalDate.currentDate(),
+                LocalDate.currentDate(),
+                RuleEnrollmentStatus.ACTIVE,
+                "test_ou",
+                "test_ou_code",
+                listOf(),
+            )
+        val ruleEvent =
+            RuleEvent(
+                event = "test_event",
+                programStage = "test_program_stage",
+                programStageName = "",
+                status = RuleEventStatus.ACTIVE,
+                eventDate = Clock.System.now(),
+                createdDate = Clock.System.now(),
+                dueDate = LocalDate.currentDate(),
+                organisationUnit = "",
+                organisationUnitCode = "",
+                completedDate = null,
+                dataValues =
+                    listOf(
+                        RuleDataValue("test_data_element", "test_value"),
+                    ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, enrollment, emptyList(), getRuleEngineContext(listOf(rule, rule2)))
         assertEquals("4", ruleEffects[0].data)
         assertEquals(sendMessageAction, ruleEffects[0].ruleAction)
@@ -112,12 +119,13 @@ createdDate = Clock.System.now(),
         val assignAction = RuleAction("2+2", "ASSIGN", mapOf(Pair("content", "#{test_calculated_value}")))
         val rule = Rule("true", listOf(assignAction), "test_program_rule1")
         val sendMessageAction =
-            RuleAction("4", "SENDMESSAGE",mapOf(Pair("content", "test_notification")))
-        val rule2 = Rule(
-            "#{test_calculated_value}==4",
-            listOf(sendMessageAction),
-            "test_program_rule2"
-        )
+            RuleAction("4", "SENDMESSAGE", mapOf(Pair("content", "test_notification")))
+        val rule2 =
+            Rule(
+                "#{test_calculated_value}==4",
+                listOf(sendMessageAction),
+                "test_program_rule2",
+            )
         for (j in 0 until i) {
             rules.add(rule)
             rules.add(rule2)
@@ -130,36 +138,43 @@ createdDate = Clock.System.now(),
         val assignAction = RuleAction("2+2", "ASSIGN", mapOf(Pair("content", "#{test_calculated_value}")))
         val rule = Rule("true", listOf(assignAction), "test_program_rule1", "")
         val sendMessageAction =
-            RuleAction("4.0", "SENDMESSAGE",mapOf(Pair("content", "test_notification")))
-        val rule2 = Rule(
-            "#{test_calculated_value}==4.0", listOf(sendMessageAction),
-            "test_program_rule2", ""
-        )
+            RuleAction("4.0", "SENDMESSAGE", mapOf(Pair("content", "test_notification")))
+        val rule2 =
+            Rule(
+                "#{test_calculated_value}==4.0",
+                listOf(sendMessageAction),
+                "test_program_rule2",
+                "",
+            )
         val ruleEngineContext = getRuleEngineContext(listOf(rule, rule2))
-        val enrollment = RuleEnrollment(
-            "test_enrollment",
-            "test_program",
-            LocalDate.currentDate(),
-            LocalDate.currentDate(),
-            RuleEnrollmentStatus.ACTIVE,
-            "test_ou",
-            "test_ou_code",
-            listOf()
-        )
-        val ruleEvent = RuleEvent(
-            event = "test_event",
-            programStage = "test_program_stage",
-            programStageName = "",
-            status = RuleEventStatus.ACTIVE,
-            eventDate = Clock.System.now(),
-createdDate = Clock.System.now(),
-            dueDate = LocalDate.currentDate(),
-            organisationUnit = "",
-            organisationUnitCode = "",
-            completedDate = null,
-            dataValues = listOf(RuleDataValue("test_data_element", "test_value")
+        val enrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "test_program",
+                LocalDate.currentDate(),
+                LocalDate.currentDate(),
+                RuleEnrollmentStatus.ACTIVE,
+                "test_ou",
+                "test_ou_code",
+                listOf(),
+            )
+        val ruleEvent =
+            RuleEvent(
+                event = "test_event",
+                programStage = "test_program_stage",
+                programStageName = "",
+                status = RuleEventStatus.ACTIVE,
+                eventDate = Clock.System.now(),
+                createdDate = Clock.System.now(),
+                dueDate = LocalDate.currentDate(),
+                organisationUnit = "",
+                organisationUnitCode = "",
+                completedDate = null,
+                dataValues =
+                    listOf(
+                        RuleDataValue("test_data_element", "test_value"),
+                    ),
             )
-        )
         val ruleEffects = RuleEngine.getInstance().evaluate(ruleEvent, enrollment, emptyList(), ruleEngineContext)
         assertEquals(1, ruleEffects.size)
         assertEquals("4", ruleEffects[0].data)
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleEventTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleEventTest.kt
index 96f84e1a..e852db41 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleEventTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleEventTest.kt
@@ -15,10 +15,20 @@ class RuleEventTest {
         ruleDataValues.add(ruleDataValue)
         val eventDate = Clock.System.now()
         val dueDate = LocalDate.Companion.currentDate()
-        val (event, programStage, _, status, eventDate1,_, dueDate1, _, _, _, dataValues) = RuleEvent(
-            "test_event_uid", "test_stage_uid", "",
-            RuleEventStatus.ACTIVE, eventDate, eventDate, dueDate, null, "", "", ruleDataValues
-        )
+        val (event, programStage, _, status, eventDate1, _, dueDate1, _, _, _, dataValues) =
+            RuleEvent(
+                "test_event_uid",
+                "test_stage_uid",
+                "",
+                RuleEventStatus.ACTIVE,
+                eventDate,
+                eventDate,
+                dueDate,
+                null,
+                "",
+                "",
+                ruleDataValues,
+            )
         assertEquals("test_event_uid", event)
         assertEquals(RuleEventStatus.ACTIVE, status)
         assertEquals("test_stage_uid", programStage)
@@ -33,15 +43,31 @@ class RuleEventTest {
         val ruleEvents: List<RuleEvent> =
             listOf(
                 RuleEvent(
-                    "test_event_one", "test_program_stage_one", "", RuleEventStatus.ACTIVE,
-                    Instant.parse("2014-02-11T01:00:00Z"), Instant.parse("2014-02-11T01:00:00Z"), LocalDate.parse("2014-02-11"), null, "", null,
-                    emptyList()
+                    "test_event_one",
+                    "test_program_stage_one",
+                    "",
+                    RuleEventStatus.ACTIVE,
+                    Instant.parse("2014-02-11T01:00:00Z"),
+                    Instant.parse("2014-02-11T01:00:00Z"),
+                    LocalDate.parse("2014-02-11"),
+                    null,
+                    "",
+                    null,
+                    emptyList(),
                 ),
                 RuleEvent(
-                    "test_event_two", "test_program_stage_two", "", RuleEventStatus.ACTIVE,
-                    Instant.parse("2017-03-22T01:00:00Z"), Instant.parse("2014-02-11T01:00:00Z"), LocalDate.parse("2017-03-22"), null, "", null,
-                    emptyList()
-                )
+                    "test_event_two",
+                    "test_program_stage_two",
+                    "",
+                    RuleEventStatus.ACTIVE,
+                    Instant.parse("2017-03-22T01:00:00Z"),
+                    Instant.parse("2014-02-11T01:00:00Z"),
+                    LocalDate.parse("2017-03-22"),
+                    null,
+                    "",
+                    null,
+                    emptyList(),
+                ),
             )
         val reversed = ruleEvents.sortedBy { e -> e.eventDate }.reversed()
         assertEquals("test_event_two", reversed[0].event)
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleTest.kt
index 52b5b102..73c8f7cf 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleTest.kt
@@ -6,15 +6,16 @@ import kotlin.test.assertEquals
 class RuleTest {
     @Test
     fun createShouldPropagatePropertiesCorrectly() {
-        val ruleAction= RuleAction("data", "ERROR")
-        val (condition, actions, uid, _, programStage, priority) = Rule(
-            "test_condition",
-            listOf(ruleAction),
-            "uid",
-            "",
-            "test_program_stage",
-            1
-        )
+        val ruleAction = RuleAction("data", "ERROR")
+        val (condition, actions, uid, _, programStage, priority) =
+            Rule(
+                "test_condition",
+                listOf(ruleAction),
+                "uid",
+                "",
+                "test_program_stage",
+                1,
+            )
         assertEquals("test_program_stage", programStage)
         assertEquals("test_condition", condition)
         assertEquals(1, priority)
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.kt
index 9a631f21..4f740d9f 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleVariablePreviousEventTest.kt
@@ -6,7 +6,6 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNull
 
-
 class RuleVariablePreviousEventTest {
     private val today = LocalDate.Companion.currentDate()
     private val yesterday = today.minus(1, DateTimeUnit.DAY)
@@ -18,7 +17,8 @@ class RuleVariablePreviousEventTest {
     private val todayMorning = today.atTime(LocalTime(10, 0, 0)).toInstant(TimeZone.currentSystemDefault())
     private val todayAfternoon = today.atTime(LocalTime(14, 0, 0)).toInstant(TimeZone.currentSystemDefault())
 
-    private val ruleVariablePreviousEvent = RuleVariablePreviousEvent("previous value", true, emptyList(), "data_element", RuleValueType.NUMERIC)
+    private val ruleVariablePreviousEvent =
+        RuleVariablePreviousEvent("previous value", true, emptyList(), "data_element", RuleValueType.NUMERIC)
 
     @Test
     fun shouldCreateEmptyRuleVariableValueWhenNoDataValuesArePresent() {
@@ -86,8 +86,11 @@ class RuleVariablePreviousEventTest {
         assertEquals(emptyList(), ruleVariableValue.candidates)
     }
 
-    private fun event(eventDate: Instant, createdDate: Instant): RuleEvent {
-        return RuleEvent(
+    private fun event(
+        eventDate: Instant,
+        createdDate: Instant,
+    ): RuleEvent =
+        RuleEvent(
             event = "test_event",
             programStage = "test_program_stage",
             programStageName = "",
@@ -99,48 +102,38 @@ class RuleVariablePreviousEventTest {
             organisationUnitCode = "",
             completedDate = LocalDate.currentDate(),
             dataValues =
-            listOf(
-                RuleDataValue("data_element", "1"),
-                RuleDataValue("data_element", "2"),
-                RuleDataValue("data_element", "3"),
-                RuleDataValue("data_element", "4"),
-                RuleDataValue("data_element", "5")
-            )
+                listOf(
+                    RuleDataValue("data_element", "1"),
+                    RuleDataValue("data_element", "2"),
+                    RuleDataValue("data_element", "3"),
+                    RuleDataValue("data_element", "4"),
+                    RuleDataValue("data_element", "5"),
+                ),
         )
-    }
 
     private fun allEventsDataValues(): Map<String, List<RuleDataValueHistory>> {
-        val ruleDataValues = mutableListOf(
-            todayDataValue(),
-            yesterdayDataValueCreatedThisMorning(),
-            yesterdayDataValueCreatedThisAfternoon(),
-            tomorrowDataValue(),
-            dayBeforeYesterdayDataValue()
-        )
-        ruleDataValues.sortWith(compareBy<RuleDataValueHistory>({ it.eventDate}, {it.createdDate }).reversed())
+        val ruleDataValues =
+            mutableListOf(
+                todayDataValue(),
+                yesterdayDataValueCreatedThisMorning(),
+                yesterdayDataValueCreatedThisAfternoon(),
+                tomorrowDataValue(),
+                dayBeforeYesterdayDataValue(),
+            )
+        ruleDataValues.sortWith(compareBy<RuleDataValueHistory>({ it.eventDate }, { it.createdDate }).reversed())
 
         return mapOf(Pair("data_element", ruleDataValues))
     }
 
-    private fun todayDataValue(): RuleDataValueHistory {
-        return RuleDataValueHistory("1", todayInstant, todayInstant, "")
-    }
-
-    private fun yesterdayDataValueCreatedThisMorning(): RuleDataValueHistory {
-        return RuleDataValueHistory("2", yesterdayInstant, todayMorning, "")
-    }
-
-    private fun yesterdayDataValueCreatedThisAfternoon(): RuleDataValueHistory {
-        return RuleDataValueHistory("3", yesterdayInstant, todayAfternoon, "")
-    }
+    private fun todayDataValue(): RuleDataValueHistory = RuleDataValueHistory("1", todayInstant, todayInstant, "")
 
-    private fun dayBeforeYesterdayDataValue(): RuleDataValueHistory {
-        return RuleDataValueHistory("5", dayBeforeYesterdayInstant, todayAfternoon, "")
-    }
+    private fun yesterdayDataValueCreatedThisMorning(): RuleDataValueHistory = RuleDataValueHistory("2", yesterdayInstant, todayMorning, "")
 
-    private fun tomorrowDataValue(): RuleDataValueHistory {
-        return RuleDataValueHistory("4", tomorrow, tomorrow, "")
-    }
+    private fun yesterdayDataValueCreatedThisAfternoon(): RuleDataValueHistory =
+        RuleDataValueHistory("3", yesterdayInstant, todayAfternoon, "")
 
+    private fun dayBeforeYesterdayDataValue(): RuleDataValueHistory =
+        RuleDataValueHistory("5", dayBeforeYesterdayInstant, todayAfternoon, "")
 
-}
\ No newline at end of file
+    private fun tomorrowDataValue(): RuleDataValueHistory = RuleDataValueHistory("4", tomorrow, tomorrow, "")
+}
diff --git a/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleVariableValueMapBuilderTest.kt b/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleVariableValueMapBuilderTest.kt
index 185fc671..fd7a7c35 100644
--- a/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleVariableValueMapBuilderTest.kt
+++ b/src/commonTest/kotlin/org/hisp/dhis/rules/models/RuleVariableValueMapBuilderTest.kt
@@ -11,781 +11,1279 @@ import kotlin.test.assertNull
 class RuleVariableValueMapBuilderTest {
     @Test
     fun currentEventVariableShouldContainNullValueForEnrollmentEvaluation() {
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable_one", true, ArrayList(), "test_dataelement_one", RuleValueType.TEXT
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable_one",
+                true,
+                ArrayList(),
+                "test_dataelement_one",
+                RuleValueType.TEXT,
+            )
         val eventDate = Instant.parse("2015-01-01T01:00:00Z")
 
         // values from context events should be ignored
-        val ruleEnrollment = RuleEnrollment(
-            "test_enrollment", "",
-            LocalDate.parse("2015-01-01"), LocalDate.parse("2015-01-01"),
-            RuleEnrollmentStatus.ACTIVE, "", "", listOf(
-                RuleAttributeValue("test_attribute_one", "test_attribute_value_one"),
-                RuleAttributeValue("test_attribute_two", "test_attribute_value_two")
-            )
-        )
-        val contextEventOne = RuleEvent(
-            "test_context_event_one",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_context_value_one"
+        val ruleEnrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "",
+                LocalDate.parse("2015-01-01"),
+                LocalDate.parse("2015-01-01"),
+                RuleEnrollmentStatus.ACTIVE,
+                "",
+                "",
+                listOf(
+                    RuleAttributeValue("test_attribute_one", "test_attribute_value_one"),
+                    RuleAttributeValue("test_attribute_two", "test_attribute_value_two"),
+                ),
+            )
+        val contextEventOne =
+            RuleEvent(
+                "test_context_event_one",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_context_value_one",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_context_value_two",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_context_value_two"
-                )
             )
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariableOne), setOf(contextEventOne), ruleEnrollment)
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_one"]!!).hasValue(null)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariableOne), setOf(contextEventOne), ruleEnrollment)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_one"]!!)
+            .hasValue(null)
             .isTypeOf(RuleValueType.TEXT)
     }
 
     @Test
     fun currentEventVariableShouldContainValuesFromCurrentEvent() {
-        val ruleVariableOne: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable_one", true, ArrayList(), "test_dataelement_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable_two", true, ArrayList(), "test_dataelement_two", RuleValueType.TEXT
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable_one",
+                true,
+                ArrayList(),
+                "test_dataelement_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable_two",
+                true,
+                ArrayList(),
+                "test_dataelement_two",
+                RuleValueType.TEXT,
+            )
         val eventInstant = Instant.parse("2015-01-01T01:00:00Z")
         val eventDate = LocalDate.parse("2015-01-01")
         val dueDate = LocalDate.parse("2016-01-01")
 
         // values from context events should be ignored
-        val contextEventOne = RuleEvent(
-            "test_context_event_one",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_context_value_one"
+        val contextEventOne =
+            RuleEvent(
+                "test_context_event_one",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_context_value_one",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_context_value_two",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_context_value_two"
-                )
             )
-        )
-        val contextEventTwo = RuleEvent(
-            "test_context_event_two",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_context_value_three"
+        val contextEventTwo =
+            RuleEvent(
+                "test_context_event_two",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_context_value_three",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_context_value_four",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_context_value_four"
-                )
             )
-        )
         // values from current ruleEvent should be propagated to the variable values
-        val currentEvent = RuleEvent(
-            "test_event_uid", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, eventInstant, eventInstant, dueDate, null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_value_one"
+        val currentEvent =
+            RuleEvent(
+                "test_event_uid",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                eventInstant,
+                eventInstant,
+                dueDate,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_value_one",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_value_two",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_value_two"
-                )
             )
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo), setOf(contextEventOne, contextEventTwo), null, currentEvent)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo), setOf(contextEventOne, contextEventTwo), null, currentEvent)
         assertEquals(13, valueMap.size.toLong())
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(
-            LocalDate.Companion.currentDate().toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(LocalDate.Companion.currentDate().toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_date"]!!).hasValue(
-            eventDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(eventDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_status"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(
+                LocalDate.Companion.currentDate().toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(LocalDate.Companion.currentDate().toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_date"]!!)
+            .hasValue(
+                eventDate.toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(eventDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_status"]!!)
             .hasValue(RuleEventStatus.ACTIVE.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(RuleEventStatus.ACTIVE.toString())
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(RuleEventStatus.ACTIVE.toString())
 
         // event count variable should respect current event
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("3")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("3")
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_id"]!!).hasValue("test_event_uid")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_event_uid")
-        RuleVariableValueAssert.assertThatVariable(valueMap["due_date"]!!).hasValue(
-                dueDate.toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dueDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_one"]!!).hasValue("test_value_one")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_value_one")
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_two"]!!).hasValue("test_value_two")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_value_two")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("3")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("3")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_id"]!!)
+            .hasValue("test_event_uid")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_event_uid")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["due_date"]!!)
+            .hasValue(
+                dueDate.toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dueDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_one"]!!)
+            .hasValue("test_value_one")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_value_one")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_two"]!!)
+            .hasValue("test_value_two")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_value_two")
     }
 
     @Test
     fun newestEventProgramVariableShouldContainValueFromNewestContextEvent() {
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_variable_one", true, ArrayList(), "test_dataelement_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_variable_two", true, ArrayList(), "test_dataelement_two", RuleValueType.TEXT
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_variable_one",
+                true,
+                ArrayList(),
+                "test_dataelement_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_variable_two",
+                true,
+                ArrayList(),
+                "test_dataelement_two",
+                RuleValueType.TEXT,
+            )
         val oldestEventDate = Instant.parse("2013-01-01T01:00:00Z")
         val newestEventDate = Instant.parse("2017-01-01T01:00:00Z")
         val currentEventInstant = Instant.parse("2015-01-01T01:00:00Z")
         val currentEventDate = LocalDate.parse("2015-01-01")
         val currentEventDueDate: LocalDate? = null
-        val oldestRuleEvent = RuleEvent(
-            "test_event_uid_oldest",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            oldestEventDate,
-            oldestEventDate,
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_value_one_oldest"
+        val oldestRuleEvent =
+            RuleEvent(
+                "test_event_uid_oldest",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                oldestEventDate,
+                oldestEventDate,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_value_one_oldest",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_value_two_oldest",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_value_two_oldest"
-                )
             )
-        )
-        val newestRuleEvent = RuleEvent(
-            "test_event_uid_newest",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            newestEventDate,
-            newestEventDate,
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_value_one_newest"
+        val newestRuleEvent =
+            RuleEvent(
+                "test_event_uid_newest",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                newestEventDate,
+                newestEventDate,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_value_one_newest",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_value_two_newest",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_value_two_newest"
-                )
             )
-        )
-        val currentEvent = RuleEvent(
-            "test_event_uid_current",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            currentEventInstant,
-            currentEventInstant,
-            currentEventDueDate,
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_value_one_current"
+        val currentEvent =
+            RuleEvent(
+                "test_event_uid_current",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                currentEventInstant,
+                currentEventInstant,
+                currentEventDueDate,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_value_one_current",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_value_two_current",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_value_two_current"
-                )
             )
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo), setOf(oldestRuleEvent, newestRuleEvent), null, currentEvent)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo), setOf(oldestRuleEvent, newestRuleEvent), null, currentEvent)
         assertEquals(valueMap.size.toLong(), 12)
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(
-                LocalDate.Companion.currentDate().toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(LocalDate.Companion.currentDate().toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(
+                LocalDate.Companion.currentDate().toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(LocalDate.Companion.currentDate().toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_date"]!!)
             .hasValue(currentEventDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(currentEventDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("3")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("3")
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_id"]!!).hasValue("test_event_uid_current")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_event_uid_current")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(currentEventDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("3")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("3")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_id"]!!)
+            .hasValue("test_event_uid_current")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_event_uid_current")
         assertNull(valueMap["due_date"])
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_one"]!!).hasValue("test_value_one_newest")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_one"]!!)
+            .hasValue("test_value_one_newest")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(
                 "test_value_one_newest",
-                "test_value_one_current", "test_value_one_oldest"
+                "test_value_one_current",
+                "test_value_one_oldest",
             )
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_two"]!!).hasValue("test_value_two_newest")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_two"]!!)
+            .hasValue("test_value_two_newest")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(
                 "test_value_two_newest",
-                "test_value_two_current", "test_value_two_oldest"
+                "test_value_two_current",
+                "test_value_two_oldest",
             )
     }
 
     @Test
     fun newestEventProgramVariableShouldReturnValuesFromCurrentEventWhenIfNewest() {
-        val ruleVariableOne: RuleVariable = RuleVariableNewestEvent(
-            "test_variable_one", true, ArrayList(), "test_dataelement_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableNewestEvent(
-            "test_variable_two", true, ArrayList(), "test_dataelement_two", RuleValueType.TEXT
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_variable_one",
+                true,
+                ArrayList(),
+                "test_dataelement_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableNewestEvent(
+                "test_variable_two",
+                true,
+                ArrayList(),
+                "test_dataelement_two",
+                RuleValueType.TEXT,
+            )
         val dateEventOne = Instant.parse("2013-01-01T01:00:00Z")
         val dateEventTwo = Instant.parse("2014-01-01T01:00:00Z")
         val instantEventCurrent = Instant.parse("2015-01-01T01:00:00Z")
         val dateEventCurrent = LocalDate.parse("2015-01-01")
         val dateEventDueCurrent = LocalDate.parse("2016-01-01")
-        val firstRuleEvent = RuleEvent(
-            "test_event_uid_one", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, dateEventOne, dateEventOne, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_value_dataelement_one_first"
+        val firstRuleEvent =
+            RuleEvent(
+                "test_event_uid_one",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventOne,
+                dateEventOne,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_value_dataelement_one_first",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_value_dataelement_two_first",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_value_dataelement_two_first"
-                )
             )
-        )
-        val secondRuleEvent = RuleEvent(
-            "test_event_uid_two", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, dateEventTwo, dateEventTwo, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_value_dataelement_one_second"
+        val secondRuleEvent =
+            RuleEvent(
+                "test_event_uid_two",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventTwo,
+                dateEventTwo,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_value_dataelement_one_second",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_value_dataelement_two_second",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_value_dataelement_two_second"
-                )
             )
-        )
-        val currentEvent = RuleEvent(
-            "test_event_uid_current",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            instantEventCurrent,
-            instantEventCurrent,
-            dateEventDueCurrent,
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_value_dataelement_one_current"
+        val currentEvent =
+            RuleEvent(
+                "test_event_uid_current",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                instantEventCurrent,
+                instantEventCurrent,
+                dateEventDueCurrent,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_value_dataelement_one_current",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_value_dataelement_two_current",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_value_dataelement_two_current"
-                )
             )
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo), setOf(firstRuleEvent, secondRuleEvent), null, currentEvent)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo), setOf(firstRuleEvent, secondRuleEvent), null, currentEvent)
         assertEquals(13, valueMap.size.toLong())
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(
-                LocalDate.Companion.currentDate().toString()
-
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(LocalDate.Companion.currentDate().toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(
+                LocalDate.Companion.currentDate().toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(LocalDate.Companion.currentDate().toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_date"]!!)
             .hasValue(dateEventCurrent.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dateEventCurrent.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("3")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("3")
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_id"]!!).hasValue("test_event_uid_current")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_event_uid_current")
-        RuleVariableValueAssert.assertThatVariable(valueMap["due_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dateEventCurrent.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("3")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("3")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_id"]!!)
+            .hasValue("test_event_uid_current")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_event_uid_current")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["due_date"]!!)
             .hasValue(dateEventDueCurrent.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dateEventDueCurrent.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_one"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dateEventDueCurrent.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_one"]!!)
             .hasValue("test_value_dataelement_one_current")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(
                 "test_value_dataelement_one_current",
-                "test_value_dataelement_one_second", "test_value_dataelement_one_first"
+                "test_value_dataelement_one_second",
+                "test_value_dataelement_one_first",
             )
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_two"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_two"]!!)
             .hasValue("test_value_dataelement_two_current")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(
                 "test_value_dataelement_two_current",
-                "test_value_dataelement_two_second", "test_value_dataelement_two_first"
+                "test_value_dataelement_two_second",
+                "test_value_dataelement_two_first",
             )
     }
 
     @Test
     fun newestEventProgramStageVariableShouldContainValueFromNewestContextEvent() {
-        val ruleVariable: RuleVariable = RuleVariableNewestStageEvent(
-            "test_variable", true, ArrayList(),
-            "test_dataelement", RuleValueType.TEXT, "test_program_stage_one"
-        )
+        val ruleVariable: RuleVariable =
+            RuleVariableNewestStageEvent(
+                "test_variable",
+                true,
+                ArrayList(),
+                "test_dataelement",
+                RuleValueType.TEXT,
+                "test_program_stage_one",
+            )
         val dateEventOne = Instant.parse("2014-02-03T01:00:00Z")
         val dateEventTwo = Instant.parse("2014-03-03T01:00:00Z")
         val dateEventThree = Instant.parse("2015-02-03T01:00:00Z")
         val instantEventCurrent = Instant.parse("2011-02-03T01:00:00Z")
         val dateEventCurrent = LocalDate.parse("2011-02-03")
         val dateEventDueCurrent = LocalDate.parse("2011-02-03")
-        val eventOne = RuleEvent(
-            "test_event_uid_one", "test_program_stage_one", "",
-            RuleEventStatus.ACTIVE, dateEventOne, dateEventOne, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_one"
-                )
+        val eventOne =
+            RuleEvent(
+                "test_event_uid_one",
+                "test_program_stage_one",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventOne,
+                dateEventOne,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_one",
+                    ),
+                ),
             )
-        )
-        val eventTwo = RuleEvent(
-            "test_event_uid_two", "test_program_stage_two", "",
-            RuleEventStatus.ACTIVE, dateEventTwo, dateEventTwo, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_two"
-                )
+        val eventTwo =
+            RuleEvent(
+                "test_event_uid_two",
+                "test_program_stage_two",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventTwo,
+                dateEventTwo,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_two",
+                    ),
+                ),
             )
-        )
-        val eventThree = RuleEvent(
-            "test_event_uid_three", "test_program_stage_two", "",
-            RuleEventStatus.ACTIVE, dateEventThree, dateEventThree, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_three"
-                )
+        val eventThree =
+            RuleEvent(
+                "test_event_uid_three",
+                "test_program_stage_two",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventThree,
+                dateEventThree,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_three",
+                    ),
+                ),
             )
-        )
-        val eventCurrent = RuleEvent(
-            "test_event_uid_current",
-            "test_program_stage_one",
-            "",
-            RuleEventStatus.ACTIVE,
-            instantEventCurrent,
-            instantEventCurrent,
-            dateEventDueCurrent,
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_current"
-                )
+        val eventCurrent =
+            RuleEvent(
+                "test_event_uid_current",
+                "test_program_stage_one",
+                "",
+                RuleEventStatus.ACTIVE,
+                instantEventCurrent,
+                instantEventCurrent,
+                dateEventDueCurrent,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_current",
+                    ),
+                ),
             )
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariable), setOf(eventOne, eventTwo, eventThree), null, eventCurrent)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariable), setOf(eventOne, eventTwo, eventThree), null, eventCurrent)
         assertEquals(12, valueMap.size.toLong())
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(
-                LocalDate.Companion.currentDate().toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(LocalDate.Companion.currentDate().toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(
+                LocalDate.Companion.currentDate().toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(LocalDate.Companion.currentDate().toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_date"]!!)
             .hasValue(dateEventCurrent.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dateEventCurrent.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("4")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("4")
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_id"]!!).hasValue("test_event_uid_current")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_event_uid_current")
-        RuleVariableValueAssert.assertThatVariable(valueMap["due_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dateEventCurrent.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("4")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("4")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_id"]!!)
+            .hasValue("test_event_uid_current")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_event_uid_current")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["due_date"]!!)
             .hasValue(dateEventDueCurrent.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dateEventDueCurrent.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable"]!!).hasValue("test_value_one")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_value_one", "test_value_current")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dateEventDueCurrent.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable"]!!)
+            .hasValue("test_value_one")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_value_one", "test_value_current")
     }
 
     @Test
     fun newestEventProgramStageVariableShouldNotContainAnyValues() {
-        val ruleVariable: RuleVariable = RuleVariableNewestStageEvent(
-            "test_variable", true, ArrayList(),
-            "test_dataelement", RuleValueType.TEXT, "test_program_stage_one"
-        )
+        val ruleVariable: RuleVariable =
+            RuleVariableNewestStageEvent(
+                "test_variable",
+                true,
+                ArrayList(),
+                "test_dataelement",
+                RuleValueType.TEXT,
+                "test_program_stage_one",
+            )
         val dateEventOne = Instant.parse("2014-03-03T01:00:00Z")
         val instantEventTwo = Instant.parse("2015-02-03T01:00:00Z")
         val dateEventTwo = LocalDate.parse("2015-02-03")
         val dueDateEventTwo = LocalDate.parse("2015-02-03")
-        val ruleEventOne = RuleEvent(
-            "test_event_uid_one", "test_program_stage_two", "",
-            RuleEventStatus.ACTIVE, dateEventOne, dateEventOne, dueDateEventTwo, null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_one"
-                )
+        val ruleEventOne =
+            RuleEvent(
+                "test_event_uid_one",
+                "test_program_stage_two",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventOne,
+                dateEventOne,
+                dueDateEventTwo,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_one",
+                    ),
+                ),
             )
-        )
-        val ruleEventTwo = RuleEvent(
-            "test_event_uid_two", "test_program_stage_two", "",
-            RuleEventStatus.ACTIVE, instantEventTwo, instantEventTwo, dueDateEventTwo, null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_two"
-                )
+        val ruleEventTwo =
+            RuleEvent(
+                "test_event_uid_two",
+                "test_program_stage_two",
+                "",
+                RuleEventStatus.ACTIVE,
+                instantEventTwo,
+                instantEventTwo,
+                dueDateEventTwo,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_two",
+                    ),
+                ),
             )
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariable), setOf(ruleEventOne), null, ruleEventTwo)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariable), setOf(ruleEventOne), null, ruleEventTwo)
         assertEquals(12, valueMap.size.toLong())
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(
-                LocalDate.Companion.currentDate().toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(LocalDate.Companion.currentDate().toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_date"]!!).hasValue(
-            dateEventTwo.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dateEventTwo.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("2")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("2")
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_id"]!!).hasValue("test_event_uid_two")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_event_uid_two")
-        RuleVariableValueAssert.assertThatVariable(valueMap["due_date"]!!).hasValue(
-            dueDateEventTwo.toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dueDateEventTwo.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable"]!!).hasValue(null)
-            .isTypeOf(RuleValueType.TEXT).hasCandidates()
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(
+                LocalDate.Companion.currentDate().toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(LocalDate.Companion.currentDate().toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_date"]!!)
+            .hasValue(
+                dateEventTwo.toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dateEventTwo.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("2")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("2")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_id"]!!)
+            .hasValue("test_event_uid_two")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_event_uid_two")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["due_date"]!!)
+            .hasValue(
+                dueDateEventTwo.toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dueDateEventTwo.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable"]!!)
+            .hasValue(null)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates()
     }
 
     @Test
     fun previousEventVariableShouldContainValuesFromPreviousEvent() {
-        val ruleVariable: RuleVariable = RuleVariablePreviousEvent(
-            "test_variable", true, ArrayList(),
-            "test_dataelement", RuleValueType.TEXT
-        )
+        val ruleVariable: RuleVariable =
+            RuleVariablePreviousEvent(
+                "test_variable",
+                true,
+                ArrayList(),
+                "test_dataelement",
+                RuleValueType.TEXT,
+            )
         val dateEventOne = Instant.parse("2014-02-03T01:00:00Z")
         val dateEventTwo = Instant.parse("2014-03-03T01:00:00Z")
         val dateEventThree = Instant.parse("2015-02-03T01:00:00Z")
         val instantEventCurrent = Instant.parse("2014-05-03T01:00:00Z")
         val dateEventCurrent = LocalDate.parse("2014-05-03")
         val dueDateEventCurrent = LocalDate.parse("2014-05-03")
-        val ruleEventOne = RuleEvent(
-            "test_event_uid_one", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, dateEventOne, dateEventOne, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_one"
-                )
+        val ruleEventOne =
+            RuleEvent(
+                "test_event_uid_one",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventOne,
+                dateEventOne,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_one",
+                    ),
+                ),
             )
-        )
-        val ruleEventTwo = RuleEvent(
-            "test_event_uid_two", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, dateEventTwo, dateEventTwo, LocalDate.currentDate(), null, "", null,
-            listOf(RuleDataValue("test_dataelement", "test_value_two"))
-        )
-        val ruleEventThree = RuleEvent(
-            "test_event_uid_three", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, dateEventThree, dateEventThree, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue("test_dataelement", "test_value_three")
-            )
-        )
-        val ruleEventCurrent = RuleEvent(
-            "test_event_uid_current",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            instantEventCurrent,
-            instantEventCurrent,
-            dueDateEventCurrent,
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_current"
-                )
+        val ruleEventTwo =
+            RuleEvent(
+                "test_event_uid_two",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventTwo,
+                dateEventTwo,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(RuleDataValue("test_dataelement", "test_value_two")),
+            )
+        val ruleEventThree =
+            RuleEvent(
+                "test_event_uid_three",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventThree,
+                dateEventThree,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue("test_dataelement", "test_value_three"),
+                ),
+            )
+        val ruleEventCurrent =
+            RuleEvent(
+                "test_event_uid_current",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                instantEventCurrent,
+                instantEventCurrent,
+                dueDateEventCurrent,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_current",
+                    ),
+                ),
             )
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariable), setOf(ruleEventOne, ruleEventTwo, ruleEventThree), null, ruleEventCurrent)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariable), setOf(ruleEventOne, ruleEventTwo, ruleEventThree), null, ruleEventCurrent)
         assertEquals(12, valueMap.size.toLong())
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(
-                LocalDate.Companion.currentDate().toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(LocalDate.Companion.currentDate().toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(
+                LocalDate.Companion.currentDate().toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(LocalDate.Companion.currentDate().toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_date"]!!)
             .hasValue(dateEventCurrent.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dateEventCurrent.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("4")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("4")
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_id"]!!).hasValue("test_event_uid_current")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_event_uid_current")
-        RuleVariableValueAssert.assertThatVariable(valueMap["due_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dateEventCurrent.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("4")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("4")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_id"]!!)
+            .hasValue("test_event_uid_current")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_event_uid_current")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["due_date"]!!)
             .hasValue(dueDateEventCurrent.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dueDateEventCurrent.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable"]!!).hasValue("test_value_two")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dueDateEventCurrent.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable"]!!)
+            .hasValue("test_value_two")
             .isTypeOf(RuleValueType.TEXT)
             .hasCandidates("test_value_three", "test_value_current", "test_value_two", "test_value_one")
     }
+
     @Test
     fun previousEventVariableShouldContainValuesFromPreviousEventWhenTeyAreOnTheSameDate() {
-        val ruleVariable: RuleVariable = RuleVariablePreviousEvent(
-            "test_variable", true, ArrayList(),
-            "test_dataelement", RuleValueType.TEXT
-        )
+        val ruleVariable: RuleVariable =
+            RuleVariablePreviousEvent(
+                "test_variable",
+                true,
+                ArrayList(),
+                "test_dataelement",
+                RuleValueType.TEXT,
+            )
         val dateEventOne = Instant.parse("2014-02-03T01:00:00Z")
         val dateEventTwo = Instant.parse("2014-03-03T01:00:00Z")
         val dateEventThree = Instant.parse("2015-02-03T01:00:00Z")
         val instantEventCurrent = Instant.parse("2014-03-03T01:00:00Z")
         val dateEventCurrent = LocalDate.parse("2014-03-03")
         val dueDateEventCurrent = LocalDate.parse("2014-05-03")
-        val ruleEventOne = RuleEvent(
-            "test_event_uid_one", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, dateEventOne, dateEventOne, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_one"
-                )
+        val ruleEventOne =
+            RuleEvent(
+                "test_event_uid_one",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventOne,
+                dateEventOne,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_one",
+                    ),
+                ),
             )
-        )
-        val ruleEventTwo = RuleEvent(
-            "test_event_uid_two", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, dateEventTwo, dateEventTwo, LocalDate.currentDate(), null, "", null,
-            listOf(RuleDataValue("test_dataelement", "test_value_two"))
-        )
-        val ruleEventThree = RuleEvent(
-            "test_event_uid_three", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, dateEventThree, dateEventThree, LocalDate.currentDate(), null, "", null, listOf(
-                RuleDataValue("test_dataelement", "test_value_three")
-            )
-        )
-        val ruleEventCurrent = RuleEvent(
-            "test_event_uid_current",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            instantEventCurrent,
-            dateEventOne,
-            dueDateEventCurrent,
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement", "test_value_current"
-                )
+        val ruleEventTwo =
+            RuleEvent(
+                "test_event_uid_two",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventTwo,
+                dateEventTwo,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(RuleDataValue("test_dataelement", "test_value_two")),
+            )
+        val ruleEventThree =
+            RuleEvent(
+                "test_event_uid_three",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                dateEventThree,
+                dateEventThree,
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue("test_dataelement", "test_value_three"),
+                ),
+            )
+        val ruleEventCurrent =
+            RuleEvent(
+                "test_event_uid_current",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                instantEventCurrent,
+                dateEventOne,
+                dueDateEventCurrent,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement",
+                        "test_value_current",
+                    ),
+                ),
             )
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariable), setOf(ruleEventOne, ruleEventTwo, ruleEventThree), null, ruleEventCurrent)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariable), setOf(ruleEventOne, ruleEventTwo, ruleEventThree), null, ruleEventCurrent)
         assertEquals(12, valueMap.size.toLong())
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(
-            LocalDate.Companion.currentDate().toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(LocalDate.Companion.currentDate().toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(
+                LocalDate.Companion.currentDate().toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(LocalDate.Companion.currentDate().toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_date"]!!)
             .hasValue(dateEventCurrent.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dateEventCurrent.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("4")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("4")
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_id"]!!).hasValue("test_event_uid_current")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_event_uid_current")
-        RuleVariableValueAssert.assertThatVariable(valueMap["due_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dateEventCurrent.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("4")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("4")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_id"]!!)
+            .hasValue("test_event_uid_current")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_event_uid_current")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["due_date"]!!)
             .hasValue(dueDateEventCurrent.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dueDateEventCurrent.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable"]!!).hasValue("test_value_one")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dueDateEventCurrent.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable"]!!)
+            .hasValue("test_value_one")
             .isTypeOf(RuleValueType.TEXT)
             .hasCandidates("test_value_three", "test_value_two", "test_value_current", "test_value_one")
     }
 
     @Test
     fun attributeVariableShouldContainValuesFromContextEnrollment() {
-        val ruleVariableOne: RuleVariable = RuleVariableAttribute(
-            "test_variable_one", true, ArrayList(),
-            "test_attribute_one", RuleValueType.TEXT
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableAttribute(
-            "test_variable_two", true, ArrayList(),
-            "test_attribute_two", RuleValueType.TEXT
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableAttribute(
+                "test_variable_one",
+                true,
+                ArrayList(),
+                "test_attribute_one",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableAttribute(
+                "test_variable_two",
+                true,
+                ArrayList(),
+                "test_attribute_two",
+                RuleValueType.TEXT,
+            )
         val eventInstant = Instant.parse("2015-01-01T01:00:00Z")
         val eventDate = LocalDate.parse("2015-01-01")
         val dueEventDate = LocalDate.parse("2015-01-01")
         val enrollmentDate = LocalDate.parse("2014-03-01")
 
         // values from enrollment should end up in ruleVariables
-        val ruleEnrollment = RuleEnrollment(
-            "test_enrollment", "",
-            enrollmentDate, enrollmentDate, RuleEnrollmentStatus.ACTIVE, "", "", listOf(
-                RuleAttributeValue("test_attribute_one", "test_attribute_value_one"),
-                RuleAttributeValue("test_attribute_two", "test_attribute_value_two")
+        val ruleEnrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "",
+                enrollmentDate,
+                enrollmentDate,
+                RuleEnrollmentStatus.ACTIVE,
+                "",
+                "",
+                listOf(
+                    RuleAttributeValue("test_attribute_one", "test_attribute_value_one"),
+                    RuleAttributeValue("test_attribute_two", "test_attribute_value_two"),
+                ),
             )
-        )
 
         // values from context events should be ignored
-        val contextEvent = RuleEvent(
-            "test_context_event_one",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            eventInstant,
-            eventInstant,
-            dueEventDate,
-            null,
-            "",
-            null,
-            listOf(
-                RuleDataValue(
-                    "test_dataelement_one", "test_context_value_one"
+        val contextEvent =
+            RuleEvent(
+                "test_context_event_one",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                eventInstant,
+                eventInstant,
+                dueEventDate,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue(
+                        "test_dataelement_one",
+                        "test_context_value_one",
+                    ),
+                    RuleDataValue(
+                        "test_dataelement_two",
+                        "test_context_value_two",
+                    ),
                 ),
-                RuleDataValue(
-                    "test_dataelement_two", "test_context_value_two"
-                )
             )
-        )
-        val currentEvent = RuleEvent(
-            "test_event_uid", "test_program_stage", "",
-            RuleEventStatus.ACTIVE, eventInstant, eventInstant, dueEventDate, null, "", null, listOf(
-                RuleDataValue("test_dataelement_one", "test_value_one"),
-                RuleDataValue("test_dataelement_two", "test_value_two")
+        val currentEvent =
+            RuleEvent(
+                "test_event_uid",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                eventInstant,
+                eventInstant,
+                dueEventDate,
+                null,
+                "",
+                null,
+                listOf(
+                    RuleDataValue("test_dataelement_one", "test_value_one"),
+                    RuleDataValue("test_dataelement_two", "test_value_two"),
+                ),
             )
-        )
 
         // here we will expect correct values to be returned
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo), setOf(contextEvent), ruleEnrollment, currentEvent)
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo), setOf(contextEvent), ruleEnrollment, currentEvent)
         assertEquals(20, valueMap.size.toLong())
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(
-                LocalDate.Companion.currentDate().toString()
-        )
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(LocalDate.Companion.currentDate().toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_date"]!!).hasValue(
-            eventDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(eventDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("2")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("2")
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_id"]!!).hasValue("test_event_uid")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_event_uid")
-        RuleVariableValueAssert.assertThatVariable(valueMap["due_date"]!!).hasValue(
-            dueEventDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(dueEventDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["enrollment_status"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(
+                LocalDate.Companion.currentDate().toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(LocalDate.Companion.currentDate().toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_date"]!!)
+            .hasValue(
+                eventDate.toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(eventDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("2")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("2")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_id"]!!)
+            .hasValue("test_event_uid")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_event_uid")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["due_date"]!!)
+            .hasValue(
+                dueEventDate.toString(),
+            ).isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(dueEventDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["enrollment_status"]!!)
             .hasValue(RuleEnrollmentStatus.ACTIVE.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(RuleEnrollmentStatus.ACTIVE.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["enrollment_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(RuleEnrollmentStatus.ACTIVE.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["enrollment_date"]!!)
             .hasValue(enrollmentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(enrollmentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["enrollment_id"]!!).hasValue("test_enrollment")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_enrollment")
-        RuleVariableValueAssert.assertThatVariable(valueMap["enrollment_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(valueMap["incident_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(enrollmentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["enrollment_id"]!!)
+            .hasValue("test_enrollment")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_enrollment")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["enrollment_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["incident_date"]!!)
             .hasValue(enrollmentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(enrollmentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["tei_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_one"]!!).hasValue("test_attribute_value_one")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_attribute_value_one")
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_two"]!!).hasValue("test_attribute_value_two")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_attribute_value_two")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(enrollmentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["tei_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_one"]!!)
+            .hasValue("test_attribute_value_one")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_attribute_value_one")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_two"]!!)
+            .hasValue("test_attribute_value_two")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_attribute_value_two")
     }
 
     @Test
     fun ruleEnrollmentValuesShouldBePropagatedToMapCorrectly() {
-        val ruleVariableOne: RuleVariable = RuleVariableAttribute(
-            "test_variable_one", true, ArrayList(),
-            "test_attribute_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableAttribute(
-            "test_variable_two", true, ArrayList(),
-            "test_attribute_two", RuleValueType.TEXT
-        )
-        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable_three", true, ArrayList(),
-            "test_dataelement_one", RuleValueType.BOOLEAN
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableAttribute(
+                "test_variable_one",
+                true,
+                ArrayList(),
+                "test_attribute_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableAttribute(
+                "test_variable_two",
+                true,
+                ArrayList(),
+                "test_attribute_two",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableThree: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable_three",
+                true,
+                ArrayList(),
+                "test_dataelement_one",
+                RuleValueType.BOOLEAN,
+            )
         val currentDate = LocalDate.Companion.currentDate()
         val enrollmentDate = LocalDate.parse("2017-02-02")
         val incidentDate = LocalDate.parse("2017-04-02")
-        val ruleEnrollment = RuleEnrollment(
-            "test_enrollment", "", incidentDate,
-            enrollmentDate, RuleEnrollmentStatus.ACTIVE, "", "", listOf(
-                RuleAttributeValue("test_attribute_one", "test_attribute_value_one"),
-                RuleAttributeValue("test_attribute_two", "test_attribute_value_two"),
-                RuleAttributeValue("test_attribute_three", "test_attribute_value_three")
-            )
-        )
-        val ruleEventOne = RuleEvent(
-            "test_event_one",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            ArrayList<RuleDataValue>()
-        )
-        val ruleEventTwo = RuleEvent(
-            "test_event_two",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            Clock.System.now(),
-            Clock.System.now(),
-            LocalDate.currentDate(),
-            null,
-            "",
-            null,
-            ArrayList<RuleDataValue>()
-        )
-        val valueMap = RuleVariableValueMapBuilder()
-            .build(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo, ruleVariableThree), setOf(ruleEventOne, ruleEventTwo), ruleEnrollment)
+        val ruleEnrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "",
+                incidentDate,
+                enrollmentDate,
+                RuleEnrollmentStatus.ACTIVE,
+                "",
+                "",
+                listOf(
+                    RuleAttributeValue("test_attribute_one", "test_attribute_value_one"),
+                    RuleAttributeValue("test_attribute_two", "test_attribute_value_two"),
+                    RuleAttributeValue("test_attribute_three", "test_attribute_value_three"),
+                ),
+            )
+        val ruleEventOne =
+            RuleEvent(
+                "test_event_one",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                ArrayList<RuleDataValue>(),
+            )
+        val ruleEventTwo =
+            RuleEvent(
+                "test_event_two",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                Clock.System.now(),
+                Clock.System.now(),
+                LocalDate.currentDate(),
+                null,
+                "",
+                null,
+                ArrayList<RuleDataValue>(),
+            )
+        val valueMap =
+            RuleVariableValueMapBuilder()
+                .build(
+                    emptyMap(),
+                    listOf(ruleVariableOne, ruleVariableTwo, ruleVariableThree),
+                    setOf(ruleEventOne, ruleEventTwo),
+                    ruleEnrollment,
+                )
         assertEquals(15, valueMap.size.toLong())
-        RuleVariableValueAssert.assertThatVariable(valueMap["current_date"]!!).hasValue(currentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(currentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["event_count"]!!).hasValue("2")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("2")
-        RuleVariableValueAssert.assertThatVariable(valueMap["enrollment_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["current_date"]!!)
+            .hasValue(currentDate.toString())
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(currentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["event_count"]!!)
+            .hasValue("2")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("2")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["enrollment_date"]!!)
             .hasValue(enrollmentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(enrollmentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["enrollment_id"]!!).hasValue("test_enrollment")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_enrollment")
-        RuleVariableValueAssert.assertThatVariable(valueMap["enrollment_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(valueMap["incident_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(enrollmentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["enrollment_id"]!!)
+            .hasValue("test_enrollment")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_enrollment")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["enrollment_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["incident_date"]!!)
             .hasValue(incidentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(incidentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(valueMap["tei_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_one"]!!).hasValue("test_attribute_value_one")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("test_attribute_value_one")
-        RuleVariableValueAssert.assertThatVariable(valueMap["test_variable_two"]!!).isTypeOf(RuleValueType.TEXT)
-            .hasValue("test_attribute_value_two").hasCandidates("test_attribute_value_two")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(incidentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["tei_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_one"]!!)
+            .hasValue("test_attribute_value_one")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("test_attribute_value_one")
+        RuleVariableValueAssert
+            .assertThatVariable(valueMap["test_variable_two"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasValue("test_attribute_value_two")
+            .hasCandidates("test_attribute_value_two")
     }
 
     @Test
     fun MultipleMapBuilderShoulCreateCorrectMapForEnrollmentAndEvents() {
-        val ruleVariableOne: RuleVariable = RuleVariableAttribute(
-            "test_variable_one", true, ArrayList(),
-            "test_attribute_one", RuleValueType.NUMERIC
-        )
-        val ruleVariableTwo: RuleVariable = RuleVariableAttribute(
-            "test_variable_two", true, ArrayList(),
-            "test_attribute_two", RuleValueType.TEXT
-        )
-        val ruleVariableThree: RuleVariable = RuleVariableCurrentEvent(
-            "test_variable_three", true, ArrayList(),
-            "test_dataelement_one", RuleValueType.BOOLEAN
-        )
+        val ruleVariableOne: RuleVariable =
+            RuleVariableAttribute(
+                "test_variable_one",
+                true,
+                ArrayList(),
+                "test_attribute_one",
+                RuleValueType.NUMERIC,
+            )
+        val ruleVariableTwo: RuleVariable =
+            RuleVariableAttribute(
+                "test_variable_two",
+                true,
+                ArrayList(),
+                "test_attribute_two",
+                RuleValueType.TEXT,
+            )
+        val ruleVariableThree: RuleVariable =
+            RuleVariableCurrentEvent(
+                "test_variable_three",
+                true,
+                ArrayList(),
+                "test_dataelement_one",
+                RuleValueType.BOOLEAN,
+            )
         val currentDate = LocalDate.Companion.currentDate()
         val enrollmentDate = LocalDate.parse("2017-02-02")
         val incidentDate = LocalDate.parse("2017-04-02")
-        val ruleEnrollment = RuleEnrollment(
-            "test_enrollment", "", incidentDate,
-            enrollmentDate, RuleEnrollmentStatus.ACTIVE, "", "", listOf(
-                RuleAttributeValue("test_attribute_one", "test_attribute_value_one"),
-                RuleAttributeValue("test_attribute_two", "test_attribute_value_two"),
-                RuleAttributeValue("test_attribute_three", "test_attribute_value_three")
-            )
-        )
+        val ruleEnrollment =
+            RuleEnrollment(
+                "test_enrollment",
+                "",
+                incidentDate,
+                enrollmentDate,
+                RuleEnrollmentStatus.ACTIVE,
+                "",
+                "",
+                listOf(
+                    RuleAttributeValue("test_attribute_one", "test_attribute_value_one"),
+                    RuleAttributeValue("test_attribute_two", "test_attribute_value_two"),
+                    RuleAttributeValue("test_attribute_three", "test_attribute_value_three"),
+                ),
+            )
         val now = LocalDate.Companion.currentDate()
         val eventOneInstant = now.minus(1, DateTimeUnit.DAY).atStartOfDayIn(TimeZone.currentSystemDefault())
         val eventOneDate = now.minus(1, DateTimeUnit.DAY)
@@ -793,34 +1291,42 @@ class RuleVariableValueMapBuilderTest {
         val eventTwoInstant = now.minus(3, DateTimeUnit.DAY).atStartOfDayIn(TimeZone.currentSystemDefault())
         val eventTwoDate = now.minus(3, DateTimeUnit.DAY)
         val eventTwoDueDate = now.minus(4, DateTimeUnit.DAY)
-        val ruleEventOne = RuleEvent(
-            "test_event_one",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            eventOneInstant,
-            eventOneInstant,
-            eventOneDueDate,
-            null,
-            "",
-            null,
-            ArrayList<RuleDataValue>()
-        )
-        val ruleEventTwo = RuleEvent(
-            "test_event_two",
-            "test_program_stage",
-            "",
-            RuleEventStatus.ACTIVE,
-            eventTwoInstant,
-            eventTwoInstant,
-            eventTwoDueDate,
-            null,
-            "",
-            null,
-            ArrayList<RuleDataValue>()
-        )
-        val (enrollmentMap, eventMap) = RuleVariableValueMapBuilder()
-            .multipleBuild(emptyMap(), listOf(ruleVariableOne, ruleVariableTwo, ruleVariableThree), setOf(ruleEventOne, ruleEventTwo), ruleEnrollment)
+        val ruleEventOne =
+            RuleEvent(
+                "test_event_one",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                eventOneInstant,
+                eventOneInstant,
+                eventOneDueDate,
+                null,
+                "",
+                null,
+                ArrayList<RuleDataValue>(),
+            )
+        val ruleEventTwo =
+            RuleEvent(
+                "test_event_two",
+                "test_program_stage",
+                "",
+                RuleEventStatus.ACTIVE,
+                eventTwoInstant,
+                eventTwoInstant,
+                eventTwoDueDate,
+                null,
+                "",
+                null,
+                ArrayList<RuleDataValue>(),
+            )
+        val (enrollmentMap, eventMap) =
+            RuleVariableValueMapBuilder()
+                .multipleBuild(
+                    emptyMap(),
+                    listOf(ruleVariableOne, ruleVariableTwo, ruleVariableThree),
+                    setOf(ruleEventOne, ruleEventTwo),
+                    ruleEnrollment,
+                )
         assertEquals(1, enrollmentMap.size.toLong())
         assertEquals(2, eventMap.size.toLong())
         val enrollmentValueMap = enrollmentMap[ruleEnrollment]
@@ -828,87 +1334,166 @@ class RuleVariableValueMapBuilderTest {
         val eventTwoValueMap = eventMap[ruleEventTwo]
 
         // Enrollment
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap!!["current_date"]!!).hasValue(currentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(currentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap["event_count"]!!).hasValue("2")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("2")
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap["enrollment_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap!!["current_date"]!!)
+            .hasValue(currentDate.toString())
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(currentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap["event_count"]!!)
+            .hasValue("2")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("2")
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap["enrollment_date"]!!)
             .hasValue(enrollmentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(enrollmentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap["enrollment_id"]!!).hasValue("test_enrollment")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_enrollment")
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap["enrollment_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap["incident_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(enrollmentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap["enrollment_id"]!!)
+            .hasValue("test_enrollment")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_enrollment")
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap["enrollment_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap["incident_date"]!!)
             .hasValue(incidentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(incidentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap["tei_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap["test_variable_one"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(incidentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap["tei_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap["test_variable_one"]!!)
             .hasValue("test_attribute_value_one")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("test_attribute_value_one")
-        RuleVariableValueAssert.assertThatVariable(enrollmentValueMap["test_variable_two"]!!)
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("test_attribute_value_one")
+        RuleVariableValueAssert
+            .assertThatVariable(enrollmentValueMap["test_variable_two"]!!)
             .isTypeOf(RuleValueType.TEXT)
-            .hasValue("test_attribute_value_two").hasCandidates("test_attribute_value_two")
+            .hasValue("test_attribute_value_two")
+            .hasCandidates("test_attribute_value_two")
 
         // Event one
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap!!["current_date"]!!).hasValue(currentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(currentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["event_count"]!!).hasValue("2")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("2")
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["enrollment_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap!!["current_date"]!!)
+            .hasValue(currentDate.toString())
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(currentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["event_count"]!!)
+            .hasValue("2")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("2")
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["enrollment_date"]!!)
             .hasValue(enrollmentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(enrollmentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["enrollment_id"]!!).hasValue("test_enrollment")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_enrollment")
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["enrollment_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["incident_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(enrollmentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["enrollment_id"]!!)
+            .hasValue("test_enrollment")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_enrollment")
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["enrollment_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["incident_date"]!!)
             .hasValue(incidentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(incidentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["tei_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["test_variable_one"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(incidentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["tei_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["test_variable_one"]!!)
             .hasValue("test_attribute_value_one")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("test_attribute_value_one")
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["test_variable_two"]!!).isTypeOf(
-            RuleValueType.TEXT)
-            .hasValue("test_attribute_value_two").hasCandidates("test_attribute_value_two")
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["event_date"]!!)
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("test_attribute_value_one")
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["test_variable_two"]!!)
+            .isTypeOf(
+                RuleValueType.TEXT,
+            ).hasValue("test_attribute_value_two")
+            .hasCandidates("test_attribute_value_two")
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["event_date"]!!)
             .hasValue(eventOneDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(eventOneDate.toString())
-        RuleVariableValueAssert.assertThatVariable(eventOneValueMap["due_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(eventOneDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(eventOneValueMap["due_date"]!!)
             .hasValue(eventOneDueDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(eventOneDueDate.toString())
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(eventOneDueDate.toString())
 
         // Event two
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap!!["current_date"]!!).hasValue(currentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(currentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["event_count"]!!).hasValue("2")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("2")
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["enrollment_date"]!!)
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap!!["current_date"]!!)
+            .hasValue(currentDate.toString())
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(currentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["event_count"]!!)
+            .hasValue("2")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("2")
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["enrollment_date"]!!)
             .hasValue(enrollmentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(enrollmentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["enrollment_id"]!!).hasValue("test_enrollment")
-            .isTypeOf(RuleValueType.TEXT).hasCandidates("test_enrollment")
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["enrollment_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["incident_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(enrollmentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["enrollment_id"]!!)
+            .hasValue("test_enrollment")
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates("test_enrollment")
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["enrollment_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["incident_date"]!!)
             .hasValue(incidentDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(incidentDate.toString())
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["tei_count"]!!).hasValue("1")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("1")
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["test_variable_one"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(incidentDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["tei_count"]!!)
+            .hasValue("1")
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("1")
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["test_variable_one"]!!)
             .hasValue("test_attribute_value_one")
-            .isTypeOf(RuleValueType.NUMERIC).hasCandidates("test_attribute_value_one")
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["test_variable_two"]!!).isTypeOf(
-            RuleValueType.TEXT)
-            .hasValue("test_attribute_value_two").hasCandidates("test_attribute_value_two")
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["event_date"]!!)
+            .isTypeOf(RuleValueType.NUMERIC)
+            .hasCandidates("test_attribute_value_one")
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["test_variable_two"]!!)
+            .isTypeOf(
+                RuleValueType.TEXT,
+            ).hasValue("test_attribute_value_two")
+            .hasCandidates("test_attribute_value_two")
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["event_date"]!!)
             .hasValue(eventTwoDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(eventTwoDate.toString())
-        RuleVariableValueAssert.assertThatVariable(eventTwoValueMap["due_date"]!!)
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(eventTwoDate.toString())
+        RuleVariableValueAssert
+            .assertThatVariable(eventTwoValueMap["due_date"]!!)
             .hasValue(eventTwoDueDate.toString())
-            .isTypeOf(RuleValueType.TEXT).hasCandidates(eventTwoDueDate.toString())
+            .isTypeOf(RuleValueType.TEXT)
+            .hasCandidates(eventTwoDueDate.toString())
     }
 }