Java Util.myAssert方法代码示例

import com.sri.ai.util.Util; //导入方法依赖的package包/类
@Override
public Expression replace(Expression expression, Expression newSubExpression) {
	AbstractQuantifiedExpression quantifiedExpression = castOrThrowError(AbstractQuantifiedExpression.class, expression, "Attempt to use " + IndexExpressionTypeSubExpressionAddress.class.getSimpleName() + " to replace sub-expression " + newSubExpression + " in %s, but the latter should have been an instance of %s but is instead an instance of %s");
	Util.myAssert(() -> quantifiedExpression.getIndexExpressions() instanceof ExtensionalIndexExpressionsSet, () -> quantifiedExpression.getClass().getSimpleName() + ".replaceIndexExpression assumes extensional set of index expressions but " + quantifiedExpression + " has a non-extensional index expression set");

	List<Expression> indexExpressionsList = ((ExtensionalIndexExpressionsSet) quantifiedExpression.getIndexExpressions()).getList();
	List<Expression> newIndexExpressionsList =
			replaceElementNonDestructively(indexExpressionsList, indexExpressionIndex,
					ie -> replaceAddressedSubExpressionInIndexExpressionByNewSubExpression(ie, newSubExpression));

	Expression result;
	if (newIndexExpressionsList != indexExpressionsList) {
		IndexExpressionsSet newIndexExpressions = new ExtensionalIndexExpressionsSet(newIndexExpressionsList);
		result = quantifiedExpression.setIndexExpressions(newIndexExpressions);
	}
	else {
		result = quantifiedExpression;
	}
	
	return result;
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
private void nullary() {
	try {
		Util.myAssert(() -> true , () -> "error message 1");
		Util.myAssert(() -> false, () -> "error message 2");
		if (System.getProperty(Util.MY_ASSERT_OFF) == null) {
			fail("Should have thrown an AssertionError but did not. System.getProperty(Util.MY_ASSERT_OFF) = " + System.getProperty(Util.MY_ASSERT_OFF));
		}
	}
	catch (AssertionError error) {
		if (error.getMessage().equals("error message 2")) {
			if (System.getProperty(Util.MY_ASSERT_OFF) == null) {
				// good, passed the unit test
			}
			else {
				fail("Threw assertion error when it should not have.");
			}
		}
		else {
			fail("Threw the wrong assertion error.");
		}
	}
	// good, passed the unit test
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
/**
 * Convenience for <code>this.getTheory().isLiteral(expression, this)</code>.
 * @param expression
 * @return
 */
default boolean isLiteral(Expression expression) {
	Theory theory = getTheory();
	Util.myAssert(theory != null, () -> "Context does not contain a theory, but is trying to check if " + expression + " is a literal according to some theory. Please make sure the context has been provided a theory");
	boolean result = theory.isLiteralOrBooleanConstant(expression, this);
	return result;
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
/**
 * Extends with pairs of symbols and their respective types represented as strings.
 * @param symbolsAndTypes
 * @return
 */
default Registry extendWithSymbolsAndTypes(Expression... symbolsAndTypes) {
	Util.myAssert(symbolsAndTypes.length % 2 == 0, () -> "Need to extend registry with a sequence of symbols and their types");
	List<Expression> indexExpressions = makeIndexExpressionsFromSymbolsAndTypes(symbolsAndTypes);
	Registry result = extendWith(new ExtensionalIndexExpressionsSet(indexExpressions));
	return result;
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
@Override
public Pair<Expression, IndexExpressionsSet> getExpressionAndIndexExpressionsFromProblemExpression(Expression expression, Context context) {
	String functorString = getFunctionString();
	Util.myAssert(() -> expression.hasFunctor(functorString), () -> "Expression expected to be application of " + functorString + " but is " + expression);
	IntensionalSet set = (IntensionalSet) expression.get(0);
	Expression body = IfThenElse.make(set.getCondition(), set.getHead(), additiveIdentityElement());
	Pair<Expression, IndexExpressionsSet> result = Pair.make(body, set.getIndexExpressions());
	return result;
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
/**
 * Assert that the give expression represents a function type application.
 * 
 * @param expression
 *            the expression to be tested.
 */
public static void assertFunctionType(Expression expression) {
	Util.myAssert(expression.hasFunctor(FUNCTION_TYPE), () -> "Functor in expression " + expression
			+ " should be a functional type (that is, have functor '->')");
	Util.myAssert(expression.numberOfArguments() == 1 || expression.numberOfArguments() == 2,
			() -> "Function type has illegal number of arguments (should be 1 or 2), has "
					+ expression.numberOfArguments() + " for " + expression);
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
public CompoundTheory(Theory... subTheoriesArray) {
	super();
	this.subTheories = list(subTheoriesArray);
	Util.myAssert(() -> subTheories.size() != 0, () -> getClass() + " needs to receive at least one sub-theory but got none.");
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
@Override
public Expression replace(Expression expression, Expression newSubExpression) {
	Util.myAssert(() -> expression instanceof AbstractExtensionalSet, () -> getClass().getSimpleName() + ".IndexAddress applied to expression " + expression + " of class " + expression.getClass());
	Expression result = ((ExtensionalSet)expression).setElementDefinition(this.index, newSubExpression);
	return result;
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
@Override
public Expression getSubExpressionOf(Expression expression) {
	Util.myAssert(() -> expression instanceof AbstractExtensionalSet, () -> getClass().getSimpleName() + ".IndexAddress applied to expression " + expression + " of class " + expression.getClass());
	Expression result = ((AbstractExtensionalSet) expression).getElementDefinition(index);
	return result;
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
@Override
public Expression replace(Expression expression, Expression newSubExpression) {
	Util.myAssert(() -> expression instanceof DefaultTuple, () -> DefaultTuple.class.getSimpleName() + ".IndexAddress applied to expression " + expression + " of class " + expression.getClass());
	Expression result = expression.set(this.index, newSubExpression);
	return result;
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
@Override
public Expression replace(Expression expression, Expression newSubExpression) {
	Util.myAssert(() -> expression.getSyntacticFormType().equals(FunctionApplication.SYNTACTIC_FORM_TYPE), () -> DefaultFunctionApplication.class.getSimpleName() + ".IndexAddress applied to expression " + expression + " of class " + expression.getClass());
	Expression result = expression.set(this.index, newSubExpression);
	return result;
}
 

import com.sri.ai.util.Util; //导入方法依赖的package包/类
public T computeCurrent() {
	Util.myAssert(baseCurrentIsInitialized, () -> "No current element defined for iterator.");
	T result = function.apply(baseCurrent);
	return result;
}