public ExecutionResult(
Sequence original_seq,
int replacing_index,
Sequence replacing_sequence,
AbstractState replacing_profile,
ExecutableSequence eseq_replaced) {
FDUtils.checkNull(original_seq, "The original seq could not be null.");
FDUtils.checkTrue(
replacing_index >= 0 && replacing_index < original_seq.size(),
"The replacing_index: "
+ replacing_index
+ " is not valid, the seq size: "
+ original_seq.size());
FDUtils.checkNull(replacing_sequence, "the replacing_sequence could not be null.");
FDUtils.checkNull(eseq_replaced, "The eseq_replaced could not be null.");
this.original_sequence = original_seq;
this.replacing_index = replacing_index;
this.replacing_sequence = replacing_sequence;
this.replacing_profile = replacing_profile;
this.replaced_eSeq = eseq_replaced;
// get the result, about exceptional, failure, or not executed?
// get the binary-profile
}
/** Return the max index from 0 - size() -1, which executes normally */
public int indexOfExecuted() {
if (this.cached_executed_index != -1) {
return this.cached_executed_index;
}
// recompute it
if (!hasNonExecuted()) {
this.cached_executed_index = this.original_sequence.size() - 1;
return this.cached_executed_index;
}
int exec_index_in_replaced = -1;
ExecutionOutcome[] outcomes = this.replaced_eSeq.getAllResults();
for (int i = 0; i < outcomes.length; i++) {
if (outcomes[i] instanceof NotExecuted) {
exec_index_in_replaced = i - 1;
break;
}
}
FDUtils.checkTrue(
exec_index_in_replaced != -1,
"The exec_index_in_replaced: " + exec_index_in_replaced + " should not be -1.");
// that is the replacing sequence should not fail!
FDUtils.checkTrue(
exec_index_in_replaced > this.replacing_index,
"The exec_index_in_replaced: "
+ exec_index_in_replaced
+ " should > this.replacing_index: "
+ this.replacing_index);
// we could even claim
// PalusUtil.checkTrue(exec_index_in_replaced > this.replacing_index
// + this.replacing_sequence.size() - 1);
// XXX fixme
// compute the corresponding index in the original statement
int exec_index_in_orig = exec_index_in_replaced - this.replacing_sequence.size() + 1;
this.cached_executed_index = exec_index_in_orig;
return this.cached_executed_index;
}
public Throwable getThrownException() {
if (this.cached_exception_thrown != null) {
return this.cached_exception_thrown;
}
if (!hasExceptionThrown()) {
this.cached_exception_thrown = null;
return this.cached_exception_thrown;
}
int index_of_exception = -1;
ExecutionOutcome[] outcomes = this.replaced_eSeq.getAllResults();
for (int i = 0; i < outcomes.length; i++) {
if (outcomes[i] instanceof ExceptionalExecution) {
index_of_exception = i;
ExceptionalExecution e = (ExceptionalExecution) outcomes[i];
this.cached_exception_thrown = e.getException();
break;
}
}
int index_of_exception_in_original = index_of_exception - this.replacing_sequence.size() + 1;
// check there must be exception
FDUtils.checkTrue(
this.replaced_eSeq.hasUnexpectedException(),
"The replace_eSeq should have unexpected" + " exception.");
FDUtils.checkNull(this.cached_exception_thrown, "The cached_exception could not be null.");
// the statement must has exceptions, the last statement executed
FDUtils.checkTrue(
index_of_exception_in_original == this.indexOfExecuted(),
"The index_of_exception: "
+ index_of_exception_in_original
+ " != this.indexOfExecuted(): "
+ this.indexOfExecuted());
return this.cached_exception_thrown;
}
// in original sequence
public int getFailureIndex() {
if (!hasFailure()) {
return -1;
}
int index = this.replaced_eSeq.getFailureIndex() - this.replacing_sequence.size() + 1;
FDUtils.checkTrue(
index > 0 && index < this.original_sequence.size(),
"The index: "
+ index
+ " is not valid, the original sequence size: "
+ this.original_sequence.size());
return index;
}
