Implement inequality operators (<, >, <=, >=) in the enable when statement

common/build.gradle.kts

@@ -28,6 +28,7 @@ dependencies {
  api(Dependencies.HapiFhir.structuresR4)
 
  implementation(Dependencies.fhirUcum)
+ implementation(Dependencies.Kotlin.kotlinTestJunit)
 
  testImplementation(Dependencies.AndroidxTest.core)
  testImplementation(Dependencies.junit)

common/src/main/java/com/google/android/fhir/MoreTypes.kt

@@ -19,6 +19,7 @@ package com.google.android.fhir
 import java.util.Calendar
 import java.util.Date
 import org.hl7.fhir.r4.model.Coding
+import org.hl7.fhir.r4.model.Quantity
 import org.hl7.fhir.r4.model.Type
 
 /**
@@ -62,6 +63,18 @@ operator fun Type.compareTo(value: Type?): Int {
  this.fhirType().equals("dateTime") -> {
  return this.dateTimeValue().value.compareTo(value.dateTimeValue().value)
  }
+ this.fhirType().equals("Quantity") -> {
+ val quantity =
+ UnitConverter.getCanonicalForm(UcumValue((this as Quantity).code, this.value))
+ val anotherQuantity =
+ UnitConverter.getCanonicalForm(UcumValue((value as Quantity).code, value.value))
+ if (quantity.code != anotherQuantity.code) {
+ throw IllegalArgumentException(
+ "Cannot compare different quantity codes: ${quantity.code} and ${anotherQuantity.code}"
+ )
+ }
+ return quantity.value.compareTo(anotherQuantity.value)
+ }
  else -> {
  throw NotImplementedError()
  }

common/src/test/java/com/google/android/fhir/MoreTypesTest.kt

@@ -19,6 +19,7 @@ package com.google.android.fhir
 import android.os.Build
 import com.google.common.truth.Truth.assertThat
 import java.util.Calendar
+import kotlin.test.assertFailsWith
 import org.hl7.fhir.r4.model.Attachment
 import org.hl7.fhir.r4.model.BooleanType
 import org.hl7.fhir.r4.model.Coding
@@ -204,4 +205,37 @@ class MoreTypesTest {
  assertThat(exception.message)
  .isEqualTo("Cannot compare different data types: decimal and integer")
  }
+
+ @Test
+ fun compareTo_quantityType_shouldReturnPositiveValue() {
+ val value = Quantity().setCode("h").setValue(10)
+ val otherValue = Quantity().setCode("h").setValue(5)
+
+ assertThat(value.compareTo(otherValue)).isEqualTo(1)
+ }
+
+ @Test
+ fun compareTo_quantityType_shouldReturnZero() {
+ val value = Quantity().setCode("h").setValue(10)
+ val otherValue = Quantity().setCode("h").setValue(10)
+
+ assertThat(value.compareTo(otherValue)).isEqualTo(0)
+ }
+
+ @Test
+ fun compareTo_quantityType_shouldReturnNegativeValue() {
+ val value = Quantity().setCode("h").setValue(10)
+ val otherValue = Quantity().setCode("h").setValue(20)
+
+ assertThat(value.compareTo(otherValue)).isEqualTo(-1)
+ }
+
+ @Test
+ fun compareTo_quantityWithDifferentCodes_shouldFail() {
+ assertFailsWith<IllegalArgumentException> {
+ val value = Quantity().setCode("h").setValue(10)
+ val otherValue = Quantity().setCode("kg").setValue(5)
+ value.compareTo(otherValue)
+ }
+ }
 }

datacapture/src/androidTest/java/com/google/android/fhir/datacapture/views/QuestionnaireItemEditTextQuantityViewHolderFactoryInstrumentedTest.kt

@@ -28,7 +28,6 @@ import com.google.android.material.textfield.TextInputEditText
 import com.google.android.material.textfield.TextInputLayout
 import com.google.common.truth.Truth.assertThat
 import java.math.BigDecimal
-import kotlin.test.assertFailsWith
 import org.hl7.fhir.r4.model.Quantity
 import org.hl7.fhir.r4.model.Questionnaire
 import org.hl7.fhir.r4.model.QuestionnaireResponse
@@ -189,34 +188,6 @@ class QuestionnaireItemEditTextQuantityViewHolderFactoryInstrumentedTest {
  assertThat(questionnaireItemViewItem.questionnaireResponseItem.answer.size).isEqualTo(0)
  }
 
- @Test
- @UiThreadTest
- fun displayValidationResult_shouldThrowNotImplementedError() {
- assertFailsWith<NotImplementedError> {
- viewHolder.bind(
- QuestionnaireItemViewItem(
- Questionnaire.QuestionnaireItemComponent().apply {
- addExtension().apply {
- url = "https://hl7.org/fhir/StructureDefinition/minValue"
- setValue(Quantity(2.2))
- }
- addExtension().apply {
- url = "https://hl7.org/fhir/StructureDefinition/maxValue"
- setValue(Quantity(4.4))
- }
- },
- QuestionnaireResponse.QuestionnaireResponseItemComponent().apply {
- addAnswer(
- QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent().apply {
- value = Quantity(3.3)
- }
- )
- }
- ) {}
- )
- }
- }
-
  @Test
  @UiThreadTest
  fun displayValidationResult_error_shouldShowErrorMessage() {

datacapture/src/main/java/com/google/android/fhir/datacapture/enablement/EnablementEvaluator.kt

@@ -16,8 +16,8 @@
 
 package com.google.android.fhir.datacapture.enablement
 
+import com.google.android.fhir.compareTo
 import com.google.android.fhir.equals
-import java.lang.IllegalStateException
 import org.hl7.fhir.r4.model.Questionnaire
 import org.hl7.fhir.r4.model.QuestionnaireResponse
 
@@ -127,6 +127,18 @@ private val Questionnaire.QuestionnaireItemEnableWhenComponent.predicate:
  Questionnaire.QuestionnaireItemOperator.NOT_EQUAL -> {
  !equals(it.value, answer)
  }
+ Questionnaire.QuestionnaireItemOperator.GREATER_THAN -> {
+ it.value > answer
+ }
+ Questionnaire.QuestionnaireItemOperator.GREATER_OR_EQUAL -> {
+ it.value >= answer
+ }
+ Questionnaire.QuestionnaireItemOperator.LESS_THAN -> {
+ it.value < answer
+ }
+ Questionnaire.QuestionnaireItemOperator.LESS_OR_EQUAL -> {
+ it.value <= answer
+ }
  else -> throw NotImplementedError("Enable when operator $operator is not implemented.")
  }
  }

datacapture/src/test/java/com/google/android/fhir/datacapture/enablement/EnablementEvaluatorTest.kt

@@ -383,6 +383,110 @@ class EnablementEvaluatorTest {
  .isFalse()
  }
 
+ @Test
+ fun evaluate_greaterThan_answersGreaterThanEnableWhenAnswer_shouldReturnTrue() {
+ evaluateEnableWhen(
+ behavior = null,
+ EnableWhen(
+ operator = Questionnaire.QuestionnaireItemOperator.GREATER_THAN,
+ expected = IntegerType(10),
+ actual = listOf(IntegerType(20))
+ )
+ )
+ .isTrue()
+ }
+
+ @Test
+ fun evaluate_greaterThan_noAnswersGreaterThanEnableWhenAnswer_shouldReturnFalse() {
+ evaluateEnableWhen(
+ behavior = null,
+ EnableWhen(
+ operator = Questionnaire.QuestionnaireItemOperator.GREATER_THAN,
+ expected = IntegerType(10),
+ actual = listOf(IntegerType(5))
+ )
+ )
+ .isFalse()
+ }
+
+ @Test
+ fun evaluate_greaterOrEqual_answersGreaterOrEqualEnableWhenAnswer_shouldReturnTrue() {
+ evaluateEnableWhen(
+ behavior = null,
+ EnableWhen(
+ operator = Questionnaire.QuestionnaireItemOperator.GREATER_OR_EQUAL,
+ expected = IntegerType(10),
+ actual = listOf(IntegerType(10))
+ )
+ )
+ .isTrue()
+ }
+
+ @Test
+ fun evaluate_greaterOrEqual_noAnswersGreaterOrEqualEnableWhenAnswer_shouldReturnFalse() {
+ evaluateEnableWhen(
+ behavior = null,
+ EnableWhen(
+ operator = Questionnaire.QuestionnaireItemOperator.GREATER_OR_EQUAL,
+ expected = IntegerType(10),
+ actual = listOf(IntegerType(5))
+ )
+ )
+ .isFalse()
+ }
+
+ @Test
+ fun evaluate_lessThan_answersLessThanEnableWhenAnswer_shouldReturnTrue() {
+ evaluateEnableWhen(
+ behavior = null,
+ EnableWhen(
+ operator = Questionnaire.QuestionnaireItemOperator.LESS_THAN,
+ expected = IntegerType(10),
+ actual = listOf(IntegerType(5))
+ )
+ )
+ .isTrue()
+ }
+
+ @Test
+ fun evaluate_lessThan_noAnswersLessThanEnableWhenAnswer_shouldReturnFalse() {
+ evaluateEnableWhen(
+ behavior = null,
+ EnableWhen(
+ operator = Questionnaire.QuestionnaireItemOperator.LESS_THAN,
+ expected = IntegerType(10),
+ actual = listOf(IntegerType(20))
+ )
+ )
+ .isFalse()
+ }
+
+ @Test
+ fun evaluate_lessOrEqual_answerLessOrEqualEnableWhenAnswer_shouldReturnTrue() {
+ evaluateEnableWhen(
+ behavior = null,
+ EnableWhen(
+ operator = Questionnaire.QuestionnaireItemOperator.LESS_OR_EQUAL,
+ expected = IntegerType(10),
+ actual = listOf(IntegerType(10))
+ )
+ )
+ .isTrue()
+ }
+
+ @Test
+ fun evaluate_lessOrEqual_noAnswerLessOrEqualEnableWhenAnswer_shouldReturnFalse() {
+ evaluateEnableWhen(
+ behavior = null,
+ EnableWhen(
+ operator = Questionnaire.QuestionnaireItemOperator.LESS_OR_EQUAL,
+ expected = IntegerType(10),
+ actual = listOf(IntegerType(20))
+ )
+ )
+ .isFalse()
+ }
+
  /**
  * Evaluates multiple `enableWhen` constraints according to the `behavior` (any or all).
  *