Test if an object is shallowly equal.
430225
function shallowEqual(actual, expected) {
  var keys = Object.keys(expected);

  var _arr2 = keys;
  for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
    var key = _arr2[_i2];
    if (actual[key] !== expected[key]) {
      return false;
    }
  }

  return true;
}
1302703
function equal(a, b) {
        if (a === b) return true;
        if (a === undefined || b === undefined) return false;
        if (a === null || b === null) return false;
        if (a.constructor === String) return a.localeCompare(b) === 0;
        if (b.constructor === String) return b.localeCompare(a) === 0;
        return false;
    }
1103792
public static boolean equalsOne(Object _obj, Object... _arrObj) {
       if (_obj == null || _arrObj == null) {
           return false;
       }
       for (Object o : _arrObj) {
           if (o != null && _obj.equals(o)) {
               return true;
           }
       }
       return false;
   }
685353
function isComparable(object) {
	let type = typeof object;
	if (type === 'number' || type === 'string' || type == 'boolean') return true;
	if (type === 'object' && object instanceof Date) return true;
	return false;
}
1201375
function objectsAreEqual(obj1, obj2) {
  // Always search through array on array columns
  if (Array.isArray(obj1)) {
    if (Array.isArray(obj2)) {
      throw new Parse.Error(107, `You cannot use ${obj2} as a query parameter`);
    } else {
      return _.some(obj1, obj => objectsAreEqual(obj, obj2));
    }
  }

  // scalar values (including null/undefined)
  // Note: undefined equals null.
  // For all other objects, strict equality is applied
  if (obj1 === obj2 || (_.isNil(obj1) && _.isNil(obj2))) {
    return true;
  }

  // if any of those is null or undefined the other is not because
  // of above --> abort
  if (_.isNil(obj1) || _.isNil(obj2)) {
    return false;
  }

  // objects
  if (_.isEqual(obj1, obj2)) {
    return true;
  }

  // both pointers
  if (obj1.objectId !== undefined && obj1.objectId === obj2.objectId) {
    return true;
  }

  // both dates
  if (isDate(obj1) && isDate(obj2)) {
    return deserializeQueryParam(obj1) === deserializeQueryParam(obj2);
  }

  return false;
}
869212
function argumentsEqual(a, b, m) {
  if ('arguments' !== type(b)) return false;
  a = [].slice.call(a);
  b = [].slice.call(b);
  return deepEqual(a, b, m);
}
59168
private static boolean deepEquals(byte[] a, byte[] b) {
        return a == b || !(a == null || b == null) && Arrays.equals(a, b);
    }
786921
public static Boolean eq(Object left, Object right) {
        return EvalHelper.isEqual(left, right, null);
    }
1301327
private boolean unequalNotNull(Object expected, Object actual) {
        if ((XMLUnit.getIgnoreWhitespace() || XMLUnit.getNormalizeWhitespace())
            && expected instanceof String && actual instanceof String) {
            String expectedString = ((String) expected).trim();
            String actualString = ((String) actual).trim();
            if (XMLUnit.getNormalizeWhitespace()) {
                expectedString = normalizeWhitespace(expectedString);
                actualString = normalizeWhitespace(actualString);
            }
            return !expectedString.equals(actualString);
        }
        return !(expected.equals(actual));
    }
794046
function _shallowEqual(lhs, rhs) {
    var lhsKeys = Object.keys(lhs);
    var rhsKeys = Object.keys(rhs);
    if (lhsKeys.length !== rhsKeys.length) {
      return false;
    }
    for (var k in lhs) {
      if (lhs[k] !== rhs[k]) {
        return false;
      }
    }
    return true;
  }
648878
function equalType (a, b) {
  if (Array.isArray(a) && Array.isArray(b)) {
    if (0 === a.length || 0 === b.length) {
      return true;
    }

    return equalType(a[0], b[0]);
  }

  if ('null' == a || 'null' == b) {
    return true;
  }

  return a == b;
}
428585
function isequal(a, b, tolerance) {
    if (tolerance === void 0) { tolerance = constants_1.EPSILON; }
    return iszero(a - b, tolerance);
}
594635
function shallowEqualArrays(a, b) {
    if (a.length !== b.length)
        return false;
    for (var /** @type {?} */ i = 0; i < a.length; ++i) {
        if (!shallowEqual(a[i], b[i]))
            return false;
    }
    return true;
}
1106016
function shallowEqual(a, b) {
  let ret = true

  for (const key in a) {
    if (a[key] !== b[key]) {
      ret = false
      break
    }
  }

  if (ret) {
    for (const key in b) {
      if (!(key in a)) {
        ret = false
        break
      }
    }
  }

  return ret
}
320705
public static void assertNotEqual(Object a, Object b, String message) {
        if (Objects.equals(a, b)) {
            fail(message);
        }
    }
841440
def isnamedtuple(obj):
    """"""
    return isinstance(obj, tuple) \
           and hasattr(obj, "_fields") \
           and hasattr(obj, "_asdict") \
           and callable(obj._asdict)
1226163
def equal(obj1, obj2):
    """"""
    Comparable.log(obj1, obj2, '==')
    equality = obj1.equality(obj2)
    Comparable.log(obj1, obj2, '==', result=equality)
    return equality