Examples with WaitCriterion org.apache.geode.test.dunit.WaitCriterion used on opensource projects

Example 71 with WaitCriterion

use of org.apache.geode.test.dunit.WaitCriterion in project geode by apache.

the class MyGatewayEventSubstitutionFilter method pauseWaitCriteria.

public static void pauseWaitCriteria(final long millisec) {
    WaitCriterion wc = new WaitCriterion() {

        public boolean done() {
            return false;
        }

        public String description() {
            return "Expected to wait for " + millisec + " millisec.";
        }
    };
    Wait.waitForCriterion(wc, millisec, 500, false);
}

Example 72 with WaitCriterion

use of org.apache.geode.test.dunit.WaitCriterion in project geode by apache.

the class MyGatewayEventSubstitutionFilter method validateRegionSize.

public static void validateRegionSize(String regionName, final int regionSize) {
    IgnoredException exp = IgnoredException.addIgnoredException(ForceReattemptException.class.getName());
    IgnoredException exp1 = IgnoredException.addIgnoredException(CacheClosedException.class.getName());
    try {
        final Region r = cache.getRegion(Region.SEPARATOR + regionName);
        assertNotNull(r);
        WaitCriterion wc = new WaitCriterion() {

            public boolean done() {
                if (r.keySet().size() == regionSize) {
                    return true;
                }
                return false;
            }

            public String description() {
                return "Expected region entries: " + regionSize + " but actual entries: " + r.keySet().size() + " present region keyset " + r.keySet();
            }
        };
        Wait.waitForCriterion(wc, 240000, 500, true);
    } finally {
        exp.remove();
        exp1.remove();
    }
}

Example 73 with WaitCriterion

use of org.apache.geode.test.dunit.WaitCriterion in project geode by apache.

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithSecurityFineLevelAndLogAtInfoLevelButNoSecurityLog.

/**
   * tests scenario where security log has not been set but a level has been set to a more granular
   * level than that of the regular log. Verifies that the correct logs for security show up in the
   * regular log as expected
   * 
   * @throws Exception
   */
