assert 订阅
assert,英语单词,动词,作动词时意为"维护,坚持;断言;主张;声称" [1] 展开全文
assert,英语单词,动词,作动词时意为"维护,坚持;断言;主张;声称" [1]
信息
中文名
assert
词    性
动词
assert单词发音
英[əˈsɜːt]美[əˈsɜːrt] [1] 
收起全文
精华内容
下载资源
问答
  • assert

    2020-06-09 19:56:41
    assert 一般在debug版本,用来检查永远不可能发生的条件。release版本禁用assert。 头文件 #include<assert.h> 使用 assert(i > 100); 不改变代码情况下,禁用assert #include<assert.h> 前面定义#...

    assert

    一般在debug版本,用来检查永远不可能发生的条件。release版本禁用assert。

    头文件

    #include<assert.h>

    使用

    assert(i > 100);

    不改变代码情况下,禁用assert

    1. #include<assert.h> 前面定义#define NDEBUG。
    2. 编译是添加 -DNDEBUG编译参数。

    注意

    1. 只检查添加,不写功能逻辑在assert中。 如i++, 禁用后,不会有++操作。
    2. #define NDEBUG要定义在#include<assert.h> 前面。
    展开全文
  • Assert

    千次阅读 2018-12-26 17:47:37
    Assert import org.apache.commons.lang.StringUtils; import java.util.Collection; import java.util.Map; /** * @author zhoulin * @date 2018/12/26 */ public abstract class Assert { /** * Assert a ...

    Assert

    import org.apache.commons.lang.StringUtils;
    import java.util.Collection;
    import java.util.Map;
    
    /**
     * @author zhoulin
     * @date 2018/12/26
     */
    public abstract class Assert {
    
    	/**
    	 * Assert a boolean expression, throwing <code>IllegalArgumentException</code>
    	 * if the test result is <code>false</code>.
    	 * <pre class="code">Assert.isTrue(i > 0, "The value must be greater than zero");</pre>
    	 * @param expression a boolean expression
    	 * @param message the exception message to use if the assertion fails
    	 * @throws DiebuIllegalArgumentException if expression is <code>false</code>
    	 */
    	public static void isTrue(boolean expression, String message) {
    		if (!expression) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert a boolean expression, throwing <code>IllegalArgumentException</code>
    	 * if the test result is <code>false</code>.
    	 * <pre class="code">Assert.isTrue(i > 0);</pre>
    	 * @param expression a boolean expression
    	 * @throws DiebuIllegalArgumentException if expression is <code>false</code>
    	 */
    	public static void isTrue(boolean expression) {
    		isTrue(expression, "[Assertion failed] - this expression must be true");
    	}
    
    	/**
    	 * Assert that an object is <code>null</code> .
    	 * <pre class="code">Assert.isNull(value, "The value must be null");</pre>
    	 * @param object the object to check
    	 * @param message the exception message to use if the assertion fails
    	 * @throws DiebuIllegalArgumentException if the object is not <code>null</code>
    	 */
    	public static void isNull(Object object, String message) {
    		if (object != null) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert that an object is <code>null</code> .
    	 * <pre class="code">Assert.isNull(value);</pre>
    	 * @param object the object to check
    	 * @throws DiebuIllegalArgumentException if the object is not <code>null</code>
    	 */
    	public static void isNull(Object object) {
    		isNull(object, "[Assertion failed] - the object argument must be null");
    	}
    
    	/**
    	 * Assert that an object is not <code>null</code> .
    	 * <pre class="code">Assert.notNull(clazz, "The class must not be null");</pre>
    	 * @param object the object to check
    	 * @param message the exception message to use if the assertion fails
    	 * @throws DiebuIllegalArgumentException if the object is <code>null</code>
    	 */
    	public static void notNull(Object object, String message) {
    		if (object == null) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert that an object is not <code>null</code> .
    	 * <pre class="code">Assert.notNull(clazz);</pre>
    	 * @param object the object to check
    	 * @throws DiebuIllegalArgumentException if the object is <code>null</code>
    	 */
    	public static void notNull(Object object) {
    		notNull(object, "[Assertion failed] - this argument is required; it must not be null");
    	}
    
    	/**
    	 * Assert that the given String is not empty; that is,
    	 * it must not be <code>null</code> and not the empty String.
    	 * <pre class="code">Assert.hasLength(name, "Name must not be empty");</pre>
    	 * @param text the String to check
    	 * @param message the exception message to use if the assertion fails
    	 * @see StringUtils#isNotEmpty
    	 */
    	public static void isNotEmpty(String text, String message) {
    		if (!StringUtils.isNotEmpty(text)) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert that the given String is not empty; that is,
    	 * it must not be <code>null</code> and not the empty String.
    	 * <pre class="code">Assert.hasLength(name);</pre>
    	 * @param text the String to check
    	 * @see StringUtils#isNotEmpty
    	 */
    	public static void isNotEmpty(String text) {
    		isNotEmpty(text,
    				"[Assertion failed] - this String argument must have length; it must not be null or empty");
    	}
    
    	/**
    	 * Assert that the given String has valid text content; that is, it must not
    	 * be <code>null</code> and must contain at least one non-whitespace character.
    	 * <pre class="code">Assert.hasText(name, "'name' must not be empty");</pre>
    	 * @param text the String to check
    	 * @param message the exception message to use if the assertion fails
    	 * @see StringUtils#isNotBlank
    	 */
    	public static void isNotBlank(String text, String message) {
    		if (!StringUtils.isNotBlank(text)) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert that the given String has valid text content; that is, it must not
    	 * be <code>null</code> and must contain at least one non-whitespace character.
    	 * <pre class="code">Assert.hasText(name, "'name' must not be empty");</pre>
    	 * @param text the String to check
    	 * @see StringUtils#hasText
    	 */
    	public static void isNotBlank(String text) {
    		isNotBlank(text,
    				"[Assertion failed] - this String argument must have text; it must not be null, empty, or blank");
    	}
    
    	/**
    	 * Assert that the given text does not contain the given substring.
    	 * <pre class="code">Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");</pre>
    	 * @param textToSearch the text to search
    	 * @param substring the substring to find within the text
    	 * @param message the exception message to use if the assertion fails
    	 */
    	public static void doesNotContain(String textToSearch, String substring, String message) {
    		if (StringUtils.isNotEmpty(textToSearch) && StringUtils.isNotEmpty(substring) &&
    				textToSearch.indexOf(substring) != -1) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert that the given text does not contain the given substring.
    	 * <pre class="code">Assert.doesNotContain(name, "rod");</pre>
    	 * @param textToSearch the text to search
    	 * @param substring the substring to find within the text
    	 */
    	public static void doesNotContain(String textToSearch, String substring) {
    		doesNotContain(textToSearch, substring,
    				"[Assertion failed] - this String argument must not contain the substring [" + substring + "]");
    	}
    
    
    	/**
    	 * Assert that an array has elements; that is, it must not be
    	 * <code>null</code> and must have at least one element.
    	 * <pre class="code">Assert.notEmpty(array, "The array must have elements");</pre>
    	 * @param array the array to check
    	 * @param message the exception message to use if the assertion fails
    	 * @throws DiebuIllegalArgumentException if the object array is <code>null</code> or has no elements
    	 */
    	public static void notEmpty(Object[] array, String message) {
    		if (array == null || array.length == 0) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert that an array has elements; that is, it must not be
    	 * <code>null</code> and must have at least one element.
    	 * <pre class="code">Assert.notEmpty(array);</pre>
    	 * @param array the array to check
    	 * @throws DiebuIllegalArgumentException if the object array is <code>null</code> or has no elements
    	 */
    	public static void notEmpty(Object[] array) {
    		notEmpty(array, "[Assertion failed] - this array must not be empty: it must contain at least 1 element");
    	}
    
    	/**
    	 * Assert that an array has no null elements.
    	 * Note: Does not complain if the array is empty!
    	 * <pre class="code">Assert.noNullElements(array, "The array must have non-null elements");</pre>
    	 * @param array the array to check
    	 * @param message the exception message to use if the assertion fails
    	 * @throws DiebuIllegalArgumentException if the object array contains a <code>null</code> element
    	 */
    	public static void noNullElements(Object[] array, String message) {
    		if (array != null) {
    			for (int i = 0; i < array.length; i++) {
    				if (array[i] == null) {
    					throw new DiebuIllegalArgumentException(message);
    				}
    			}
    		}
    	}
    
    	/**
    	 * Assert that an array has no null elements.
    	 * Note: Does not complain if the array is empty!
    	 * <pre class="code">Assert.noNullElements(array);</pre>
    	 * @param array the array to check
    	 * @throws DiebuIllegalArgumentException if the object array contains a <code>null</code> element
    	 */
    	public static void noNullElements(Object[] array) {
    		noNullElements(array, "[Assertion failed] - this array must not contain any null elements");
    	}
    
    	/**
    	 * Assert that a collection has elements; that is, it must not be
    	 * <code>null</code> and must have at least one element.
    	 * <pre class="code">Assert.notEmpty(collection, "Collection must have elements");</pre>
    	 * @param collection the collection to check
    	 * @param message the exception message to use if the assertion fails
    	 * @throws IllegalArgumentException if the collection is <code>null</code> or has no elements
    	 */
    	public static void notEmpty(Collection collection, String message) {
    		if (collection == null || collection.isEmpty()) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert that a collection has elements; that is, it must not be
    	 * <code>null</code> and must have at least one element.
    	 * <pre class="code">Assert.notEmpty(collection, "Collection must have elements");</pre>
    	 * @param collection the collection to check
    	 * @throws DiebuIllegalArgumentException if the collection is <code>null</code> or has no elements
    	 */
    	public static void notEmpty(Collection collection) {
    		notEmpty(collection,
    				"[Assertion failed] - this collection must not be empty: it must contain at least 1 element");
    	}
    
    	/**
    	 * Assert that a Map has entries; that is, it must not be <code>null</code>
    	 * and must have at least one entry.
    	 * <pre class="code">Assert.notEmpty(map, "Map must have entries");</pre>
    	 * @param map the map to check
    	 * @param message the exception message to use if the assertion fails
    	 * @throws DiebuIllegalArgumentException if the map is <code>null</code> or has no entries
    	 */
    	public static void notEmpty(Map map, String message) {
    		if (map == null || map.isEmpty()) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert that a Map has entries; that is, it must not be <code>null</code>
    	 * and must have at least one entry.
    	 * <pre class="code">Assert.notEmpty(map);</pre>
    	 * @param map the map to check
    	 * @throws DiebuIllegalArgumentException if the map is <code>null</code> or has no entries
    	 */
    	public static void notEmpty(Map map) {
    		notEmpty(map, "[Assertion failed] - this map must not be empty; it must contain at least one entry");
    	}
    
    
    	/**
    	 * Assert that the provided object is an instance of the provided class.
    	 * <pre class="code">Assert.instanceOf(Foo.class, foo);</pre>
    	 * @param clazz the required class
    	 * @param obj the object to check
    	 * @throws DiebuIllegalArgumentException if the object is not an instance of clazz
    	 * @see Class#isInstance
    	 */
    	public static void isInstanceOf(Class clazz, Object obj) {
    		isInstanceOf(clazz, obj, "");
    	}
    
    	/**
    	 * Assert that the provided object is an instance of the provided class.
    	 * <pre class="code">Assert.instanceOf(Foo.class, foo);</pre>
    	 * @param type the type to check against
    	 * @param obj the object to check
    	 * @param message a message which will be prepended to the message produced by
    	 * the function itself, and which may be used to provide context. It should
    	 * normally end in a ": " or ". " so that the function generate message looks
    	 * ok when prepended to it.
    	 * @throws DiebuIllegalArgumentException if the object is not an instance of clazz
    	 * @see Class#isInstance
    	 */
    	public static void isInstanceOf(Class type, Object obj, String message) {
    		notNull(type, "Type to check against must not be null");
    		if (!type.isInstance(obj)) {
    			throw new DiebuIllegalArgumentException(message +
    					"Object of class [" + (obj != null ? obj.getClass().getName() : "null") +
    					"] must be an instance of " + type);
    		}
    	}
    
    	/**
    	 * Assert that <code>superType.isAssignableFrom(subType)</code> is <code>true</code>.
    	 * <pre class="code">Assert.isAssignable(Number.class, myClass);</pre>
    	 * @param superType the super type to check
    	 * @param subType the sub type to check
    	 * @throws DiebuIllegalArgumentException if the classes are not assignable
    	 */
    	public static void isAssignable(Class superType, Class subType) {
    		isAssignable(superType, subType, "");
    	}
    
    	/**
    	 * Assert that <code>superType.isAssignableFrom(subType)</code> is <code>true</code>.
    	 * <pre class="code">Assert.isAssignable(Number.class, myClass);</pre>
    	 * @param superType the super type to check against
    	 * @param subType the sub type to check
    	 * @param message a message which will be prepended to the message produced by
    	 * the function itself, and which may be used to provide context. It should
    	 * normally end in a ": " or ". " so that the function generate message looks
    	 * ok when prepended to it.
    	 * @throws DiebuIllegalArgumentException if the classes are not assignable
    	 */
    	public static void isAssignable(Class superType, Class subType, String message) {
    		notNull(superType, "Type to check against must not be null");
    		if (subType == null || !superType.isAssignableFrom(subType)) {
    			throw new DiebuIllegalArgumentException(message + subType + " is not assignable to " + superType);
    		}
    	}
    
    
    	/**
    	 * Assert a boolean expression, throwing <code>IllegalStateException</code>
    	 * if the test result is <code>false</code>. Call isTrue if you wish to
    	 * throw IllegalArgumentException on an assertion failure.
    	 * <pre class="code">Assert.state(id == null, "The id property must not already be initialized");</pre>
    	 * @param expression a boolean expression
    	 * @param message the exception message to use if the assertion fails
    	 * @throws DiebuIllegalArgumentException if expression is <code>false</code>
    	 */
    	public static void state(boolean expression, String message) {
    		if (!expression) {
    			throw new DiebuIllegalArgumentException(message);
    		}
    	}
    
    	/**
    	 * Assert a boolean expression, throwing {@link DiebuIllegalArgumentException}
    	 * if the test result is <code>false</code>.
    	 * <p>Call {@link #isTrue(boolean)} if you wish to
    	 * throw {@link DiebuIllegalArgumentException} on an assertion failure.
    	 * <pre class="code">Assert.state(id == null);</pre>
    	 * @param expression a boolean expression
    	 * @throws DiebuIllegalArgumentException if the supplied expression is <code>false</code>
    	 */
    	public static void state(boolean expression) {
    		state(expression, "[Assertion failed] - this state invariant must be true");
    	}
    }
    
    

    DiebuException

    /**
     * @author zhoulin
     * @date 2018/12/26
     */
    public class DiebuException extends  RuntimeException{
        private static final String DEFAULT_CODE = "basic";
    
        private String errorCode;
    
        public DiebuException(String message){
            super(message);
            this.errorCode = DEFAULT_CODE;
        }
    
        public DiebuException(String message, String errorCode){
            super(message);
            this.errorCode = errorCode;
        }
    
        public String getCode() {
            return this.errorCode;
        }
    }
    

    DiebuRuntimeException

    /**
     * @author zhoulin
     * @date 2018/12/26
     */
    public class DiebuRuntimeException extends  DiebuException{
        public DiebuRuntimeException(String message){
            super(message);
        }
    }
    
    

    DiebuIllegalArgumentException

    /**
     * @author zhoulin
     * @date 2018/12/26
     */
    public class DiebuIllegalArgumentException extends  DiebuRuntimeException{
        public DiebuIllegalArgumentException(String message) {
            super(message);
        }
    }
    
    
    展开全文
  • ASSERT

    2014-03-13 16:33:48
    下面是一种用户自己定义宏 ASSERT 的方法: #ifdef DEBUG void _Assert(char* , unsigned); //原型 #define ASSERT(f) \ if(f) \ NULL; \ else \ _Assert(__FILE__ , __LINE__) #else #define ASSERT(f) NULL #...
    下面是一种用户自己定义宏 ASSERT 的方法:

    #ifdef DEBUG
    void _Assert(char* , unsigned); //原型
    #define ASSERT(f) \
    if(f) \
        NULL; \
    else \
        _Assert(__FILE__ , __LINE__)
    #else
    #define ASSERT(f) NULL
    #endif

    从中我们可以看到,如果定义了 DEBUG,ASSERT 将被扩展为一个 if 语句。if 语句中的
    NULL 语句让人感到很奇怪,这是因为要避免 if 不配对,所以它必须要有 else 语句。也许
    读者认为在_Assert 调用的闭括号之后需要一个分号,但并不需要。因为用户在使用
    ASSERT 时,已经给出了一个分号.
    当 ASSERT 失败时,它就使用预处理程序根据宏__FILE__和__LINE__所提供的文件名
    和行号参数调用_Assert。
    _Assert 在标准错误输出设备 stderr 上打印一条错误消息,然后
    中止:

    void _Assert(char* strFile, unsigned uLine)
    {
        fflush(stdout);
        fprintf(stderr, “\nAssertion failed: %s, line %u\n”,strFile, uLine);
        fflush(stderr);
        abort();
    }

    在执行 abort 之前,需要调用 fflush 将所有的缓冲输出写到标准输出设备 stdout 上。
    同 样 , 如 果 stdout 和 stderr 都 指 向 同 一 个 设 备 , fflush stdout 仍 然 要 放 在 fflush
    stderr 之前,以确保只有在所有的输出都送到 stdout 之后,fprintf 才显示相应的错误信
    息。
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,950
精华内容 25,180
热门标签
关键字:

assert