Warning, this is very slow to output log, checking truthy however is
 basically as performant as an if statement

 @example

 # foo and bar are objects we want to inspect
 rmq.debug.assert(1==2, 'Bad stuff happened', {
   foo: foo,
   bar: bar
 })
775858
def assert(truthy, label = nil, objects = nil)
      if (RMQ.app.development? || RMQ.app.test?) && !truthy
        label ||= 'Assert failed'
        if block_given? && !objects
          objects = yield
        end
        log_detailed label, objects: objects, skip_first_caller: true
      end
    end
395603
public void assertEquals(Object expected, Object actual) {
    if (expected == null && actual == null)
      return;
    if (expected != null && expected.equals(actual))
      return;
    fail(format(expected, actual));
  }
259375
function isFalsy(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && value) {
        throw LogicException.throw(assertionTypes.IS_FALSY, value, message, id);
    }
}
1172704
function isNotFalse(value, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && value === false) {
        throw ValueException.expectedValue(assertionTypes.IS_NOT_FALSE, value, false, message, id);
    }
}
192858
def __assert_false(returned):
        '''
        
        '''
        result = "Pass"
        if isinstance(returned, str):
            try:
                returned = bool(returned)
            except ValueError:
                raise
        try:
            assert (returned is False), "{0} not False".format(returned)
        except AssertionError as err:
            result = "Fail: " + six.text_type(err)
        return result
472223
function isDebug(debugging) {
    // If manually passed just return.
    if (isValue(debugging))
        return debugging;
    var eargv = process && process.execArgv;
    function chkDebug() {
        return (eargv.filter(function (v) { return /^(--debug|--inspect)/.test(v); }).length ||
            isValue(v8debug));
    }
    return function_1.tryWrap(chkDebug)(false);
}
244863
def check(target, ruleset, ruleset_file, debug, json, stat, skip, tag, verbose,
          checks_paths, target_type, timeout, pull, insecure):
    
    if ruleset and ruleset_file:
        raise click.BadOptionUsage(
            "Options '--ruleset' and '--file-ruleset' cannot be used together.")

    if json and not os.path.isdir(os.path.dirname(os.path.realpath(json.name))):
        raise click.BadOptionUsage(
            "Parent directory for the json output file does not exist.")

    try:
        if not debug:
            logging.basicConfig(stream=six.StringIO())

        log_level = _get_log_level(debug=debug,
                                   verbose=verbose)
        results = run(
            target=target,
            ruleset_name=ruleset,
            ruleset_file=ruleset_file,
            logging_level=log_level,
            tags=tag,
            pull=pull,
            checks_paths=checks_paths,
            target_type=target_type,
            timeout=timeout,
            insecure=insecure,
            skips=skip
        )
        _print_results(results=results, stat=stat, verbose=verbose)

        if json:
            results.save_json_to_file(file=json)

        if not results.ok:
            sys.exit(1)
        elif results.fail:
            sys.exit(3)

    except ColinException as ex:
        logger.error("An error occurred: %r", ex)
        if debug:
            raise
        else:
            raise click.ClickException(str(ex))
    except Exception as ex:
        logger.error("An error occurred: %r", ex)
        if debug:
            raise
        else:
            raise click.ClickException(str(ex))
