docs: public static void validateValues(Object actualValue, Object expectedValue, String pathExpression, TestContext context)
              throws ValidationException {
          try {
              if (actualValue != null) {
                  Assert.isTrue(expectedValue != null,
                          ValidationUtils.buildValueMismatchErrorMessage(
                                  "Values not equal for element '" + pathExpression + "'", null, actualValue));
  
                  if (expectedValue instanceof Matcher) {
                      Assert.isTrue(((Matcher) expectedValue).matches(actualValue),
                              ValidationUtils.buildValueMismatchErrorMessage(
                                      "Values not matching for element '" + pathExpression + "'", expectedValue, actualValue));
                      return;
                  }
  
                  if (!(expectedValue instanceof String)) {
                      Object converted = TypeConversionUtils.convertIfNecessary(actualValue, expectedValue.getClass());
  
                      if (converted == null) {
                          throw new CitrusRuntimeException(String.format("Failed to convert value '%s' to required type '%s'", actualValue, expectedValue.getClass()));
                      }
  
                      if (converted instanceof List) {
                          Assert.isTrue(converted.toString().equals(expectedValue.toString()),
                                  ValidationUtils.buildValueMismatchErrorMessage(
                                          "Values not equal for element '" + pathExpression + "'", expectedValue.toString(), converted.toString()));
                      } else if (converted instanceof String[]) {
                          String convertedDelimitedString = StringUtils.arrayToCommaDelimitedString((String[]) converted);
                          String expectedDelimitedString = StringUtils.arrayToCommaDelimitedString((String[]) expectedValue);
  
                          Assert.isTrue(convertedDelimitedString.equals(expectedDelimitedString),
                                  ValidationUtils.buildValueMismatchErrorMessage(
                                          "Values not equal for element '" + pathExpression + "'", expectedDelimitedString, convertedDelimitedString));
                      } else if (converted instanceof byte[]) {
                          String convertedBase64 = Base64.encodeBase64String((byte[]) converted);
                          String expectedBase64 = Base64.encodeBase64String((byte[]) expectedValue);
  
                          Assert.isTrue(convertedBase64.equals(expectedBase64),
                                  ValidationUtils.buildValueMismatchErrorMessage(
                                          "Values not equal for element '" + pathExpression + "'", expectedBase64, convertedBase64));
                      } else {
                          Assert.isTrue(converted.equals(expectedValue),
                                  ValidationUtils.buildValueMismatchErrorMessage(
                                          "Values not equal for element '" + pathExpression + "'", expectedValue, converted));
                      }
                  } else {
                      String expectedValueString = expectedValue.toString();
                      String actualValueString;
                      if (List.class.isAssignableFrom(actualValue.getClass())) {
                          actualValueString = StringUtils.arrayToCommaDelimitedString(((List)actualValue).toArray(new Object[((List)actualValue).size()]));
                          expectedValueString = expectedValueString.replaceAll("^\\[", "").replaceAll("\\]$", "").replaceAll(",\\s", ",");
                      } else {
                          actualValueString = actualValue.toString();
                      }
  
                      if (ValidationMatcherUtils.isValidationMatcherExpression(String.valueOf(expectedValueString))) {
                          ValidationMatcherUtils.resolveValidationMatcher(pathExpression,
                                  actualValueString,
                                  String.valueOf(expectedValueString),
                                  context);
                      } else {
                          Assert.isTrue(actualValueString.equals(expectedValueString),
                                  ValidationUtils.buildValueMismatchErrorMessage(
                                          "Values not equal for element '" + pathExpression + "'", expectedValueString, actualValueString));
                      }
                  }
              } else if (expectedValue != null) {
                  if (expectedValue instanceof Matcher) {
                      Assert.isTrue(((Matcher) expectedValue).matches(null),
                              ValidationUtils.buildValueMismatchErrorMessage(
                                      "Values not matching for element '" + pathExpression + "'", expectedValue, null));
                  } else if (expectedValue instanceof String) {
                      String expectedValueString = expectedValue.toString();
  
                      if (ValidationMatcherUtils.isValidationMatcherExpression(expectedValueString)) {
                          ValidationMatcherUtils.resolveValidationMatcher(pathExpression,
                                  null,
                                  expectedValueString,
                                  context);
                      } else {
                          Assert.isTrue(!StringUtils.hasText(expectedValueString),
                                  ValidationUtils.buildValueMismatchErrorMessage(
                                          "Values not equal for element '" + pathExpression + "'", expectedValueString, null));
                      }
                  } else {
                      throw new ValidationException("Validation failed: " + ValidationUtils.buildValueMismatchErrorMessage(
                              "Values not equal for element '" + pathExpression + "'", expectedValue, null));
                  }
              }
          } catch (IllegalArgumentException | AssertionError e) {
              throw new ValidationException("Validation failed:", e);
          }
      }