/*******************************************************************************
* Copyright (c) 1998, 2015 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.testing.framework;
import java.io.*;
import java.math.*;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.indirection.*;
/**
* <p><b>Purpose</b>:Class stores the test exception if raised and decides whether the test was
* successfull or not.
*/
public class TestResult implements ResultInterface, Comparable, Serializable {
public static final String ERROR = "Error";
public static final String FATAL_ERROR = "FatalError";
public static final String PASSED = "Passed";
public static final String PROBLEM = "Problem";
public static final String WARNING = "Warning";
protected String name;
protected String description;
protected BigDecimal id;
protected String outcome;
protected transient ValueHolderInterface summary;
protected transient ValueHolderInterface loadBuildSummary;
protected EclipseLinkException exception;
protected transient TestCase testCase;
protected long totalTime;
protected long testTime;
public TestResult() {
summary = new ValueHolder();
loadBuildSummary = new ValueHolder();
}
public TestResult(TestCase testCase) {
this.outcome = "Passed";
this.testCase = testCase;
try {
this.name = testCase.getName();
this.description = testCase.getDescription();
} catch (NullPointerException e) {
}
summary = new ValueHolder();
loadBuildSummary = new ValueHolder();
}
public TestResult(TestCase testCase, String result) {
this.outcome = result;
this.testCase = testCase;
this.name = testCase.getName();
this.description = testCase.getDescription();
summary = new ValueHolder();
loadBuildSummary = new ValueHolder();
}
public int compareTo(Object summary) {
return getName().compareTo(((TestResult)summary).getName());
}
public String getDescription() {
return description;
}
public EclipseLinkException getException() {
return exception;
}
public boolean shouldLogResult() {
return !hasPassed();
}
/**
* Not return warning stacktrace
*/
public String getExceptionStackTraceForDatabase() {
if ((exception != null) && !hasWarning()) {
StringWriter writer = new StringWriter();
exception.printStackTrace(new PrintWriter(writer));
String trace = writer.toString();
// Trim to 2000
// Must trim for writing to the database.
if (trace.length() >= 2000) {
trace = trace.substring(0, 1995);
}
return trace;
}
return null;
}
/**
* Not return warning stacktrace
*/
public String getExceptionStackTrace() {
if (exception != null) {
StringWriter writer = new StringWriter();
exception.printStackTrace(new PrintWriter(writer));
String trace = writer.toString();
return trace;
}
return null;
}
public BigDecimal getId() {
return id;
}
public long getTestTime() {
return testTime;
}
public long getTotalTime() {
return totalTime;
}
public void setTestTime(long testTime) {
this.testTime = testTime;
}
public void setTotalTime(long totalTime) {
this.totalTime = totalTime;
}
/**
* This is use to return null when the test no error but warning
*/
public EclipseLinkException getLoadBuildException() {
return exception;
}
public LoadBuildSummary getLoadBuildSummary() {
return (LoadBuildSummary)loadBuildSummary.getValue();
}
public ValueHolderInterface getLoadBuildSummaryHolder() {
return loadBuildSummary;
}
public String getName() {
return name;
}
/**
* Return the outcome of the test.
* This is one of, "Passed", "Warning", "Error", "FatalError"
*/
public String getOutcome() {
return outcome;
}
/**
* Depending upon the result of the exception the test outcome is decided.
*/
public String getOutcomeForException(EclipseLinkException exception) {
if (exception == null) {
return PASSED;
} else if (exception instanceof TestErrorException) {
return ERROR;
} else if (exception instanceof TestProblemException) {
return PROBLEM;
} else if (exception instanceof TestWarningException) {
return WARNING;
} else {
return FATAL_ERROR;
}
}
public TestResultsSummary getSummary() {
return (TestResultsSummary)summary.getValue();
}
public ValueHolderInterface getSummaryHolder() {
return summary;
}
public TestCase getTestCase() {
return testCase;
}
public void setTestCase(TestCase testCase) {
this.testCase = testCase;
}
/**
* A error means that the verify detected a failure in the test.
*/
public boolean hasError() {
return getOutcome().equals(ERROR);
}
/**
* A fatal error means that an unhandled exception occurred during the test.
*/
public boolean hasFatalError() {
return getOutcome().equals(FATAL_ERROR);
}
/**
* Passed means the test was ok.
*/
public boolean hasPassed() {
return getOutcome().equals(PASSED);
}
/**
* A problem means a error occurred during setup or reset.
*/
public boolean hasProblem() {
return getOutcome().equals(PROBLEM);
}
/**
* A warning means the test did not pass, but there may be a reason for it too fail on this platform.
*/
public boolean hasWarning() {
return getOutcome().equals(WARNING);
}
/**
* Return if the test failed (did not pass or throw warning).
*/
public boolean hasFailed() {
return !(hasPassed() || hasWarning());
}
/**
* logs the result of the test on the print stream.
*/
public void logRegressionResult(Writer log) {
String indentationString = getTestCase().getIndentationString();
try {
log.write(indentationString + "RESULT: " + getOutcome() + org.eclipse.persistence.internal.helper.Helper.cr());
log.flush();
} catch (IOException exception) {
}
LoadBuildSystem.loadBuild.addResult(this);
}
/**
* logs the result of the test on the print stream.
*/
public void logResult(Writer log) {
String indentationString = getTestCase().getIndentationString();
try {
if (hasError() || hasFatalError() || hasProblem()) {
log.write(indentationString + "##FAILURE##" + org.eclipse.persistence.internal.helper.Helper.cr());
}
log.write(indentationString + "TEST TIME: " + getTestTime() + org.eclipse.persistence.internal.helper.Helper.cr());
log.write(indentationString + "TOTAL TIME: " + getTotalTime() + org.eclipse.persistence.internal.helper.Helper.cr());
log.write(indentationString + "RESULT: " + getOutcome() + org.eclipse.persistence.internal.helper.Helper.cr());
if (getException() != null) {
getException().setIndentationString(indentationString);
// Do not print the stack for warnings, just the exception.
if (hasWarning()) {
log.write(getException() + org.eclipse.persistence.internal.helper.Helper.cr());
} else {
log.write(indentationString);
log.flush();
log.write(getExceptionStackTrace() + org.eclipse.persistence.internal.helper.Helper.cr());
}
}
log.flush();
} catch (IOException exception) {
}
LoadBuildSystem.loadBuild.addResult(this);
}
public void setDescription(String aDescription) {
description = aDescription;
}
/**
* Set the exception raised by the test case in the result.
* Set the outcome dependant on the exeception.
*/
public void setException(EclipseLinkException anException) {
exception = anException;
setOutcome(getOutcomeForException(anException));
}
/**
* Return the exception raised by the test.
*/
public void setExceptionStackTrace(String stackTrace) {
if (stackTrace != null) {
if (exception == null) {
exception = new TestException(stackTrace);
}
}
}
public void setId(BigDecimal anId) {
id = anId;
}
public void setLoadBuildSummary(LoadBuildSummary summary) {
if (loadBuildSummary == null) {
loadBuildSummary = new ValueHolder();
}
loadBuildSummary.setValue(summary);
}
public void setLoadBuildSummaryHolder(ValueHolderInterface holder) {
loadBuildSummary = holder;
}
public void setName(String aName) {
name = aName;
}
/**
* Set the outcome of the test.
* This is one of, "Passed", "Warning", "Error", "FatalError"
*/
public void setOutcome(String outcome) {
this.outcome = outcome;
}
public void setSummary(TestResultsSummary summary) {
if (this.summary == null) {
this.summary = new ValueHolder();
}
this.summary.setValue(summary);
}
public void setSummaryHolder(ValueHolderInterface holder) {
summary = holder;
}
public void setupTestResult(TestCase testCase) {
this.testCase = testCase;
}
}