Selenium + Java系列一：断言

常见断言整理到以下工具类中：

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;
		}
	}

}