1303807
boolean handlePropertyHits(BackedSession d2, Thread t, int len) {
        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_WAS.entering(methodClassName, methodNames[HANDLE_PROPERTY_HITS]);
        }

        Enumeration vEnum = null;
        boolean doWrite = false;

        Connection conn = null;
        String id = d2.getId();
        String propid = null;
        PreparedStatement batchUpdatePS = null;
        PreparedStatement batchInsertPS = null;
        PreparedStatement batchDeletePS = null;
        LinkedList<DatabaseMRHelper> insertBatch = new LinkedList<DatabaseMRHelper>();

        boolean updateClose = false;
        boolean insertClose = false;
        boolean delClose = false;

        conn = getConnection(false);
        if (conn == null) {
            return true;
        }
        if (!multirowInitialized) {
            try {
                initMultirowDBTypes(conn);
            } catch (SQLException e) {
                if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled()&&LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                    LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "problem getting types", e); //PM99783
                }
                if (conn != null)
                    closeConnection(conn);
                return false;
            }
        }

        try {
            // we are not synchronized here - were not in old code either
            Hashtable sht = null;
            if (_smc.writeAllProperties()) {
                Hashtable ht = (Hashtable) d2.getSwappableData();
                vEnum = ht.keys();
                doWrite = true;
                if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                    LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "doing app changes for ALL mSwappable Data " + ht.toString());
                }
            } else {
                if (d2.appDataChanges != null) {
                    if (appDataTablesPerThread) {
                        if ((sht = (Hashtable) d2.appDataChanges.get(t)) != null) {
                            doWrite = true;
                            if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                                LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "doing app changes for " + id + " on thread "
                                                                                                                                    + t);
                            }
                            if (sht != null) {
                                vEnum = sht.keys();
                            } else {
                                vEnum = (new Hashtable()).keys();
                            }
                        }
                    } else { // appDataTablesPerSession
                        doWrite = true;
                        vEnum = d2.appDataChanges.keys();
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "doing app changes for TimeBasedWrite");
                        }
                    }
                }

            }

            if (doWrite) {
                int enumCount = 0;
                batchUpdatePS = conn.prepareStatement(upAnyProp);
                while (vEnum.hasMoreElements()) {
                    enumCount++;
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "enumCount is now " + enumCount);
                    }
                    long startTime = System.currentTimeMillis();
                    //*start *dbc2.2

                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "about to do vEnum.nextElement");
                    }

                    propid = (String) vEnum.nextElement();
                    if (id.equals(propid)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.WARNING, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "DatabaseHashMapMR.AttributeEqualsSessionIdWarning",
                                                            propid);
                        continue;
                    } else {
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "it worked and the propid is: " + propid);
                        }
                    }

                    ByteArrayOutputStream baos = new ByteArrayOutputStream();

                    ObjectOutputStream oos = createObjectOutputStream(baos);
                    oos.writeObject(d2.getSwappableData().get(propid));
                    oos.flush();

                    int size = baos.size();
                    byte[] objbuf = baos.toByteArray();
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "size for " + propid + " is " + size);
                    }

                    oos.close();
                    baos.close();

                    int rowsRet = 0;

                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "before update " + propid + " for session " + id);
                    }

                    // based on the amount of data, we choose whether to go to the
                    // small, medium, or large columns (nulling out whatever is
                    // in the other columns).  We first attempt an update.  If a
                    // row count > 0 is returned, we are done.  Otherwise, the
                    // row does not yet exist so we insert.

                    if (size <= smallColSize) {
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "storing in small which can handle up to "
                                                                                                                                + smallColSize + " bytes");
                        }

                        if (!usingInformix) {
                            batchUpdatePS.setBytes(1, objbuf);
                            batchUpdatePS.setNull(2, mediumPropType);
                            batchUpdatePS.setNull(3, largePropType);
                        } else {
                            ByteArrayInputStream bis = new ByteArrayInputStream(objbuf);
                            batchUpdatePS.setBinaryStream(1, bis, objbuf.length);
                            batchUpdatePS.setNull(2, mediumPropType);
                            batchUpdatePS.setNull(3, largePropType);
                        }
                        batchUpdatePS.setString(4, id);
                        batchUpdatePS.setString(5, propid);
                        batchUpdatePS.setString(6, getAppName());
                        batchUpdatePS.addBatch();
                        //in case we need to do an insert on this afterwards
                        //<string, string, byte[]>
                        DatabaseMRHelper helper = new DatabaseMRHelper();
                        helper.setId(id);
                        helper.setPropId(propid);
                        helper.setObject(objbuf);
                        if (usingInformix) {
                            helper.setUseStream(true);
                        }
                        helper.setAppName(getAppName());
                        helper.setSize(DatabaseMRHelper.SMALL);
                        insertBatch.add(helper);

                        // note, the old value in the medium column is left alone
                        // since further access when look at the small column first
                    } else if (size <= mediumColSize) {
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "storing in medium which can handle up to "
                                                                                                                                + mediumColSize + " bytes");
                        }

                        if ((!usingInformix) && (!_smc.isUseOracleBlob())) {
                            batchUpdatePS.setNull(1, smallPropType);
                            batchUpdatePS.setBytes(2, objbuf);
                            batchUpdatePS.setNull(3, largePropType);
                        } else {
                            ByteArrayInputStream bis = new ByteArrayInputStream(objbuf);
                            batchUpdatePS.setNull(1, smallPropType);
                            batchUpdatePS.setBinaryStream(2, bis, objbuf.length);
                            batchUpdatePS.setNull(3, largePropType);
                        }
                        batchUpdatePS.setString(4, id);
                        batchUpdatePS.setString(5, propid);
                        batchUpdatePS.setString(6, getAppName());

                        batchUpdatePS.addBatch();
                        DatabaseMRHelper helper = new DatabaseMRHelper();
                        helper.setId(id);
                        helper.setPropId(propid);
                        helper.setObject(objbuf);
                        if (usingInformix || _smc.isUseOracleBlob()) {
                            helper.setUseStream(true);
                        }
                        helper.setAppName(getAppName());
                        helper.setSize(DatabaseMRHelper.MEDIUM);
                        insertBatch.add(helper);
                    } else if (size <= largeColSize) {
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "storing in large which can handle up to "
                                                                                                                                + largeColSize + " bytes");
                        }
                        // note, the old value in the largecolumn is left alone
                        // since further access will look at the small column and then the
                        // medium column prior to the large column

                        if (!usingInformix) {
                            batchUpdatePS.setNull(1, smallPropType);
                            batchUpdatePS.setNull(2, mediumPropType);
                            batchUpdatePS.setBytes(3, objbuf);
                        } else {
                            ByteArrayInputStream bis = new ByteArrayInputStream(objbuf);
                            batchUpdatePS.setNull(1, smallPropType);
                            batchUpdatePS.setNull(2, mediumPropType);
                            batchUpdatePS.setBinaryStream(3, bis, objbuf.length);
                        }
                        batchUpdatePS.setString(4, id);
                        batchUpdatePS.setString(5, propid);
                        batchUpdatePS.setString(6, getAppName());

                        batchUpdatePS.addBatch();

                        DatabaseMRHelper helper = new DatabaseMRHelper();
                        helper.setId(id);
                        helper.setPropId(propid);
                        helper.setObject(objbuf);
                        if (usingInformix) {
                            //ByteArrayInputStream bis = new ByteArrayInputStream(objbuf);
                            //inssps.setBinaryStream(3, bis, objbuf.length);
                            helper.setUseStream(true);
                        }
                        helper.setAppName(getAppName());
                        helper.setSize(DatabaseMRHelper.LARGE);
                        insertBatch.add(helper);
                    } else { // too big 325643
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.SEVERE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "DatabaseHashMapMR.db2LongVarCharErr");
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.SEVERE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "DatabaseHashMapMR.propertyTooBig", propid);
                    }

                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "after commit " + propid + " for session " + id);
                    }
                    SessionStatistics pmiStats = _iStore.getSessionStatistics();
                    if (pmiStats != null) {
                        pmiStats.writeTimes(objbuf.length, System.currentTimeMillis() - startTime);
                    }

                }
                int updateCount = 0; //PM99783
                int[] results = null;
                if (enumCount>0) {
                    results = batchUpdatePS.executeBatch();
                    if (usingOracle) { //PM99783 when on Oracle DB, executeBatch() returns -2 (SUCCESS_NO_INFO), might be related to BatchPerformanceWorkaround Oracle property, hence we getUpdateCount instead
                        updateCount = batchUpdatePS.getUpdateCount();
                    }
                } else {
                    results = new int[0]; //skip trying to insert
                }
                batchUpdatePS.close();
                updateClose=true;
                if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                    LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "after " + results.length + " batch update(s), total update count : " + updateCount);
                }
                boolean needToInsert = false;
                int batchInsertPSCount = results.length;
                // PI53220 Oracle 11 returns -2 (SUCCESS_NO_INFO); PI57327 Oracle 12 returns successful results.
                if (results[0] == java.sql.Statement.SUCCESS_NO_INFO && updateCount > 0 && (_smc.writeAllProperties() || batchInsertPSCount == updateCount))
                {
                    batchInsertPSCount = batchInsertPSCount - updateCount; // Oracle only : when Write All option or no insert cases
                }
                for (int i=0;i<batchInsertPSCount;i++) {
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "For batch # " + (i+1) + ", update result : " + results[i]);
                    }
                    if (results[i]<=0) { //no rows updated (PM99783)
                        if (!needToInsert) {
                            needToInsert = true;
                            batchInsertPS = conn.prepareStatement(insAnyProp);
                        }
                        DatabaseMRHelper updateRow = insertBatch.get(i);
                        batchInsertPS.setString(1, updateRow.getId());
                        batchInsertPS.setString(2, updateRow.getPropId());
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "Insert attribute " + updateRow.getPropId());
                        }
                        switch (updateRow.getSize()) {
                        case DatabaseMRHelper.SMALL:
                            if (!updateRow.isUseStream()) {
                                batchInsertPS.setBytes(3, updateRow.getObject());
                                batchInsertPS.setNull(4, mediumPropType);
                                batchInsertPS.setNull(5, largePropType);
                            } else {
                                byte[] objbuf = updateRow.getObject();
                                ByteArrayInputStream bis = new ByteArrayInputStream(objbuf);
                                batchInsertPS.setBinaryStream(3, bis, objbuf.length);
                                batchInsertPS.setNull(4, mediumPropType);
                                batchInsertPS.setNull(5, largePropType);
                            }
                            break;
                        case DatabaseMRHelper.MEDIUM:
                            if (!updateRow.isUseStream()) {
                                batchInsertPS.setNull(3, smallPropType);
                                batchInsertPS.setBytes(4, updateRow.getObject());
                                batchInsertPS.setNull(5, largePropType);
                            } else {
                                byte[] objbuf = updateRow.getObject();
                                ByteArrayInputStream bis = new ByteArrayInputStream(objbuf);
                                batchInsertPS.setNull(3, smallPropType);
                                batchInsertPS.setBinaryStream(4, bis, objbuf.length);
                                batchInsertPS.setNull(5, largePropType);
                            }
                            break;
                        case DatabaseMRHelper.LARGE:
                            if (!updateRow.isUseStream()) {
                                batchInsertPS.setNull(3, smallPropType);
                                batchInsertPS.setNull(4, mediumPropType);
                                batchInsertPS.setBytes(5, updateRow.getObject());
                            } else {
                                byte[] objbuf = updateRow.getObject();
                                ByteArrayInputStream bis = new ByteArrayInputStream(objbuf);
                                batchInsertPS.setNull(3, smallPropType);
                                batchInsertPS.setNull(4, mediumPropType);
                                batchInsertPS.setBinaryStream(5, bis, objbuf.length);
                            }
                            break;
                        default:
                            break;
                        }

                        batchInsertPS.setString(6, updateRow.getAppName());
                        batchInsertPS.addBatch();
                    }
                }
                //try inserts
                results = new int[0];
                if (needToInsert) {
                    try {
                        results = batchInsertPS.executeBatch();
                    } catch (java.sql.BatchUpdateException e) {
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "Continue insert due to BatchPerformanceWorkaround enabled");
                        }
                    }
                    batchInsertPS.close();
                    insertClose=true;
                }
                if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled()&&LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                    int problemCntr = 0;
                    for (int i:results) {
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "Insert result : " + i);
                        }
                        if (usingOracle && i == java.sql.Statement.SUCCESS_NO_INFO) { //PM99783
                            //Oracle executeBatch() returns -2 (SUCCESS_NO_INFO)
                        }
                        else if (i < 0) {
                            problemCntr++;
                        }
                    }
                    if (problemCntr>0) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "Problem updating/creating "+ problemCntr + " attributes");
                    }
                }
                if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                    LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "Exitting Loop ... all properties writes are done");
                }
                if (appDataTablesPerThread) {
                    if (d2.appDataChanges != null)
                        d2.appDataChanges.remove(t);
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "remove thread from appDataChanges for thread: " + t);
                    }
                } else { //appDataTablesPerSession
                    if (d2.appDataChanges != null)
                        d2.appDataChanges.clear();
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "clearing appDataChanges");
                    }
                }
            }

            // see if any properties were REMOVED.
            // if so, process them

            Enumeration vEnum2 = null;

            if (d2.appDataRemovals != null) {
                if (!appDataTablesPerThread) { // appDataTablesPerSession
                    vEnum2 = d2.appDataRemovals.keys();
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "doing app removals for " + id + " on ALL threads");
                    }
                } else { //appDataTablesPerThread
                    if ((sht = (Hashtable) d2.appDataRemovals.get(t)) != null) {
                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "doing app removals for " + id + " on thread " + t);
                        }
                        if (sht != null) {
                            vEnum2 = sht.keys();
                        } else {
                            vEnum2 = (new Hashtable()).keys();
                        }
                    }
                }

                if (vEnum2 != null && vEnum2.hasMoreElements()) {
                    batchDeletePS = conn.prepareStatement(delProp);
                    while (vEnum2.hasMoreElements()) {
                        propid = (String) vEnum2.nextElement();
                        if (id.equals(propid)) {
                            //since the attribute was never stored on the database, this will do nothing.
                            //We don't even need a warning because they're removing it.
                            continue;
                        } else {
                            if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                                LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "deleting prop " + propid + " for session "
                                                                                                                                    + id);
                            }
                        }
                        batchDeletePS.setString(1, id);
                        batchDeletePS.setString(2, propid);
                        batchDeletePS.setString(3, getAppName()); //*dbc2.2
                        batchDeletePS.addBatch();

                        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "after remove, before commit " + propid
                                                                                                                                + " for session " + id);
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "after commit " + propid + " for session " + id);
                        }
                    }
                    int results[] = batchDeletePS.executeBatch();
                    batchDeletePS.close();
                    delClose = true;
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled()&&LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        int problemCntr = 0;
                        for (int i:results) {
                            if (i<=0) {
                                problemCntr++;
                            }
                        }
                        if (problemCntr>0) {
                            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "There was a problem deleting " + problemCntr + " rows");
                        }
                    }
                }

                if (!appDataTablesPerThread) { // appDataTablesPerSession
                    if (d2.appDataRemovals != null)
                        d2.appDataRemovals.clear();
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "clearing appDataRemovals");
                    }
                } else { //appDataTablesPerThread
                    if (d2.appDataRemovals != null)
                        d2.appDataRemovals.remove(t);
                    if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
                        LoggingUtil.SESSION_LOGGER_WAS.logp(Level.FINE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "remove thread from appDataRemovals: " + t);
                    }
                }
            }
        } catch (SQLException se) {
            //            if (isStaleConnectionException(se)) {
            //                com.ibm.ws.ffdc.FFDCFilter.processException(se, "com.ibm.ws.session.store.db.DatabaseHashMapMR.handlePropertyHits", "422", d2);
            //                LoggingUtil.SESSION_LOGGER_WAS.logp(Level.SEVERE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "StaleConnectionException");
            //            } else {
            com.ibm.ws.ffdc.FFDCFilter.processException(se, "com.ibm.ws.session.store.db.DatabaseHashMapMR.handlePropertyHits", "428", d2);
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.SEVERE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "DatabaseHashMapMR.propHitErr");
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.SEVERE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "CommonMessage.exception", se);
            //            }
        } catch (Exception ee) {
            com.ibm.ws.ffdc.FFDCFilter.processException(ee, "com.ibm.ws.session.store.db.DatabaseHashMapMR.handlePropertyHits", "444", d2);
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.SEVERE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "DatabaseHashMapMR.propHitErr");
            LoggingUtil.SESSION_LOGGER_WAS.logp(Level.SEVERE, methodClassName, methodNames[HANDLE_PROPERTY_HITS], "CommonMessage.exception", ee);
        } finally {
            if (!updateClose && batchUpdatePS!=null) {
                closeStatement(batchUpdatePS);
            }
            if (!insertClose && batchInsertPS!=null) {
                closeStatement(batchInsertPS);
            }
            if (!delClose && batchDeletePS != null) {
                closeStatement(batchDeletePS);
            }
            if (conn != null) {
                closeConnection(conn);
            }
        }
        if (com.ibm.websphere.ras.TraceComponent.isAnyTracingEnabled() && LoggingUtil.SESSION_LOGGER_WAS.isLoggable(Level.FINE)) {
            LoggingUtil.SESSION_LOGGER_WAS.exiting(methodClassName, methodNames[HANDLE_PROPERTY_HITS], Boolean.valueOf(true));
        }
        return true; // 325643
    }
