private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config, String logFile) { RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>(); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN); encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext())); appender.setEncoder(encoder); config.start(encoder); appender.setFile(logFile); FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy(); rollingPolicy.setFileNamePattern(logFile + ".%i"); appender.setRollingPolicy(rollingPolicy); rollingPolicy.setParent(appender); config.start(rollingPolicy); SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>(); triggeringPolicy.setMaxFileSize("10MB"); appender.setTriggeringPolicy(triggeringPolicy); config.start(triggeringPolicy); config.appender("FILE", appender); return appender; }
public static void startLogback() { long startTime = System.nanoTime(); Config config = Configs.DEFAULT.logging(); LogbackConfig logbackConfig = getLogbackConfig(config); LogbackManager logbackMgr = LogbackManager.INSTANCE; RollingFileAppender<ILoggingEvent> fileAppender = logbackMgr.createRollingFileAppender(logbackConfig); ConsoleAppender<ILoggingEvent> consoleAppender = logbackMgr .createConsoleAppender(APPENDER_CONSOLE, config.getString(KEY_LOG_PATTERN_CONSOLE)); List<Appender<ILoggingEvent>> appenderList = new ArrayList<>(); appenderList.add(consoleAppender); appenderList.add(fileAppender); logbackMgr.getAppenders().addAll(appenderList); LoggerContext context = logbackMgr.getLoggerContext(); initRootLogger(context, consoleAppender, config); addLoggers(config, appenderList); addAsyncAppender(config, fileAppender); context.start(); context.getLogger(LogbackInitializer.class).info(INIT_MSG, elapsedMillis(startTime)); }
public static final MetasfreshFileLoggerHelper get(final LoggerContext context) { final Logger rootLogger = context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME); final Appender<ILoggingEvent> appender = rootLogger.getAppender(FILEAPPENDER_NAME); if (!(appender instanceof RollingFileAppender)) { return NULL; } final RollingFileAppender<?> rollingFileAppender = (RollingFileAppender<?>)appender; final RollingPolicy rollingPolicy = rollingFileAppender.getRollingPolicy(); if (!(rollingPolicy instanceof MetasfreshTimeBasedRollingPolicy)) { return NULL; } final MetasfreshTimeBasedRollingPolicy<?> metasfreshRollingPolicy = (MetasfreshTimeBasedRollingPolicy<?>)rollingPolicy; return new MetasfreshFileLoggerHelper(rollingFileAppender, metasfreshRollingPolicy); }
public Logger getLogger() { LoggerContext context = (LoggerContext)LoggerFactory.getILoggerFactory(); Logger rootLogger = context.getLogger("ROOT"); rootLogger.detachAppender("console"); // Just a simple pattern for outputting the messages, includes the ISO8601 formatted timestamp and marker. PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(context); encoder.setPattern("%msg"); encoder.start(); RollingFileAppender appender = new RollingFileAppender<>(); appender.setContext(context); appender.setRollingPolicy(new ExternalRotateRollingPolicy()); appender.getRollingPolicy().setParent(appender); appender.setFile(new File(folder.getRoot(), "log").getAbsolutePath()); appender.setEncoder(encoder); appender.start(); rootLogger.addAppender(appender); context.start(); return rootLogger; }
protected Appender buildAppender(String name, String fileName, String pattern) { RollingFileAppender appender = new RollingFileAppender(); appender.setContext(loggerContext); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setContext(loggerContext); rolling.setParent(appender); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd}"); rolling.start(); appender.setRollingPolicy(rolling); PatternLayoutEncoder layout = new PatternLayoutEncoder(); layout.setContext(loggerContext); layout.setPattern(pattern); layout.setCharset(Charset.forName(getEncoding())); layout.start(); appender.setEncoder(layout); // 启动 appender.start(); return appender; }
protected Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) { RollingFileAppender appender = new RollingFileAppender(); appender.setContext(loggerContext); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setContext(loggerContext); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd-HH}"); rolling.setMaxHistory(maxBackupIndex); rolling.setParent(appender); rolling.start(); appender.setRollingPolicy(rolling); PatternLayoutEncoder layout = new PatternLayoutEncoder(); layout.setContext(loggerContext); layout.setPattern(pattern); layout.setCharset(Charset.forName(getEncoding())); layout.start(); appender.setEncoder(layout); // 启动 appender.start(); return appender; }
protected Appender buildAppender(String name, String fileName, String pattern) { RollingFileAppender appender = new RollingFileAppender(); appender.setContext(loggerContext); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setParent(appender); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd}"); rolling.setContext(loggerContext); rolling.start(); appender.setRollingPolicy(rolling); PatternLayout layout = new PatternLayout(); layout.setPattern(pattern); layout.setContext(loggerContext); layout.start(); appender.setLayout(layout); // 启动 appender.start(); return appender; }
protected Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) { RollingFileAppender appender = new RollingFileAppender(); appender.setContext(loggerContext); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setContext(loggerContext); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd-HH}"); rolling.setMaxHistory(maxBackupIndex); rolling.setParent(appender); rolling.start(); appender.setRollingPolicy(rolling); PatternLayout layout = new PatternLayout(); layout.setContext(loggerContext); layout.setPattern(pattern); layout.start(); appender.setLayout(layout); // 启动 appender.start(); return appender; }
private Appender buildAppender(String name, String fileName, String pattern) { RollingFileAppender appender = new RollingFileAppender(); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setParent(appender); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd}"); appender.setRollingPolicy(rolling); PatternLayoutEncoder layout = new PatternLayoutEncoder(); layout.setPattern(pattern); layout.setCharset(Charset.forName(getEncoding())); appender.setEncoder(layout); // 启动 appender.start(); return appender; }
private Appender buildDailyMaxRollingAppender(String name, String fileName, String pattern, int maxBackupIndex) { RollingFileAppender appender = new RollingFileAppender(); appender.setName(name); appender.setAppend(true); appender.setFile(new File(getLogPath(), fileName).getAbsolutePath()); TimeBasedRollingPolicy rolling = new TimeBasedRollingPolicy(); rolling.setFileNamePattern(new File(getLogPath(), fileName).getAbsolutePath() + ".%d{yyyy-MM-dd-HH}"); rolling.setMaxHistory(maxBackupIndex); rolling.setParent(appender); appender.setRollingPolicy(rolling); PatternLayoutEncoder layout = new PatternLayoutEncoder(); layout.setPattern(pattern); layout.setCharset(Charset.forName(getEncoding())); appender.setEncoder(layout); // 启动 appender.start(); return appender; }
protected FileAppender<ILoggingEvent> createRollingFileAppender(Encoder<ILoggingEvent> encoder, LoggerContext context, RollingPolicyFactory rollingPolicy) { RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<>(); appender.setFile(file); appender.setContext(context); appender.setEncoder(encoder); // Setup rolling policy RollingPolicy policy = rollingPolicy.createRollingPolicy(context); appender.setRollingPolicy(policy); policy.setParent(appender); // Setup triggering policy TriggeringPolicy<ILoggingEvent> triggeringPolicy = rollingPolicy.createTriggeringPolicy(context); if (triggeringPolicy != null) { appender.setTriggeringPolicy(triggeringPolicy); triggeringPolicy.start(); } policy.start(); appender.start(); return appender; }
@Before public void setUp() { MockitoAnnotations.initMocks(this); final RollingFileAppender<LoggingEvent> fileAppender = new RollingFileAppender<>(); fileAppender.setFile("application.log"); final TimeBasedRollingPolicy<LoggingEvent> rollingPolicy = new TimeBasedRollingPolicy<>(); _context = new LoggerContext(); _triggeringPolicy = new SizeAndRandomizedTimeBasedFNATP<>(_wrappedPolicy); rollingPolicy.setContext(_context); rollingPolicy.setFileNamePattern("application-%d{yyyy-MM-dd_HH}.log"); rollingPolicy.setParent(fileAppender); rollingPolicy.setTimeBasedFileNamingAndTriggeringPolicy(_triggeringPolicy); rollingPolicy.start(); }
public static void addFileAppender(String name, String logPattern, String filePath, int maxHistory) { RollingFileAppender<ILoggingEvent> fileAppender = new RollingFileAppender<ILoggingEvent>(); fileAppender.setFile(filePath); fileAppender.setEncoder(getPatternLayoutEncoder(logPattern)); fileAppender.setContext(loggerContext); fileAppender.setName(name); fileAppender.setAppend(true); // time based rolling policy TimeBasedRollingPolicy<ILoggingEvent> logFilePolicy = new TimeBasedRollingPolicy<>(); logFilePolicy.setContext(loggerContext); logFilePolicy.setParent(fileAppender); logFilePolicy.setFileNamePattern(getDateBasedFileName(filePath)); logFilePolicy.setMaxHistory(50); logFilePolicy.start(); fileAppender.setRollingPolicy(logFilePolicy); fileAppender.start(); registeredAppenders.put(name, fileAppender); }
private FileAppender<ILoggingEvent> getAppender(String pluginId) { File pluginLogFileLocation = pluginLogFile(pluginId); RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<>(); rollingFileAppender.setEncoder(LogHelper.encoder()); rollingFileAppender.setContext(LogHelper.LOGGER_CONTEXT); rollingFileAppender.setFile(pluginLogFileLocation.getPath()); rollingFileAppender.setName(rollingFileAppenderName(pluginId)); LogHelper.rollingPolicyForAppender( rollingFileAppender, "5 MB", "20 MB", 7 ); rollingFileAppender.start(); return rollingFileAppender; }
private RollingFileAppender<ILoggingEvent> rollingAppender(String file) throws IOException { RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<>(); rollingFileAppender.setEncoder(LogHelper.encoder("%date{ISO8601} - %msg%n")); rollingFileAppender.setContext(LogHelper.LOGGER_CONTEXT); rollingFileAppender.setFile(getEffectiveLogDirectory(file)); rollingFileAppender.setName(UUID.randomUUID().toString()); LogHelper.rollingPolicyForAppender( rollingFileAppender, "5 MB", "20 MB", 4 ); rollingFileAppender.start(); return rollingFileAppender; }
private static OutputStreamAppender<ILoggingEvent> configureFileLogging(File logFile, LoggerContext loggerContext) { RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<ILoggingEvent>(); rollingFileAppender.setFile(logFile.getAbsolutePath()); rollingFileAppender.setName("com.documents4j.logger.client.file"); rollingFileAppender.setContext(loggerContext); FixedWindowRollingPolicy fixedWindowRollingPolicy = new FixedWindowRollingPolicy(); fixedWindowRollingPolicy.setFileNamePattern(logFile.getAbsolutePath() + ".%i.gz"); fixedWindowRollingPolicy.setMaxIndex(LogDescription.MAXIMUM_LOG_HISTORY_INDEX); fixedWindowRollingPolicy.setContext(loggerContext); fixedWindowRollingPolicy.setParent(rollingFileAppender); SizeBasedTriggeringPolicy<ILoggingEvent> sizeBasedTriggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>(); sizeBasedTriggeringPolicy.setMaxFileSize(LogDescription.MAXIMUM_LOG_FILE_SIZE); sizeBasedTriggeringPolicy.setContext(loggerContext); rollingFileAppender.setRollingPolicy(fixedWindowRollingPolicy); rollingFileAppender.setTriggeringPolicy(sizeBasedTriggeringPolicy); sizeBasedTriggeringPolicy.start(); fixedWindowRollingPolicy.start(); System.out.println("Logging: The log is written to " + logFile); return rollingFileAppender; }
private static OutputStreamAppender<ILoggingEvent> configureFileLogging(File logFile, LoggerContext loggerContext) { RollingFileAppender<ILoggingEvent> rollingFileAppender = new RollingFileAppender<ILoggingEvent>(); rollingFileAppender.setFile(logFile.getAbsolutePath()); rollingFileAppender.setName("com.documents4j.logger.server.file"); rollingFileAppender.setContext(loggerContext); FixedWindowRollingPolicy fixedWindowRollingPolicy = new FixedWindowRollingPolicy(); fixedWindowRollingPolicy.setFileNamePattern(logFile.getAbsolutePath() + ".%i.gz"); fixedWindowRollingPolicy.setMaxIndex(LogDescription.MAXIMUM_LOG_HISTORY_INDEX); fixedWindowRollingPolicy.setContext(loggerContext); fixedWindowRollingPolicy.setParent(rollingFileAppender); SizeBasedTriggeringPolicy<ILoggingEvent> sizeBasedTriggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>(); sizeBasedTriggeringPolicy.setMaxFileSize(LogDescription.MAXIMUM_LOG_FILE_SIZE); sizeBasedTriggeringPolicy.setContext(loggerContext); rollingFileAppender.setRollingPolicy(fixedWindowRollingPolicy); rollingFileAppender.setTriggeringPolicy(sizeBasedTriggeringPolicy); sizeBasedTriggeringPolicy.start(); fixedWindowRollingPolicy.start(); System.out.println("Logging: The log is written to " + logFile); return rollingFileAppender; }
/** * Initializer logback * * @param file * @param level * @param maxHistory */ private void doInitializer(String file, String level, int maxHistory) { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME); rootLogger.detachAndStopAllAppenders(); // appender RollingFileAppender<ILoggingEvent> fileAppender = new RollingFileAppender<ILoggingEvent>(); fileAppender.setContext(loggerContext); fileAppender.setName("application"); fileAppender.setFile(file); fileAppender.setAppend(true); // policy TimeBasedRollingPolicy<ILoggingEvent> policy = new TimeBasedRollingPolicy<ILoggingEvent>(); policy.setContext(loggerContext); policy.setMaxHistory(maxHistory); policy.setFileNamePattern(file + ".%d{yyyy-MM-dd}"); policy.setParent(fileAppender); policy.start(); fileAppender.setRollingPolicy(policy); // encoder PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerContext); encoder.setPattern("%date [%thread] %-5level %logger (%file:%line\\) - %msg%n"); encoder.start(); fileAppender.setEncoder(encoder); fileAppender.start(); rootLogger.addAppender(fileAppender); rootLogger.setLevel(Level.toLevel(level)); rootLogger.setAdditive(false); }
@Override public void setupLogger() { String file = checkFile(); LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger newLogger =loggerContext.getLogger("ROOT"); //Remove all previously added appenders from this logger instance. newLogger.detachAndStopAllAppenders(); //define appender RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>(); //policy TimeBasedRollingPolicy<ILoggingEvent> policy = new TimeBasedRollingPolicy<ILoggingEvent>(); policy.setContext(loggerContext); policy.setMaxHistory(day); policy.setFileNamePattern(formateLogFile(file)); policy.setParent(appender); policy.start(); //encoder PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerContext); encoder.setPattern(formatePattern); encoder.start(); //start appender appender.setRollingPolicy(policy); appender.setContext(loggerContext); appender.setEncoder(encoder); appender.setPrudent(true); //support that multiple JVMs can safely write to the same file. appender.start(); newLogger.addAppender(appender); //setup level setLevel(newLogger); //remove the appenders that inherited 'ROOT'. newLogger.setAdditive(false); }
/** * Initializer logback * * @param file log file * @param level log level * @param maxHistory max history */ private void doInitializer(String file, String level, int maxHistory) { LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME); rootLogger.detachAndStopAllAppenders(); // appender RollingFileAppender<ILoggingEvent> fileAppender = new RollingFileAppender<>(); fileAppender.setContext(loggerContext); fileAppender.setName("application"); fileAppender.setFile(file); fileAppender.setAppend(true); // policy TimeBasedRollingPolicy<ILoggingEvent> policy = new TimeBasedRollingPolicy<>(); policy.setContext(loggerContext); policy.setMaxHistory(maxHistory); policy.setFileNamePattern(file + ".%d{yyyy-MM-dd}"); policy.setParent(fileAppender); policy.start(); fileAppender.setRollingPolicy(policy); // encoder PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(loggerContext); encoder.setPattern("%date [%thread] %-5level %logger (%file:%line\\) - %msg%n"); encoder.start(); fileAppender.setEncoder(encoder); fileAppender.start(); rootLogger.addAppender(fileAppender); rootLogger.setLevel(Level.toLevel(level)); rootLogger.setAdditive(false); }
private static void addAsyncAppender(Config config, RollingFileAppender<ILoggingEvent> fileAppender) { if (Boolean.getBoolean(SYS_PROP_LOG_ASYNC)) { LogbackManager.INSTANCE.createAsyncAppender(LogbackConfig.builder() .asyncAppenderName(APPENDER_ASYNC) .asyncLogQueueSize(config.getInt(KEY_ASYNC_LOG_QUEUE_SIZE)) .asyncLogDiscardingThreshold(config.getInt(KEY_ASYNC_LOG_DISCARD_THRESHOLD)) .asyncAppender(fileAppender) .build()); } }
public static Flusher createFlusher(String name, String dir, String file) { Preconditions.checkArgument(new File(dir).exists(), String.format("dir[%s] not exist", dir)); // LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); LoggerContext context = new LoggerContext(); Logger logger = context.getLogger(name); logger.setAdditive(false); RollingFileAppender rollingFileAppender = new RollingFileAppender(); rollingFileAppender.setContext(context); rollingFileAppender.setName(name + "_appender"); rollingFileAppender.setFile(dir + File.separator + file + ".dat"); rollingFileAppender.setAppend(true); TimeBasedRollingPolicy rollingPolicy = new TimeBasedRollingPolicy(); rollingPolicy.setFileNamePattern(dir + File.separator + file + ".%d{yyyy-MM-dd_HH}.dat"); rollingPolicy.setParent(rollingFileAppender); rollingPolicy.setContext(context); rollingPolicy.start(); PatternLayoutEncoder encoder = new PatternLayoutEncoder(); encoder.setContext(context); encoder.setPattern("%msg%n"); encoder.start(); rollingFileAppender.setRollingPolicy(rollingPolicy); rollingFileAppender.setEncoder(encoder); rollingFileAppender.start(); logger.addAppender(rollingFileAppender); return new Flusher(logger); }
/** * A relatively robust file renaming method which in case of failure due to * src and target being on different volumes, falls back onto * renaming by copying. * * @param src * @param target * @throws RolloverFailure */ public void rename(String src, String target) throws RolloverFailure { if (src.equals(target)) { addWarn("Source and target files are the same [" + src + "]. Skipping."); return; } File srcFile = new File(src); if (srcFile.exists()) { File targetFile = new File(target); createMissingTargetDirsIfNecessary(targetFile); addInfo("Renaming file [" + srcFile + "] to [" + targetFile + "]"); boolean result = srcFile.renameTo(targetFile); if (!result) { addWarn("Failed to rename file [" + srcFile + "] as [" + targetFile + "]."); if (areOnDifferentVolumes(srcFile, targetFile)) { addWarn("Detected different file systems for source [" + src + "] and target [" + target + "]. Attempting rename by copying."); renameByCopying(src, target); return; } else { addWarn("Please consider leaving the [file] option of " + RollingFileAppender.class.getSimpleName() + " empty."); addWarn("See also " + RENAMING_ERROR_URL); } } } else { throw new RolloverFailure("File [" + src + "] does not exist."); } }
static LoggerContext buildLoggerContext(String stamp, String filename, boolean safetyMode) { LoggerContext loggerContext = new LoggerContext(); RollingFileAppender<ILoggingEvent> rfa = new RollingFileAppender<ILoggingEvent>(); PatternLayoutEncoder patternLayout = new PatternLayoutEncoder(); patternLayout.setPattern(stamp + " %5p - %-50m%n"); patternLayout.setContext(loggerContext); patternLayout.start(); rfa.setEncoder(patternLayout); rfa.setAppend(true); rfa.setPrudent(safetyMode); rfa.setContext(loggerContext); TimeBasedRollingPolicy tbrp = new TimeBasedRollingPolicy(); tbrp.setContext(loggerContext); tbrp.setFileNamePattern(filename+"-%d{"+DATE_PATTERN+"}.log"); tbrp.setParent(rfa); tbrp.start(); rfa.setRollingPolicy(tbrp); rfa.start(); ch.qos.logback.classic.Logger root = loggerContext .getLogger(Logger.ROOT_LOGGER_NAME); root.addAppender(rfa); return loggerContext; }
@Test public void basic() throws Exception { String testId = "basic"; lc.putProperty("testId", testId); loadConfig(ClassicTestConstants.JORAN_INPUT_PREFIX + "rolling/" + testId + ".xml"); statusChecker.assertIsErrorFree(); Logger root = lc.getLogger(Logger.ROOT_LOGGER_NAME); expectedFilenameList.add(randomOutputDir + "z" + testId); RollingFileAppender<ILoggingEvent> rfa = (RollingFileAppender<ILoggingEvent>) root .getAppender("ROLLING"); TimeBasedRollingPolicy tprp = (TimeBasedRollingPolicy<ILoggingEvent>) rfa .getTriggeringPolicy(); TimeBasedFileNamingAndTriggeringPolicy tbnatp = tprp .getTimeBasedFileNamingAndTriggeringPolicy(); String prefix = "Hello---"; int runLength = 4; for (int i = 0; i < runLength; i++) { logger.debug(prefix + i); addExpectedFileNamedIfItsTime_ByDate(randomOutputDir, testId, false); incCurrentTime(500); tbnatp.setCurrentTime(currentTime); } existenceCheck(expectedFilenameList); sortedContentCheck(randomOutputDir, runLength, prefix); }