Test two dictionary is equal on values. (ignore order)
517039
def is_same_dict(d1, d2):
    
    for k, v in d1.items():
        if isinstance(v, dict):
            is_same_dict(v, d2[k])
        else:
            assert d1[k] == d2[k]

    for k, v in d2.items():
        if isinstance(v, dict):
            is_same_dict(v, d1[k])
        else:
            assert d1[k] == d2[k]
1197157
def indexes_equal(a: Index, b: Index) -> bool:
    
    return str(a) == str(b)
134812
private static boolean doEquals(DerValue d1, DerValue d2) {
        synchronized (d1.data) {
            synchronized (d2.data) {
                d1.data.reset();
                d2.data.reset();
                return d1.buffer.equals(d2.buffer);
            }
        }
    }
1032159
def values_are_equivalent(self, val1, val2):
        '''
        '''
        return self.get_lowest_equivalent_value(val1) == self.get_lowest_equivalent_value(val2)
576644
def Equals(self, other):
        
        if other is None:
            return False
        if other.PrevHash.ToBytes() == self.PrevHash.ToBytes() and other.PrevIndex == self.PrevIndex:
            return True
        return False
936961
def compareValues(self, a, b):
        
        values = self.values()
        try:
            return cmp(values.index(a), values.index(b))
        except ValueError:
            return cmp(a, b)
614557
def is_equal(self, other):
        
        other = self.coerce(other)
        return len(self.get_values().symmetric_difference(other.get_values())) == 0
621057
function isEqualWith (obj1, obj2, func) {
  if (isFunction(func)) {
    return equalCompare(obj1, obj2, function (v1, v2, key, obj1, obj2) {
      var result = func(v1, v2, key, obj1, obj2)
      return isUndefined(result) ? defaultCompare(v1, v2) : !!result
    }, func)
  }
  return equalCompare(obj1, obj2, defaultCompare)
}
122917
function areEqual(a,b) {
	var same = true;
	$.each(a, function(i, _) {
		if (b[i] === undefined || a[i] !== b[i]) {
			same = false;
			return false;
		}
	});
	return same;
}
956937
def equal(actual, expected):
    '''
    
    '''
    is_passing = (actual == expected)

    types_to_diff = (str, dict, list, tuple)
    if not is_passing and isinstance(expected, types_to_diff) and isinstance(actual, types_to_diff):
        readable_diff = difflib.unified_diff(pformat(expected).split('\n'),
                                             pformat(actual).split('\n'), n=99)
        description = '\n'.join(['equal:'] + list(readable_diff))
    else:
        description = "equal: expect {} == {}".format(actual, expected)
    outcome = (is_passing, description)
    return outcome
525445
public static boolean propertiesEqual(Dictionary<String, String> properties, Dictionary<String, String> dictionary)
    {
        Enumeration<String> props = properties.keys();
        while (props.hasMoreElements())
        {
            String key = props.nextElement();
            if (!properties.get(key).equals(dictionary.get(key)))
                return false;
        }
        props = dictionary.keys();
        while (props.hasMoreElements())
        {
            String key = props.nextElement();
            if (!dictionary.get(key).equals(properties.get(key)))
                return false;
        }
        return true;
    }
696139
def _eq(self, other):
        """"""
        return (self.type, self.value) == (other.type, other.value)
252804
def is_subdict(self, a,b):
        '''
        
        '''
        return all((k in b and b[k]==v) for k,v in a.iteritems())
921973
function equal(a, b) {
  if (a === b) return true

  let arrA = isArray(a)
  let arrB = isArray(b)
  let length = 0

  if (arrA && arrB) {
    length = a.length
    if (length !== b.length) return false
    for (let i = length; i-- !== 0;) { if (!equal(a[i], b[i])) return false }
    return true
  }

  if (arrA !== arrB) return false

  let dateA = a instanceof Date
  let dateB = b instanceof Date
  if (dateA !== dateB) return false
  if (dateA && dateB) return a.getTime() === b.getTime()

  let regexpA = a instanceof RegExp
  let regexpB = b instanceof RegExp
  if (regexpA !== regexpB) return false
  if (regexpA && regexpB) return a.toString() === b.toString()

  if (a instanceof Object && b instanceof Object) {
    let keys = keyList(a)
    length = keys.length

    if (length !== keyList(b).length) { return false }

    for (let i = length; i-- !== 0;) { if (!hasProp.call(b, keys[i])) return false }

    let key = ''
    for (let i = length; i-- !== 0;) {
      key = keys[i]
      if (!equal(a[key], b[key])) return false
    }

    return true
  }

  return false
}
179460
private boolean checkEquality(HashMap<String, Double> a,
			HashMap<String, Double> b) {
		for(String s: a.keySet()){
			if(Double.compare(a.get(s), b.get(s)) != 0)
				return false;
		}
		return true;
	}
1065308
def equal(list1, list2):
    
    return [item1 == item2 for item1, item2 in broadcast_zip(list1, list2)]
53068
def _assert_keys_match(keys1, keys2):
  """"""
  if set(keys1) != set(keys2):
    raise ValueError('{} {}'.format(list(keys1), list(keys2)))