126655
function () {
      var args = [], len = arguments.length;
      while ( len-- ) args[ len ] = arguments[ len ];

      if (!settings$2.debug) {
        return;
      }
      args.unshift('DEBUG');
      settings$2.logger.output.apply(null, args);
    }
116154
public static Boolean assertFalse(Boolean value, String message) {
        if (Boolean.valueOf(value))
            throw new IllegalArgumentException(message);
        return value;
    }
1329082
function assertEqualsDelta(msg, expected, actual, epsilon) {
	var args = this.argsWithOptionalMsg_(arguments, 4);
	jstestdriver.assertCount++;
	msg = args[0];
	expected = args[1];
	actual = args[2];
	epsilon = args[3];

	if (!compareDelta_(expected, actual, epsilon)) {
		this.fail(msg + 'expected ' + epsilon + ' within ' +
							this.prettyPrintEntity_(expected) +
							' but was ' + this.prettyPrintEntity_(actual) + '');
	}
	return true;
}
1028423
public static void assertEquals(Object expected, Object actual) {
        assertEquals(expected, actual, "Expected value " + expected + " but got " + actual);
    }
822989
function debug(name) {
  function disabled(){}
  disabled.enabled = false;

  var match = skips.some(function(re){
    return re.test(name);
  });

  if (match) return disabled;

  match = names.some(function(re){
    return re.test(name);
  });

  if (!match) return disabled;

  function logger(msg) {
    msg = (msg instanceof Error) ? (msg.stack || msg.message) : msg;
    Function.prototype.apply.call(logger.log, this, arguments);
  }

  logger.log = exports.log;
  logger.enabled = true;

  return logger;
}
1352899
def debug
    return unless @debug
    message = Thread.current.to_s + ' ' + yield
    if defined?(Syslog) and Syslog.opened?
      Syslog.debug(message)
    else
      STDERR << 'syncache: ' + message + "\n"
      STDERR.flush
    end
  end