@Test
public void testDistributedSystemWithSecurityFineLevelAndLogAtInfoLevelButNoSecurityLog() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(LOG_LEVEL, "info");
    properties.put(SECURITY_LOG_LEVEL, "fine");
    properties.put(MCAST_PORT, "0");
    properties.put(LOCATORS, "");
    properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false");
    properties.put(DISABLE_AUTO_RECONNECT, "true");
    properties.put(MEMBER_TIMEOUT, "2000");
    properties.put(ENABLE_CLUSTER_CONFIGURATION, "false");
    final File logFile = new File(logFileName);
    if (logFile.exists()) {
        logFile.delete();
    }
    assertFalse(logFile.exists());
    this.system = DistributedSystem.connect(properties);
    assertNotNull(this.system);
    DistributionConfig config = ((InternalDistributedSystem) this.system).getConfig();
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.FINE_LEVEL, config.getSecurityLogLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.INFO_LEVEL, config.getLogLevel());
    InternalLogWriter securityLogWriter = (InternalLogWriter) system.getSecurityLogWriter();
    InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter();
    assertNotNull(securityLogWriter);
    assertNotNull(logWriter);
    assertTrue(securityLogWriter instanceof LogWriterLogger);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, securityLogWriter.getLogWriterLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.INFO_LEVEL) + " but was " + LogWriterImpl.levelToString(securityLogWriter.getLogWriterLevel()), InternalLogWriter.INFO_LEVEL, logWriter.getLogWriterLevel());
    assertTrue(securityLogWriter.fineEnabled());
    assertFalse(logWriter.fineEnabled());
    assertTrue(((LogWriterLogger) securityLogWriter).isDebugEnabled());
    assertFalse(((LogWriterLogger) logWriter).isDebugEnabled());
    assertTrue(securityLogWriter instanceof FastLogger);
    assertTrue(logWriter instanceof FastLogger);
    assertTrue(((FastLogger) securityLogWriter).isDelegating());
    assertTrue(((FastLogger) logWriter).isDelegating());
    Wait.waitForCriterion(new WaitCriterion() {

        @Override
        public boolean done() {
            return logFile.exists();
        }

        @Override
        public String description() {
            return "waiting for log files to exist: " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(logFile.exists());
    final Logger logger = LogService.getLogger();
    int i = 0;
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        securityLogWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        securityLogWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        securityLogWriter.fine(FINE_STRING);
        assertTrue(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        securityLogWriter.config(CONFIG_STRING);
        assertTrue(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        securityLogWriter.info(INFO_STRING);
        assertTrue(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        securityLogWriter.warning(WARNING_STRING);
        assertTrue(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        securityLogWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        securityLogWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertFalse(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertTrue(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertTrue(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertTrue(fileContainsString(logFile, FATAL_STRING));
    }
    this.system.disconnect();
    this.system = null;
}

Example 74 with WaitCriterion

use of org.apache.geode.test.dunit.WaitCriterion in project geode by apache.

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithDebugLogLevel.

@Test
public void testDistributedSystemWithDebugLogLevel() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(LOG_LEVEL, "debug");
    properties.put(MCAST_PORT, "0");
    properties.put(LOCATORS, "");
    properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false");
    properties.put(DISABLE_AUTO_RECONNECT, "true");
    properties.put(MEMBER_TIMEOUT, "2000");
    properties.put(ENABLE_CLUSTER_CONFIGURATION, "false");
    final File logFile = new File(logFileName);
    if (logFile.exists()) {
        logFile.delete();
    }
    assertFalse(logFile.exists());
    this.system = DistributedSystem.connect(properties);
    assertNotNull(this.system);
    DistributionConfig config = ((InternalDistributedSystem) this.system).getConfig();
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.FINE_LEVEL, config.getLogLevel());
    InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter();
    assertNotNull(logWriter);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel());
    assertTrue(logWriter.fineEnabled());
    assertTrue(((LogWriterLogger) logWriter).isDebugEnabled());
    assertTrue(logWriter instanceof FastLogger);
    assertTrue(((FastLogger) logWriter).isDelegating());
    Wait.waitForCriterion(new WaitCriterion() {

        @Override
        public boolean done() {
            return logFile.exists();
        }

        @Override
        public String description() {
            return "waiting for log file to exist: " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(logFile.exists());
    // assert not empty
    FileInputStream fis = new FileInputStream(logFile);
    try {
        assertTrue(fis.available() > 0);
    } finally {
        fis.close();
    }
    final Logger logger = LogService.getLogger();
    int i = 0;
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        logWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        logWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        logWriter.fine(FINE_STRING);
        assertTrue(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        logWriter.config(CONFIG_STRING);
        assertTrue(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        logWriter.info(INFO_STRING);
        assertTrue(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        logWriter.warning(WARNING_STRING);
        assertTrue(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        logWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertTrue(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertTrue(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertTrue(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertTrue(fileContainsString(logFile, FATAL_STRING));
    }
    // change log level to error and verify
    config.setLogLevel(InternalLogWriter.ERROR_LEVEL);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.ERROR_LEVEL, config.getLogLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.ERROR_LEVEL, logWriter.getLogWriterLevel());
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        logWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        logWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        logWriter.fine(FINE_STRING);
        assertFalse(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        logWriter.config(CONFIG_STRING);
        assertFalse(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        logWriter.info(INFO_STRING);
        assertFalse(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        logWriter.warning(WARNING_STRING);
        assertFalse(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        logWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertFalse(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertFalse(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertFalse(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertTrue(fileContainsString(logFile, FATAL_STRING));
    }
    this.system.disconnect();
    this.system = null;
}

Example 75 with WaitCriterion

use of org.apache.geode.test.dunit.WaitCriterion in project geode by apache.

the class DistributedSystemLogFileJUnitTest method testDistributedSystemWithFineLogLevel.

@Test
public void testDistributedSystemWithFineLogLevel() throws Exception {
    // final int port = AvailablePort.getRandomAvailablePort(AvailablePort.JGROUPS);
    final String logFileName = name.getMethodName() + "-system-" + System.currentTimeMillis() + ".log";
    final Properties properties = new Properties();
    properties.put(LOG_FILE, logFileName);
    properties.put(LOG_LEVEL, "fine");
    properties.put(MCAST_PORT, "0");
    properties.put(LOCATORS, "");
    properties.put(ENABLE_NETWORK_PARTITION_DETECTION, "false");
    properties.put(DISABLE_AUTO_RECONNECT, "true");
    properties.put(MEMBER_TIMEOUT, "2000");
    properties.put(ENABLE_CLUSTER_CONFIGURATION, "false");
    final File logFile = new File(logFileName);
    if (logFile.exists()) {
        logFile.delete();
    }
    assertFalse(logFile.exists());
    this.system = DistributedSystem.connect(properties);
    assertNotNull(this.system);
    DistributionConfig config = ((InternalDistributedSystem) this.system).getConfig();
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.FINE_LEVEL, config.getLogLevel());
    InternalLogWriter logWriter = (InternalLogWriter) system.getLogWriter();
    assertNotNull(logWriter);
    assertTrue(logWriter instanceof LogWriterLogger);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.FINE_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.FINE_LEVEL, logWriter.getLogWriterLevel());
    assertTrue(logWriter.fineEnabled());
    assertTrue(((LogWriterLogger) logWriter).isDebugEnabled());
    assertTrue(logWriter instanceof FastLogger);
    assertTrue(((FastLogger) logWriter).isDelegating());
    Wait.waitForCriterion(new WaitCriterion() {

        @Override
        public boolean done() {
            return logFile.exists();
        }

        @Override
        public String description() {
            return "waiting for log file to exist: " + logFile;
        }
    }, TIMEOUT_MILLISECONDS, INTERVAL_MILLISECONDS, true);
    assertTrue(logFile.exists());
    // assert not empty
    FileInputStream fis = new FileInputStream(logFile);
    try {
        assertTrue(fis.available() > 0);
    } finally {
        fis.close();
    }
    final Logger logger = LogService.getLogger();
    int i = 0;
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        logWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        logWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        logWriter.fine(FINE_STRING);
        assertTrue(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        logWriter.config(CONFIG_STRING);
        assertTrue(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        logWriter.info(INFO_STRING);
        assertTrue(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        logWriter.warning(WARNING_STRING);
        assertTrue(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        logWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertTrue(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertTrue(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertTrue(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertTrue(fileContainsString(logFile, FATAL_STRING));
    }
    // change log level to error and verify
    config.setLogLevel(InternalLogWriter.ERROR_LEVEL);
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " + LogWriterImpl.levelToString(config.getLogLevel()), InternalLogWriter.ERROR_LEVEL, config.getLogLevel());
    assertEquals("Expected " + LogWriterImpl.levelToString(InternalLogWriter.ERROR_LEVEL) + " but was " + LogWriterImpl.levelToString(logWriter.getLogWriterLevel()), InternalLogWriter.ERROR_LEVEL, logWriter.getLogWriterLevel());
    {
        i++;
        final String FINEST_STRING = "testLogLevels Message logged at FINEST level [" + i + "]";
        logWriter.finest(FINEST_STRING);
        assertFalse(fileContainsString(logFile, FINEST_STRING));
        i++;
        final String FINER_STRING = "testLogLevels Message logged at FINER level [" + i + "]";
        logWriter.finer(FINER_STRING);
        assertFalse(fileContainsString(logFile, FINER_STRING));
        i++;
        final String FINE_STRING = "testLogLevels Message logged at FINE level [" + i + "]";
        logWriter.fine(FINE_STRING);
        assertFalse(fileContainsString(logFile, FINE_STRING));
        i++;
        final String CONFIG_STRING = "testLogLevels Message logged at CONFIG level [" + i + "]";
        logWriter.config(CONFIG_STRING);
        assertFalse(fileContainsString(logFile, CONFIG_STRING));
        i++;
        final String INFO_STRING = "testLogLevels Message logged at INFO level [" + i + "]";
        logWriter.info(INFO_STRING);
        assertFalse(fileContainsString(logFile, INFO_STRING));
        i++;
        final String WARNING_STRING = "ExpectedStrings: testLogLevels Message logged at WARNING level [" + i + "]";
        logWriter.warning(WARNING_STRING);
        assertFalse(fileContainsString(logFile, WARNING_STRING));
        i++;
        final String ERROR_STRING = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logWriter.error(ERROR_STRING);
        assertTrue(fileContainsString(logFile, ERROR_STRING));
        i++;
        final String SEVERE_STRING = "ExpectedStrings: testLogLevels Message logged at SEVERE level [" + i + "]";
        logWriter.severe(SEVERE_STRING);
        assertTrue(fileContainsString(logFile, SEVERE_STRING));
        i++;
        final String TRACE_STRING = "testLogLevels Message logged at TRACE level [" + i + "]";
        logger.trace(TRACE_STRING);
        assertFalse(fileContainsString(logFile, TRACE_STRING));
        i++;
        final String DEBUG_STRING = "testLogLevels Message logged at DEBUG level [" + i + "]";
        logger.debug(DEBUG_STRING);
        assertFalse(fileContainsString(logFile, DEBUG_STRING));
        i++;
        final String INFO_STRING_J = "testLogLevels Message logged at INFO level [" + i + "]";
        logger.info(INFO_STRING_J);
        assertFalse(fileContainsString(logFile, INFO_STRING_J));
        i++;
        final String WARN_STRING = "ExpectedStrings: testLogLevels Message logged at WARN level [" + i + "]";
        logger.warn(WARN_STRING);
        assertFalse(fileContainsString(logFile, WARN_STRING));
        i++;
        final String ERROR_STRING_J = "ExpectedStrings: testLogLevels Message logged at ERROR level [" + i + "]";
        logger.error(ERROR_STRING_J);
        assertTrue(fileContainsString(logFile, ERROR_STRING_J));
        i++;
        final String FATAL_STRING = "ExpectedStrings: testLogLevels Message logged at FATAL level [" + i + "]";
        logger.fatal(FATAL_STRING);
        assertTrue(fileContainsString(logFile, FATAL_STRING));
    }
    this.system.disconnect();
    this.system = null;
}