| /* |
| |
| Derby - Class org.apache.derbyTesting.functionTests.tests.engine.ErrorStreamTest |
| |
| Licensed to the Apache Software Foundation (ASF) under one or more |
| contributor license agreements. See the NOTICE file distributed with |
| this work for additional information regarding copyright ownership. |
| The ASF licenses this file to You under the Apache License, Version 2.0 |
| (the "License"); you may not use this file except in compliance with |
| the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| |
| */ |
| |
| package org.apache.derbyTesting.functionTests.tests.engine; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileNotFoundException; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.PrintStream; |
| import java.io.PrintWriter; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.security.PrivilegedActionException; |
| import java.security.PrivilegedExceptionAction; |
| import java.sql.SQLException; |
| import junit.framework.Test; |
| import org.apache.derbyTesting.functionTests.util.PrivilegedFileOpsForTests; |
| import org.apache.derbyTesting.junit.BaseJDBCTestCase; |
| import org.apache.derbyTesting.junit.BaseTestCase; |
| import org.apache.derbyTesting.junit.TestConfiguration; |
| |
| |
| /** |
| * Tests related to the Derby error stream. |
| * |
| * This test has been converted to junit from the old harness tests |
| * logStream.java and errorStream.java. The testDefault method is based on |
| * logStream.java, the other test* methods are from errorStream.java. |
| */ |
| public class ErrorStreamTest extends BaseJDBCTestCase { |
| private static final String FILE_PROP = "derby.stream.error.file"; |
| private static final String METHOD_PROP = "derby.stream.error.method"; |
| private static final String FIELD_PROP = "derby.stream.error.field"; |
| private static final String STYLE_PROP = "derby.stream.error.style"; |
| |
| private static final String ROLLING_FILE_STYLE = "rollingFile"; |
| private static final String ROLLING_FILE_COUNT_PROP = "derby.stream.error.rollingFile.count"; |
| private static final String ROLLING_FILE_LIMIT_PROP = "derby.stream.error.rollingFile.limit"; |
| private static final String ROLLING_FILE_PATTERN_PROP = "derby.stream.error.rollingFile.pattern"; |
| private static final String DERBY_0_LOG = "derby-0.log"; |
| private static final String DERBYLANGUAGELOG_QUERY_PLAN = "derby.language.logQueryPlan"; |
| |
| private static final String LOGFILESDIR = "logfilesdir"; |
| |
| /** |
| * runNo keeps track of which run we are in to generate unique (within a |
| * JUnit run) names for files that are used in the test. Has to be static. |
| */ |
| private static int runNo = 0; |
| |
| /** |
| * File used when FILE_PROP is set, it maps to file |
| * <database>-file-<runNo>.log |
| */ |
| private File fileStreamFile; |
| |
| /** |
| * See doc for getStream() below. Has to be static. |
| */ |
| private static OutputStream methodStream; |
| private File methodStreamFile; |
| |
| /** |
| * Field fieldStream used by Derby when FIELD_PROP is set, |
| * so it needs to be public and static. |
| * Maps to file <database>-field-<runNo>.log |
| */ |
| public static OutputStream fieldStream; |
| private File fieldStreamFile; |
| |
| /** |
| * Field errStream used as redirection for System.err to be able |
| * to checks its (non-)use in the scenarios. We first tried to |
| * merge it with System.out and let the harness compare outputs, |
| * but this gave intermittent merging differences, so abandoned. |
| * Maps to file <database>-err-<runNo>.log |
| */ |
| private OutputStream errStream; |
| private File errStreamFile; |
| |
| public ErrorStreamTest(String name) { |
| super(name); |
| } |
| |
| public static Test suite() { |
| return TestConfiguration.embeddedSuite(ErrorStreamTest.class); |
| } |
| |
| public void setUp() throws Exception { |
| bootDerby(); |
| // Shutdown engine so we can change properties for error stream |
| getTestConfiguration().shutdownEngine(); |
| openStreams(); |
| } |
| |
| public void tearDown() throws Exception { |
| resetProps(); |
| closeStreams(); |
| nullFields(); |
| super.tearDown(); |
| } |
| |
| /** |
| * Test that the error stream file (derby.log) is created at database boot |
| * and not deleted when the database is shut down, but can be deleted |
| * afterwards. |
| */ |
| public void testDefault() throws IOException, SQLException { |
| File derbyLog = new File(getSystemProperty("derby.system.home"), |
| "derby.log"); |
| bootDerby(); |
| assertIsExisting(derbyLog); |
| assertNotDirectory(derbyLog); |
| assertNotEmpty(derbyLog); |
| |
| println("Shutdown database"); |
| getTestConfiguration().shutdownDatabase(); |
| |
| assertIsExisting(derbyLog); |
| assertNotDirectory(derbyLog); |
| assertNotEmpty(derbyLog); |
| |
| println("Shutdown engine"); |
| getTestConfiguration().shutdownEngine(); |
| |
| boolean deleted = deleteFile(derbyLog); |
| assertTrue("File " + derbyLog + " could not be deleted", deleted); |
| } |
| |
| /** |
| * Test the derby.stream.error.file property. |
| */ |
| public void testFile() throws IOException, SQLException { |
| setSystemProperty(FILE_PROP, getCanonicalPath(fileStreamFile)); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotEmpty(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test the derby.stream.error.file property with wrong input. |
| */ |
| public void testWrongFile() throws IOException, SQLException { |
| setSystemProperty(FILE_PROP, getCanonicalPath(new File( |
| new File(getSystemProperty("derby.system.home"), "foo"), |
| makeStreamFilename("file")))); // erroneous path |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertNotEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test the derby.stream.error.method property. |
| */ |
| public void testMethod() throws IOException, SQLException { |
| setSystemProperty(METHOD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.getStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotExisting(fileStreamFile); |
| assertNotEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test the derby.stream.error.method property with wrong input. |
| */ |
| public void testWrongMethod() throws IOException, SQLException { |
| setSystemProperty(METHOD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.nonExistingGetStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertNotEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test the derby.stream.error.field property. |
| */ |
| public void testField() throws IOException, SQLException { |
| setSystemProperty(FIELD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.fieldStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertNotEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test the derby.stream.error.field property with wrong input. |
| */ |
| public void testWrongField() throws IOException, SQLException { |
| setSystemProperty(FIELD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.nonExistingFieldStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertNotEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test that the derby.stream.error.file property overrides the |
| * derby.stream.error.method property. |
| */ |
| public void testFileOverMethod() throws IOException, SQLException { |
| setSystemProperty(FILE_PROP, getCanonicalPath(fileStreamFile)); |
| setSystemProperty(METHOD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.getStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotEmpty(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test that the derby.stream.error.file property overrides the |
| * derby.stream.error.field property. |
| */ |
| public void testFileOverField() throws IOException, SQLException { |
| setSystemProperty(FILE_PROP, getCanonicalPath(fileStreamFile)); |
| setSystemProperty(FIELD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.fieldStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotEmpty(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test that the derby.stream.error.file property overrides the |
| * derby.stream.error.method and the derby.stream.error.field property. |
| */ |
| public void testFileOverMethodAndField() throws IOException, SQLException { |
| setSystemProperty(FILE_PROP, getCanonicalPath(fileStreamFile)); |
| setSystemProperty(METHOD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.getStream"); |
| setSystemProperty(FIELD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.fieldStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotEmpty(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test that the derby.stream.error.field property overrides the |
| * derby.stream.error.method property. |
| */ |
| public void testMethodOverField() throws IOException, SQLException { |
| |
| setSystemProperty(METHOD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.getStream"); |
| setSystemProperty(FIELD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.fieldStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotExisting(fileStreamFile); |
| assertNotEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test the derby.stream.error.style=rollingFile property. |
| */ |
| public void testStyleRollingFile() throws IOException, SQLException { |
| setSystemProperty(STYLE_PROP, ROLLING_FILE_STYLE); |
| |
| File derby0log = new File(getSystemProperty("derby.system.home"), DERBY_0_LOG); |
| |
| File derby0lck = new File(getSystemProperty("derby.system.home"), |
| "derby-0.log.lck"); |
| |
| bootDerby(); |
| |
| assertIsExisting(derby0log); |
| assertNotDirectory(derby0log); |
| assertNotEmpty(derby0log); |
| |
| assertIsExisting(derby0lck); |
| assertNotDirectory(derby0lck); |
| assertIsEmpty(derby0lck); |
| |
| println("Shutdown database"); |
| getTestConfiguration().shutdownDatabase(); |
| |
| assertIsExisting(derby0log); |
| assertNotDirectory(derby0log); |
| assertNotEmpty(derby0log); |
| |
| assertIsExisting(derby0lck); |
| assertNotDirectory(derby0lck); |
| assertIsEmpty(derby0lck); |
| |
| println("Shutdown engine"); |
| getTestConfiguration().shutdownEngine(); |
| |
| assertNotExisting(derby0lck); |
| |
| boolean deleted = deleteFile(derby0log); |
| assertTrue("File " + derby0log + " could not be deleted", deleted); |
| } |
| |
| /** |
| * Test the derby.stream.error.style property with wrong style. |
| */ |
| public void testWrongStyle() throws IOException, SQLException { |
| setSystemProperty(STYLE_PROP, "unknownStyle"); |
| |
| File derby0log = new File(getSystemProperty("derby.system.home"), DERBY_0_LOG); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotExisting(derby0log); |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertNotEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test the derby.stream.error.style=rollingFile property with default config |
| */ |
| public void testDefaultRollingDefaultConfig() throws IOException, SQLException { |
| setSystemProperty(STYLE_PROP, ROLLING_FILE_STYLE); |
| |
| // This is set so that we can get enough output into the log files |
| setSystemProperty(DERBYLANGUAGELOG_QUERY_PLAN, "true"); |
| |
| bootDerby(); |
| |
| // This will generate enough output to roll through all 10 log files |
| for (int i = 0; i < 3699; i++) { |
| checkAllConsistency(getConnection()); |
| } |
| // Make sure we remove the system property that is logging the query plan |
| removeSystemProperty(DERBYLANGUAGELOG_QUERY_PLAN); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| // There should be derb-0.log .. derby-9.log files present |
| for (int i = 0; i < 10; i++) { |
| File derbyLog = new File(getSystemProperty("derby.system.home"), |
| "derby-" + i + ".log"); |
| assertIsExisting(derbyLog); |
| assertNotDirectory(derbyLog); |
| assertNotEmpty(derbyLog); |
| |
| // Check the last log file to make sure that it has the default |
| // limit |
| if (i == 9) { |
| assertFileSize(derbyLog, 1024000); |
| } |
| |
| boolean deleted = deleteFile(derbyLog); |
| assertTrue("File " + derbyLog + " could not be deleted", deleted); |
| } |
| |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test the derby.stream.error.style=rollingFile property with user configuration. |
| */ |
| public void testDefaultRollingUserConfig() throws IOException, SQLException { |
| setSystemProperty(STYLE_PROP, ROLLING_FILE_STYLE); |
| setSystemProperty(ROLLING_FILE_PATTERN_PROP, "%d/db-%g.log"); |
| setSystemProperty(ROLLING_FILE_COUNT_PROP, "3"); |
| setSystemProperty(ROLLING_FILE_LIMIT_PROP, "10000"); |
| |
| // This is set so that we can get enough output into the log files |
| setSystemProperty(DERBYLANGUAGELOG_QUERY_PLAN, "true"); |
| |
| bootDerby(); |
| |
| // This will generate enough output to roll through all 3 log files |
| for (int i = 0; i < 10; i++) { |
| checkAllConsistency(getConnection()); |
| } |
| // Make sure we remove the system property that is logging the query plan |
| removeSystemProperty(DERBYLANGUAGELOG_QUERY_PLAN); |
| removeSystemProperty(ROLLING_FILE_PATTERN_PROP); |
| removeSystemProperty(ROLLING_FILE_COUNT_PROP); |
| removeSystemProperty(ROLLING_FILE_LIMIT_PROP); |
| |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| // There should be derb-0.log .. derby-3.log files present |
| for (int i = 0; i < 3; i++) { |
| File derbyLog = new File(getSystemProperty("derby.system.home"), |
| "db-" + i + ".log"); |
| assertIsExisting(derbyLog); |
| assertNotDirectory(derbyLog); |
| assertNotEmpty(derbyLog); |
| |
| // Check the last log file to make sure that it has the correct |
| // limit |
| if (i == 2) { |
| assertFileSize(derbyLog, 10000); |
| } |
| |
| boolean deleted = deleteFile(derbyLog); |
| assertTrue("File " + derbyLog + " could not be deleted", deleted); |
| } |
| |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test that the derby.stream.error.style property overrides the |
| * derby.stream.error.file property. |
| */ |
| public void testRollingFileStyleOverFile() throws IOException, SQLException { |
| setSystemProperty(STYLE_PROP, ROLLING_FILE_STYLE); |
| |
| File derby0log = new File(getSystemProperty("derby.system.home"), DERBY_0_LOG); |
| |
| setSystemProperty(FILE_PROP, getCanonicalPath(fileStreamFile)); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotEmpty(derby0log); |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| } |
| |
| /** |
| * Test that the derby.stream.error.style property overrides the |
| * derby.stream.error.method property. |
| */ |
| public void testRollingFileStyleOverMethod() throws IOException, SQLException { |
| setSystemProperty(STYLE_PROP, ROLLING_FILE_STYLE); |
| |
| File derby0log = new File(getSystemProperty("derby.system.home"), DERBY_0_LOG); |
| |
| setSystemProperty(METHOD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.getStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotEmpty(derby0log); |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| |
| boolean deleted = deleteFile(derby0log); |
| assertTrue("File " + derby0log + " could not be deleted", deleted); |
| } |
| |
| /** |
| * Test that the derby.stream.error.style property overrides the |
| * derby.stream.error.field property. |
| */ |
| public void testRollingFileStyleOverField() throws IOException, SQLException { |
| setSystemProperty(STYLE_PROP, ROLLING_FILE_STYLE); |
| |
| File derby0log = new File(getSystemProperty("derby.system.home"), DERBY_0_LOG); |
| |
| setSystemProperty(FIELD_PROP, |
| "org.apache.derbyTesting.functionTests.tests.engine."+ |
| "ErrorStreamTest.fieldStream"); |
| |
| bootDerby(); |
| getTestConfiguration().shutdownEngine(); |
| |
| closeStreams(); |
| |
| assertNotEmpty(derby0log); |
| assertNotExisting(fileStreamFile); |
| assertIsEmpty(methodStreamFile); |
| assertIsEmpty(fieldStreamFile); |
| assertIsEmpty(errStreamFile); |
| |
| boolean deleted = deleteFile(derby0log); |
| assertTrue("File " + derby0log + " could not be deleted", deleted); |
| } |
| |
| /** |
| * Method getStream used by Derby when derby.stream.error.method |
| * is set. Maps to file <database>-method-<runNo>.log |
| * This method has to be static. |
| */ |
| public static OutputStream getStream() { |
| return methodStream; |
| } |
| |
| private static String makeStreamFilename(String type) { |
| return type + "-" + runNo + ".log"; |
| } |
| |
| private void openStreams() throws IOException{ |
| String systemHome = getSystemProperty("derby.system.home"); |
| String logFilesHome=systemHome + File.separatorChar + LOGFILESDIR; |
| makeDirIfNotExisting(systemHome); |
| makeDirIfNotExisting(logFilesHome); |
| |
| runNo += 1; |
| |
| methodStreamFile = new File(logFilesHome, makeStreamFilename("method")); |
| fileStreamFile = new File(logFilesHome, makeStreamFilename("file")); |
| fieldStreamFile = new File(logFilesHome, makeStreamFilename("field")); |
| errStreamFile = new File(logFilesHome, makeStreamFilename("err")); |
| |
| methodStream = newFileOutputStream(methodStreamFile); |
| fieldStream = newFileOutputStream(fieldStreamFile); |
| errStream = newFileOutputStream(errStreamFile); |
| |
| setSystemErr(new PrintStream(errStream)); |
| |
| } |
| |
| |
| private void closeStreams() throws IOException { |
| try { |
| methodStream.close(); |
| fieldStream.close(); |
| errStream.close(); |
| |
| // reset until next scenario, no expected output |
| setSystemErr(System.out); |
| } catch (IOException e) { |
| println("Could not close stream files"); |
| throw e; |
| } |
| } |
| |
| private static void assertNotDirectory(final File f) throws IOException { |
| try { |
| AccessController.doPrivileged( |
| new PrivilegedExceptionAction<Void>() { |
| public Void run() throws IOException { |
| assertFalse("assertNotDirectory failed: " + |
| f.getCanonicalPath(), f.isDirectory()); |
| return null; |
| } |
| }); |
| } catch (PrivilegedActionException e) { |
| // e.getException() should be an instance of IOException. |
| throw (IOException) e.getException(); |
| } |
| } |
| |
| private static void assertIsEmpty(final File f) throws IOException { |
| String path = getCanonicalPath(f); |
| assertTrue(path + " doesn't exist", |
| PrivilegedFileOpsForTests.exists(f)); |
| assertEquals(path + " is not empty", |
| 0, PrivilegedFileOpsForTests.length(f)); |
| } |
| |
| |
| private static void assertNotEmpty(final File f) throws IOException { |
| try { |
| AccessController.doPrivileged( |
| new PrivilegedExceptionAction<Void>() { |
| public Void run() throws IOException { |
| assertTrue("assertNotEmpty failed: " + f.getCanonicalPath() |
| + " does not exist.", f.exists()); |
| FileInputStream fis = new FileInputStream(f); |
| int result = fis.read(); |
| fis.close(); |
| assertTrue("assertNotEmpty failed: " + f.getCanonicalPath() |
| + " is empty.", -1 != result); |
| return null; |
| } |
| }); |
| } catch (PrivilegedActionException e) { |
| // e.getException() should be an instance of IOException. |
| throw (IOException) e.getException(); |
| } |
| } |
| |
| private static void assertFileSize(final File f, final int size) throws IOException { |
| try { |
| AccessController.doPrivileged( |
| new PrivilegedExceptionAction<Void>() { |
| public Void run() throws IOException { |
| assertEquals("assertFileEize failed for file " + f.getName() + ": ", size, f.length()); |
| return null; |
| } |
| }); |
| } catch (PrivilegedActionException e) { |
| // e.getException() should be an instance of IOException. |
| throw (IOException) e.getException(); |
| } |
| } |
| |
| private static void assertIsExisting(final File f) throws IOException { |
| String path = getCanonicalPath(f); |
| assertTrue(path + " doesn't exist", |
| PrivilegedFileOpsForTests.exists(f)); |
| } |
| |
| |
| private static void assertNotExisting(final File f) throws IOException { |
| String path = getCanonicalPath(f); |
| assertFalse(path + " exists", |
| PrivilegedFileOpsForTests.exists(f)); |
| } |
| |
| private static boolean deleteFile(final File f) { |
| return PrivilegedFileOpsForTests.delete(f); |
| } |
| |
| private static String getCanonicalPath(final File f) throws IOException { |
| try { |
| return AccessController.doPrivileged( |
| new PrivilegedExceptionAction<String>() { |
| public String run() throws IOException { |
| return f.getCanonicalPath(); |
| } |
| }); |
| } catch (PrivilegedActionException e) { |
| // e.getException() should be an instance of IOException. |
| throw (IOException) e.getException(); |
| } |
| } |
| |
| private static void makeDirIfNotExisting(final String filename) { |
| AccessController.doPrivileged(new PrivilegedAction<Void>() { |
| public Void run() { |
| File f = new File(filename); |
| if(!f.exists()) { |
| f.mkdir(); |
| } |
| return null; |
| } |
| }); |
| } |
| |
| private static FileOutputStream newFileOutputStream(final File f) |
| throws FileNotFoundException { |
| try { |
| return AccessController.doPrivileged( |
| new PrivilegedExceptionAction<FileOutputStream>() { |
| public FileOutputStream run() throws FileNotFoundException { |
| return new FileOutputStream(f); |
| } |
| }); |
| } catch (PrivilegedActionException e) { |
| // e.getException() should be a FileNotFoundException. |
| throw (FileNotFoundException) e.getException(); |
| } |
| } |
| |
| |
| private static void resetProps() { |
| removeSystemProperty(FILE_PROP); |
| removeSystemProperty(METHOD_PROP); |
| removeSystemProperty(FIELD_PROP); |
| removeSystemProperty(STYLE_PROP); |
| } |
| |
| private void deleteStreamFiles() { |
| deleteFile(fileStreamFile); |
| deleteFile(methodStreamFile); |
| deleteFile(fieldStreamFile); |
| deleteFile(errStreamFile); |
| } |
| |
| private void nullFields() { |
| // Nulling fields to let objects be gc'd |
| fileStreamFile = null; |
| methodStreamFile = null; |
| fieldStreamFile = null; |
| errStreamFile = null; |
| methodStream = null; |
| fieldStream = null; |
| errStream = null; |
| } |
| |
| |
| private void bootDerby() throws SQLException { |
| /* Connect to the database to make sure that the |
| * JDBC Driver class is loaded |
| */ |
| getConnection(); |
| getConnection().close(); |
| } |
| |
| /** |
| * <p> |
| * Run the bare test, including {@code setUp()} and {@code tearDown()}. |
| * </p> |
| * |
| * <p> |
| * This is overriding BaseJDBCTestCase.runBareOverridable and thereby |
| * BaseJDBCTestCase.runBare(), so we can copy any log files created by this |
| * test if any of the fixtures fail. |
| * </p> |
| */ |
| public void runBareOverridable() throws Throwable { |
| PrintStream out = System.out; |
| TestConfiguration config = getTestConfiguration(); |
| boolean stopAfterFirstFail = config.stopAfterFirstFail(); |
| try { |
| super.runBareOverridable(); |
| } |
| // To log the exception to file, copy the derby.log file and copy |
| // the database of the failed test. |
| catch (Throwable running) { |
| PrintWriter stackOut = null; |
| try{ |
| copyFileToFail(LOGFILESDIR); |
| nullFields(); |
| deleteFile(LOGFILESDIR); |
| // copy files from testStyleRollingFile: |
| copyFileToFail("derby-0.log"); |
| copyFileToFail("derby-0.log.lck"); |
| // copy files from the testDefaultRollingUserConfig test |
| for (int i = 0; i < 3; i++) { |
| copyFileToFail("db-" + i + ".log"); |
| deleteFile("db-" + i + ".log"); |
| } |
| } |
| catch (IOException ioe) { |
| // We need to throw the original exception so if there |
| // is an exception saving the db or derby.log we will print it |
| // and additionally try to log it to file. |
| BaseTestCase.printStackTrace(ioe); |
| if (stackOut != null) { |
| stackOut.println("Copying derby.log or database failed:"); |
| ioe.printStackTrace(stackOut); |
| stackOut.println(); |
| } |
| } |
| finally { |
| if (stackOut != null) { |
| stackOut.close(); |
| } |
| if (stopAfterFirstFail) { |
| // if run with -Dderby.tests.stopAfterFirstFail=true |
| // exit after reporting failure. Useful for debugging |
| // cascading failures or errors that lead to hang. |
| running.printStackTrace(out); |
| System.exit(1); |
| } |
| else |
| throw running; |
| } |
| } |
| finally{ |
| // attempt to clean up |
| // first ensure we have the engine shutdown, or some |
| // files cannot be cleaned up. |
| getTestConfiguration().shutdownEngine(); |
| File origLogFilesDir = new File(DEFAULT_DB_DIR, LOGFILESDIR); |
| nullFields(); |
| removeDirectory(origLogFilesDir); |
| deleteFile("derby-0.log.lck"); |
| deleteFile("derby-0.log"); |
| deleteFile("derby.log"); |
| } |
| } |
| |
| private void copyFileToFail(String origFileName) throws IOException { |
| String failPath = PrivilegedFileOpsForTests.getAbsolutePath(getFailureFolder()); |
| File origFile = new File (DEFAULT_DB_DIR, origFileName); |
| File newFile = new File (failPath, origFileName); |
| PrivilegedFileOpsForTests.copy(origFile,newFile); |
| } |
| |
| // delete a file - used in cleanup when we don't care about the result |
| private void deleteFile(String origFileName) throws IOException { |
| File origFile = new File (DEFAULT_DB_DIR, origFileName); |
| PrivilegedFileOpsForTests.delete(origFile); |
| } |
| } |
