常见断言整理到以下工具类中:
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.assertThat;
import java.math.BigDecimal;
import java.util.Map;
public class AssertUtil {
public static final Logger logger = LoggerFactory.getLogger(AssertUtil.class);
/**
* equalTo匹配符表明如果测试的actual等于expect则测试通过,equalTo可以测试数值之间,字
* 符串之间和对象之间是否相等,相当于Object的equals方法
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertEquals(String errMsg, Object actual, Object expect) {
logger.info("断言方式:equalTo 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, equalTo(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* containsString匹配符表明如果测试的字符串actual包含子字符串expect则测试通过
*
* @param errMsg
* 断言失败提示信息
* @param actual
* 实际值
* @param expect
* 预期值
*/
public static void assertContains(String errMsg, String actual, String expect) {
logger.info("断言方式:containsString 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, containsString(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* startsWith匹配符表明如果测试的字符串actual以子字符串expect开始则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertStartsWith(String errMsg, String actual, String expect) {
logger.info("断言方式:startsWith 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, startsWith(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* endsWith匹配符表明如果测试的字符串actual以子字符串expect结尾则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertEndswith(String errMsg, String actual, String expect) {
logger.info("断言方式:endsWith 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, endsWith(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* equalToIgnoringCase匹配符表明如果测试的字符串actual在忽略大小写的情况下等于expect则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertEqualToIgnoringCase(String errMsg, String actual, String expect) {
logger.info("断言方式:equalToIgnoringCase 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, equalToIgnoringCase(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* closeTo匹配符表明如果所测试的浮点型数actual在expect±error范围之内则测试通过
*
* @param errMsg
* @param actual
* @param expect
* @param error
* 誤差
*/
public static void assertCloseTo(String errMsg, Double actual, Double expect, Double error) {
logger.info("断言方式:closeTo 实际值:" + actual + " 期望值:" + expect + ";误差值:" + error);
try {
assertThat(errMsg, actual, closeTo(expect, error));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* closeTo匹配符表明如果所测试的actual在expect±error范围之内则测试通过
*
* @param errMsg
* @param actual
* @param expect
* @param error
* 誤差
*/
public static void assertCloseTo(String errMsg, BigDecimal actual, BigDecimal expect, BigDecimal error) {
logger.info("断言方式:closeTo 实际值:" + actual + " 期望值:" + expect + ";误差值:" + error);
try {
assertThat(errMsg, actual, closeTo(expect, error));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* greaterThan匹配符表明如果所测试的数值actual大于expect则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertGreaterThan(String errMsg, Double actual, Double expect) {
logger.info("断言方式:greaterThan 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, greaterThan(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* lessThan匹配符表明如果所测试的数值actual小于expect则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertLessThan(String errMsg, Double actual, Double expect) {
logger.info("断言方式:lessThan 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, lessThan(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* greaterThanOrEqualTo匹配符表明如果所测试的数值actual大于等于expect则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertGreaterThanOrEqualTo(String errMsg, Double actual, Double expect) {
logger.info("断言方式:greaterThanOrEqualTo 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, greaterThanOrEqualTo(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* lessThanOrEqualTo匹配符表明如果所测试的数值actual小于等于expect则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertLessThanOrEqualTo(String errMsg, Double actual, Double expect) {
logger.info("断言方式:lessThanOrEqualTo 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, lessThanOrEqualTo(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* hasEntry匹配符表明如果测试的Map对象mapObject含有一个键值为"key"对应元素值为"value"的Entry项则测试通过
*
* @param errMsg
* @param actualMap
* @param key
* @param value
*/
public static void assertHasEntry(String errMsg, Map<?, ?> actualMap, Object key, Object value) {
logger.info("断言方式:hasEntry 实际值:" + actualMap.toString() + " 期望值:key=" + key.toString() + ";value="
+ value.toString());
try {
assertThat(errMsg, actualMap, hasEntry(key, value));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* hasKey匹配符表明如果测试的Map对象mapObject含有键值key则测试通过
*
* @param errMsg
* @param actualMap
* @param key
*/
public static void assertHasKey(String errMsg, Map<?, ?> actualMap, Object key) {
logger.info("断言方式:hasKey 实际值:" + actualMap.toString() + " 期望值:key=" + key.toString());
try {
assertThat(errMsg, actualMap, hasKey(key));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* hasValue匹配符表明如果测试的Map对象mapObject含有元素值“value”则测试通过
*
* @param errMsg
* @param actualMap
* @param key
*/
public static void assertHasValue(String errMsg, Map<?, ?> actualMap, Object key) {
logger.info("断言方式:hasValue 实际值:" + actualMap.toString() + " 期望值:key=" + key.toString());
try {
assertThat(errMsg, actualMap, hasValue(key));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* allOf匹配符表明如果接下来的所有条件必须都成立测试才通过,相当于“与”(&&)
*
* @param errMsg
* @param actual
* @param min
* @param max
*/
public static void assertAllof(String errMsg, Double actual, Double min, Double max) {
logger.info("断言方式:allOf 实际值:" + actual + " 期望值:最小值=" + min + ";最大值=" + max);
try {
assertThat(errMsg, actual, allOf(greaterThan(min), lessThan(max)));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* anyOf匹配符表明如果接下来的所有条件只要有一个成立则测试通过,相当于“或”(||)
*
* @param errMsg
* @param actual
* @param min
* @param max
*/
public static void assertAnyof(String errMsg, Double actual, Double min, Double max) {
logger.info("断言方式:anyOf 实际值:" + actual + " 期望值:最小值=" + min + ";最大值=" + max);
try {
assertThat(errMsg, actual, anyOf(greaterThan(min), lessThan(max)));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* anything匹配符表明无论什么条件,永远为true
*
* @param errMsg
* @param actual
*/
public static void assertAnything(String errMsg, Object actual) {
logger.info("断言方式:anything 实际值:" + actual);
try {
assertThat(errMsg, actual, anything());
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* is匹配符表明如果前面待测的actual等于后面给出的expect,则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertIs(String errMsg, Object actual, Object expect) {
logger.info("断言方式:is 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, is(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
/**
* not匹配符和is匹配符正好相反,表明如果前面待测的actual不等于后面给出的expect,则测试通过
*
* @param errMsg
* @param actual
* @param expect
*/
public static void assertNot(String errMsg, Object actual, Object expect) {
logger.info("断言方式:not 实际值:" + actual + " 期望值:" + expect);
try {
assertThat(errMsg, actual, not(expect));
} catch (AssertionError e) {
logger.error(errMsg, e);
throw e;
}
}
}