Note that since nameExpectedValues is a map, it can only contain one expected value per name.
960961
public static void check(LinkedHashMap<String, Object> nameExpectedValues, long timeout, String failMessagePrefix)
          throws QTasteTestFailException {
        CacheValidator validator = new CacheValidator(nameExpectedValues, timeout);
        validator.validate(failMessagePrefix);
    }
814264
public void collectMarkerSpecification(VariableSpecifications boundNames)
    {
        if (collectionElement != null)
            collectionElement.collectMarkerSpecification(boundNames);

        if (operator.equals(Operator.IN) && inValues != null)
        {
            for (Term value : inValues)
                value.collectMarkerSpecification(boundNames);
        }
        else
        {
            value.collectMarkerSpecification(boundNames);
        }
    }
777396
function multiMapSet(multimap, key, value) {
  if (!multimap.has(key)) {
    multimap.set(key, new Set());
  }
  const values = multimap.get(key);
  if (!values.has(value)) {
    values.add(value);
    return true;
  }
  return false;
}
638738
private static void forSpecialValue(Map<String, Object> conditionMap) {
        conditionMap.keySet().forEach(key -> {
            Object value = conditionMap.get(key);
            if (value instanceof String) {
                conditionMap.put(key, "'".concat(value.toString()).concat("'"));
            }
            if (value instanceof Date) {
                String dateString = DateConverterFactory.getDateConverter().toStandardString((Date) value);
                conditionMap.put(key, "'".concat(dateString).concat("'"));
            }
            if (value instanceof Calendar) {
                String dateString = DateConverterFactory.getDateConverter().toStandardString((Calendar) value);
                conditionMap.put(key, "'".concat(dateString).concat("'"));
            }
            if (value instanceof Number) {
                conditionMap.put(key, value.toString());
            }
        });
    }
408412
function checkValue(typeVarMap, index, k, x) {
        var propPath = [k];
        var t = expType.types[k];
        return (
          t.type === VARIABLE ?
            Z.chain (
              function(typeVarMap) {
                return isEmpty (typeVarMap[t.name].types) ?
                  Left (function() {
                    return typeVarConstraintViolation (
                      env,
                      typeInfo,
                      index,
                      propPath,
                      typeVarMap[t.name].valuesByPath
                    );
                  }) :
                  Right (typeVarMap);
              },
              Right (updateTypeVarMap (env,
                                       typeVarMap,
                                       t,
                                       index,
                                       propPath,
                                       [x]))
            ) :
          // else
            Z.map (
              function(r) { return r.typeVarMap; },
              satisfactoryTypes (env,
                                 typeInfo,
                                 typeVarMap,
                                 t,
                                 index,
                                 propPath,
                                 [x])
            )
        );
      }
65936
public void setValuesForIn(String values, String name, Map<String, Object> map) {
        String cleanName = htmlCleaner.cleanupValue(name);
        String[] valueArrays = values.split("\\s*,\\s*");
        List<Object> valueObjects = new ArrayList<Object>(valueArrays.length);
        for (int i = 0; i < valueArrays.length; i++) {
            Object cleanValue = getCleanValue(valueArrays[i]);
            valueObjects.add(cleanValue);
        }
        setValueForIn(valueObjects, cleanName, map);
    }
1006718
public ScanSpec withValueMap(Map<String, Object> valueMap) {
        if (valueMap == null)
            this.valueMap = null;
        else
            this.valueMap = Collections.unmodifiableMap(new LinkedHashMap<String, Object>(valueMap));
        return this;
    }
441591
public static List<NameValuePair>
    buildNameValuePareList(Map<String, String> keyValueMap) {
        return keyValueMap.entrySet().stream()
                .map(entry -> new BasicNameValuePair(entry.getKey(),
                        entry.getValue()))
                .collect(toList());
    }
1279921
@SuppressWarnings("unchecked")
  public static <K, V> MultiValueMap<K, V> unmodifiableMultiValueMap(
      final MultiValueMap<? extends K, ? extends V> map) {
    Assert.notNull(map, "'map' must not be null");
    final Map<K, List<V>> result = new LinkedHashMap<>(map.size());
    map.forEach((key, value) -> {
      final List<? extends V> values = Collections.unmodifiableList(value);
      result.put(key, (List<V>) values);
    });
    final Map<K, List<V>> unmodifiableMap = Collections.unmodifiableMap(result);
    return CollectionUtils.toMultiValueMap(unmodifiableMap);
  }
1234749
public void put(String name, String... values) {
    getMap().put(name, Arrays.asList(values));
  }
825729
public void addValueTo(Object value, String name) {
        getMapHelper().addValueToIn(value, name, getCurrentValues());
    }
724076
public static void check(LinkedHashMap<String, Object> nameExpectedValues, long timeout) throws QTasteTestFailException {
        check(nameExpectedValues, timeout, null);
    }
636640
def has_value_name(self, name):
        
        for val, _ in self._values:
            if val == name:
                return True
        return False
427179
public void setValueForIn(Object value, String name, Map<String, Object> map) {
        getMapHelper().setValueForIn(value, name, map);
    }
286746
public final boolean containsAllNames(VariableNumMap other) {
    int[] otherNums = other.nums;
    String[] otherNames = other.names;

    for (int i = 0; i < otherNums.length; i++) {
      int index = getVariableIndex(otherNums[i]);
      if (index < 0 || !otherNames[i].equals(names[index])) {
        return false;
      }
    }
    return true;
  }
118477
private String value(String nameEqualsValue)
    {
        String value=nameEqualsValue.substring(nameEqualsValue.indexOf('=')+1).trim();
        int i=value.indexOf(';');
        if(i>0)
            value=value.substring(0,i);
        if(value.startsWith("\""))
        {
            value=value.substring(1,value.indexOf('"',1));
        }
        else
        {
            i=value.indexOf(' ');
            if(i>0)
                value=value.substring(0,i);
        }
        return value;
    }
943650
private LinkedHashMap<String, Num> mapValues(String infix, Object... values) {
        LinkedHashMap<String, Num> vNames = null;
        int remain = 0;
      
        Matcher mat = pVariableNames.matcher(infix);
        while (mat.find()) {
            if (vNames == null)
                vNames = new LinkedHashMap<String, Num>();

            String vName = mat.group();
            if (!vNames.containsKey(vName)) {
                remain++;
                Num num = findValue(vName, true, values);
                vNames.put(vName, num);

                if (num != null)
                    remain--;
            }
        }

        // pair names with values without name
        if (vNames != null) {
            int lastPos = 0;
            for (Entry<String, Num> entry : vNames.entrySet()) {
                if (entry.getValue() == null) {
                    for (int i = lastPos; i < values.length; i++) {
                        Object v = values[i];
                        if (v != null) {
                            if (v instanceof Num) {
                                Num n = (Num) v;
                                if (n.getName() == null)
                                    entry.setValue(n);
                                else if (n.getName().equals(entry.getValue()))
                                    entry.setValue(n);
                            }
                            else
                                entry.setValue(Num.toNum(v));

                            values[i] = null;
                            lastPos = i;
                            remain--;
                        }
                    }
                }
            }
        }

        if (remain > 0 && vNames != null) {
            StringBuilder sb = new StringBuilder();
            int c = 0;
            for (Entry<String, Num> entry : vNames.entrySet()) {
                if (entry.getValue() == null) {
                    if (c++ > 0)
                        sb.append(", ");
                    sb.append(entry.getKey());
                }
            }

            throw new CalculatorException("Undefined values for expression (" + infix + ") variables: " + sb.toString());
        }

        return vNames;
    }