219206
def debug_object(obj, log_level: int = logging.DEBUG) -> None:
    
    msgs = ["For {o!r}:".format(o=obj)]
    for attrname in dir(obj):
        attribute = getattr(obj, attrname)
        msgs.append("- {an!r}: {at!r}, of type {t!r}".format(
            an=attrname, at=attribute, t=type(attribute)))
    log.log(log_level, "{}", "\n".join(msgs))
115137
public static void assertTrue(String message, boolean value) {
        if (value) {
            pass(message);
        } else {
            fail(message, null);
        }
    }
1319380
def _assertion(self, assertion, verified=False):
        

        if not hasattr(assertion, 'signature') or not assertion.signature:
            logger.debug("unsigned")
            if self.require_signature:
                raise SignatureError("Signature missing for assertion")
        else:
            logger.debug("signed")
            if not verified and self.do_not_verify is False:
                try:
                    self.sec.check_signature(assertion, class_name(assertion),
                                             self.xmlstr)
                except Exception as exc:
                    logger.error("correctly_signed_response: %s", exc)
                    raise

        self.assertion = assertion
        logger.debug("assertion context: %s", self.context)
        logger.debug("assertion keys: %s", assertion.keyswv())
        logger.debug("outstanding_queries: %s", self.outstanding_queries)

        # if self.context == "AuthnReq" or self.context == "AttrQuery":
        if self.context == "AuthnReq":
            self.authn_statement_ok()
        # elif self.context == "AttrQuery":
        #            self.authn_statement_ok(True)

        if not self.condition_ok():
            raise VerificationError("Condition not OK")

        logger.debug("--- Getting Identity ---")

        # if self.context == "AuthnReq" or self.context == "AttrQuery":
        #    self.ava = self.get_identity()
        #    logger.debug("--- AVA: %s", self.ava)

        try:
            self.get_subject()
            if self.asynchop:
                if self.allow_unsolicited:
                    pass
                elif self.came_from is None:
                    raise VerificationError("Came from")
            return True
        except Exception:
            logger.exception("get subject")
            raise