docs: protected static boolean locateMatchingAttributeValue(final String attrName, final String attrValue,
                                                            final Map<String, List<Object>> attributes,
                                                            final boolean matchIfNoValueProvided) {
          LOGGER.debug("Locating matching attribute [{}] with value [{}] amongst the attribute collection [{}]", attrName, attrValue, attributes);
          if (StringUtils.isBlank(attrName)) {
              LOGGER.debug("Failed to match since attribute name is undefined");
              return false;
          }
  
          val names = attributes.entrySet()
              .stream()
              .filter(e -> {
                  LOGGER.debug("Attempting to match [{}] against [{}]", attrName, e.getKey());
                  return e.getKey().matches(attrName);
              })
              .collect(Collectors.toSet());
  
          LOGGER.debug("Found [{}] attributes relevant for multifactor authentication bypass", names.size());
  
          if (names.isEmpty()) {
              return false;
          }
  
          if (StringUtils.isBlank(attrValue)) {
              LOGGER.debug("No attribute value to match is provided; Match result is set to [{}]", matchIfNoValueProvided);
              return matchIfNoValueProvided;
          }
  
          val values = names
              .stream()
              .filter(e -> {
                  val valuesCol = CollectionUtils.toCollection(e.getValue());
                  LOGGER.debug("Matching attribute [{}] with values [{}] against [{}]", e.getKey(), valuesCol, attrValue);
                  return valuesCol
                      .stream()
                      .anyMatch(v -> v.toString().matches(attrValue));
              }).collect(Collectors.toSet());
  
          LOGGER.debug("Matching attribute values remaining are [{}]", values);
          return !values.isEmpty();
      }