精华内容
下载资源
问答
  • assert断言

    2018-11-29 17:54:52
    assert断言

                                                                                      assert断言

    断言是软件调试的一种方法,当不满足某条件下,系统将会report错误信息,并且系统将会主动crash。

    展开全文
  • Assert断言

    2018-05-24 20:18:00
    使用assert断言是学习python一个非常好的习惯,python assert 断言句语格式及用法很简单。在没完善一个程序之前,我们不知道程序在哪里会出错,与其让它在运行最崩溃,不如在出现错误条件时就崩溃,这时候就需要...

    使用assert断言是学习python一个非常好的习惯,python assert 断言句语格式及用法很简单。在没完善一个程序之前,我们不知道程序在哪里会出错,与其让它在运行最崩溃不如在出现错误条件时就崩溃,这时候就需要assert断言的帮助。本文主要是讲assert断言的基础知识。

    python assert断言的作用

    python assert断言是声明其布尔值必须为真的判定,如果发生异常就说明表达示为假。可以理解assert断言语句为raise-if-not,用来测试表示式,其返回值为假,就会触发异常。

    assert断言语句的语法格式

        assert python 怎么用?
        expression assert 表达式
    1. assert语句用来声明某个条件是真的。
    2. 如果你非常确信某个你使用的列表中至少有一个元素,而你想要检验这一点,并且在它非真的时候引发一个错误,那么assert语句是应用在这种情形下的理想语句。
    3. 当assert语句失败的时候,会引发一AssertionError。

    下面做一些assert用法的语句供参考:

    >>assert 1==1
    >> assert 1 == 2
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AssertionError
    
    >>assert 2+2==2*2
    >>assert len(['my boy',12])<10
    >>assert range(4)==[0,1,2,3]
    >>> mylist = ['item']
    >>assert len(mylist) >= 1
    >>mylist.pop()
    'item'
    >>assert len(mylist) >= 1
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AssertionError

     

    如何为assert断言语句添加异常参数

    assert的异常参数,其实就是在断言表达式后添加字符串信息,用来解释断言并更好的知道是哪里出了问题。格式如下:

        assert expression [, arguments]
        assert 表达式 [, 参数]

    自定异常

    class ShortInputException(Exception):
        '''自定义的异常类'''
        def __init__(self, length, atleast):
            #super().__init__()
            self.length = length
            self.atleast = atleast
    
    def main():
        try:
            s = input('请输入 --> ')
            if len(s) < 3:
                # raise引发一个你定义的异常
                raise ShortInputException(len(s), 3)
        except ShortInputException as result:#x这个变量被绑定到了错误的实例
            print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'% (result.length, result.atleast))
        else:
            print('没有异常发生.')
    
    main()

    原文地址https://blog.csdn.net/hunyxv/article/details/52737339

    转载于:https://www.cnblogs.com/wangkun122/p/9084911.html

    展开全文
  • ASSERT 断言

    2021-08-13 12:28:56
    断言实际是一个宏,通常我们使用断言来进行简单的条件判断,当assert(_Expression) 中,_Expression表达式不成立时,直接中断程序 使用断言需要包含头文件 #include <assert.h> #ifdef NDEBUG #define assert...

    一、C/C++中的断言

    断言实际是一个宏,通常我们使用断言来进行简单的条件判断,当assert(_Expression) 中,_Expression表达式不成立时,直接中断程序

    使用断言需要包含头文件 #include <assert.h>

    #ifdef NDEBUG
    #define assert(_Expression) ((void)0)
    #else /* !defined (NDEBUG) */
    #if defined(_UNICODE) || defined(UNICODE)
    #define assert(_Expression) \
     (void) \
     ((!!(_Expression)) || \
      (_wassert(_CRT_WIDE(#_Expression),_CRT_WIDE(__FILE__),__LINE__),0))
    #else /* not unicode */
    #define assert(_Expression) \
     (void) \
     ((!!(_Expression)) || \
      (_assert(#_Expression,__FILE__,__LINE__),0))
    #endif /* _UNICODE||UNICODE */
    #endif /* !defined (NDEBUG) */
    

    For Example:

    #include <iostream>
    #include <assert.h>
    using namespace std;
    
    int func(int* p)
    {
        assert( p!= NULL);
        return (*p)<<1;
    }
    
    int main()
    {
        // func(nullptr); //==》 中断
    
        /*
          Assertion failed!
    
          Program: D:\xxxxxx\chp02\debug\chp02.exe
          File: ..\..\cpp_review\chp02\main.cpp, Line 6
    
          Expression: p!= NULL
        */
        int a = 10;
        cout << func(&a) << endl; // 20
    
        return 0;
    }
    
    

    那如何关闭assert断言呢,从源码定义中可以看出,只需要在源代码的开头,include <assert.h> 之前。定义一下 宏NDEBUG即可

    #include <iostream>
    
    #define NDEBUG
    #include <assert.h>
    using namespace std;
    
    int func(int* p){
        assert( p!= NULL);
        return p == nullptr ? 0 : *p;
    }
    
    int main()
    {
        func(nullptr);
        int a = 10;
        cout << func(&a) << endl; // 20
    
        return 0;
    }
    
    

    重新运行之后,我们发现断言部分实际不生效了;但是如果发生错误,程序依然会产生异常,而且比较难定位异常产生的位置,所以,通常我们并不会主动关闭断言。


    二、Qt中的断言

    在Qt中也是支持assert断言的,Qt中为我们提供了如下的两个宏
    Q_ASSERTQ_ASSERT_X

    #if !defined(Q_ASSERT)
    #  if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
    #    define Q_ASSERT(cond) static_cast<void>(false && (cond))
    #  else
    #    define Q_ASSERT(cond) ((cond) ? static_cast<void>(0) : qt_assert(#cond, __FILE__, __LINE__))
    #  endif
    #endif
    

    Q_ASSERT 的使用与assert 相似,当cond 不成立是触发中断,程序退出

    #if !defined(Q_ASSERT_X)
    #  if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
    #    define Q_ASSERT_X(cond, where, what) static_cast<void>(false && (cond))
    #  else
    #    define Q_ASSERT_X(cond, where, what) ((cond) ? static_cast<void>(0) : qt_assert_x(where, what, __FILE__, __LINE__))
    #  endif
    #endif
    

    Q_ASSERT_X 除了指定断言条件cond外,还可以指定 where(文件、行号等自定义信息,需要注意,where为 const char* 类型),可以指定what(自定义错误提示语,也是const char* 类型)

    举个栗子:

    #include <QCoreApplication>
    
    
    int func(int* p)
    {
        // Q_ASSERT(p !=NULL);
    
        Q_ASSERT_X(p!= NULL,"[main.cpp][function:func][line:8]","p is nullptr,error");
        // ASSERT failure in [main.cpp][function:func][line:8]: "p is nullptr,error", file ..\..\cpp_review\qassert01\main.cpp, line 8
    
        return *p;
    }
    
    int main(int argc, char *argv[])
    {
        QCoreApplication a(argc, argv);
    
        func(nullptr);
    
        return a.exec();
    }
    
    
    展开全文
  • assert 断言

    千次阅读 2018-11-03 19:24:09
    assert 模块提供了断言测试的函数,用于测试不变式。 assert.AssertionError 类 Error 的一个子类,表明断言的失败。 assert 模块抛出的所有错误都是 AssertionError 类的实例。 new assert.AssertionError(options)...

    刚开始接触这块说不好自己的想法只能借用学习文档来记录我的学习过程,以后会慢慢加强的。下面是文档的内容:

    assert 模块提供了断言测试的函数,用于测试不变式。

    assert.AssertionError 类

    Error 的一个子类,表明断言的失败。 assert 模块抛出的所有错误都是 AssertionError 类的实例。

    new assert.AssertionError(options)

    • options
      • message 如果有值,则错误信息会被设为该值。
      • actual 错误实例的 actual 属性会被设为该值。用于 actual 错误输入,例如使用 assert.strictEqual()。
      • expected 错误实例的 expected 属性会被设为该值。用于 expected 错误输入,例如使用 assert.strictEqual()。
      • operator 错误实例的 operator 属性会被设为该值。用于表明比较时使用的是哪个操作(或触发错误的是哪个断言函数)。
      • stackStartFn 如果有值,则由提供的函数生成堆栈踪迹。

    所有实例都包含内置的 Error 属性(message 和 name)以及:

    • actual 被设为实际值,例如使用 assert.strictEqual()。
    • expected 被设为期望值,例如使用 assert.strictEqual()。
    • generatedMessage 表明信息是否为自动生成的。
    • code 总是被设为 ERR_ASSERTION,表明错误是一个断言错误。
    • operator 被设为传入的运算符的值。
    const assert = require('assert');
    
    // 生成一个 AssertionError,用于比较错误信息:
    const { message } = new assert.AssertionError({
      actual: 1,
      expected: 2,
      operator: 'strictEqual'
    });
    
    // 验证输出的错误:
    try {
      assert.strictEqual(1, 2);
    } catch (err) {
      assert(err instanceof assert.AssertionError);
      assert.strictEqual(err.message, message);
      assert.strictEqual(err.name, 'AssertionError [ERR_ASSERTION]');
      assert.strictEqual(err.actual, 1);
      assert.strictEqual(err.expected, 2);
      assert.strictEqual(err.code, 'ERR_ASSERTION');
      assert.strictEqual(err.operator, 'strictEqual');
      assert.strictEqual(err.generatedMessage, true);
    }
    

    assert(value[, message])

      - value <any> 要检查是否为真的值。
      - message <string> | <Error>
    

    assert.ok() 的别名。

    assert.deepEqual(actual, expected[, message])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    

    测试实际参数和预期参数之间的深度相等性。将原值与抽象等式比较(==).

    只考虑可枚举的“自有”属性。deepequal()实现不测试对象的[[Prototype]]或可枚举的自己的符号属性。对于此类检查,请考虑使用assert.deepStrictEqual()。deepequal()可能会有令人惊讶的结果。下面的示例不会抛出AssertionError,因为RegExp对象上的属性是不可枚举的:

    // WARNING: This does not throw an AssertionError!
    assert.deepEqual(/a/gi, new Date());
    

    Map和Set例外。正如预期的那样,Map和Set也会比较它们所包含的项。

    “深”等式意味着子对象的可枚举的“自有”属性也被计算:

    const assert = require('assert');
    
    const obj1 = {
      a: {
        b: 1
      }
    };
    const obj2 = {
      a: {
        b: 2
      }
    };
    const obj3 = {
      a: {
        b: 1
      }
    };
    const obj4 = Object.create(obj1);
    
    assert.deepEqual(obj1, obj1);
    // OK
    
    // Values of b are different:
    assert.deepEqual(obj1, obj2);
    // AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
    
    assert.deepEqual(obj1, obj3);
    // OK
    
    // Prototypes are ignored:
    assert.deepEqual(obj1, obj4);
    // AssertionError: { a: { b: 1 } } deepEqual {}
    

    如果值不相等,将抛出AssertionError,其消息属性设置为等于消息参数的值。如果消息参数未定义,则会分配一个默认错误消息。如果消息参数是错误的实例,那么它将被抛出,而不是AssertionError。

    assert.deepStrictEqual(actual, expected[, message])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    

    测试 actual 参数与 expected 参数是否深度相等。 深度相等意味着子对象中可枚举的自身属性也会按以下规则递归地比较。

    比较的详细说明

    • 原始值运用 SameValue比较法进行比较,使用 Object.is() 函数。
    • 对象的类型标签应该相同。
    • 对象的原型使用全等运算符比较。
    • 只比较可枚举的自身属性。
    • Error 的名称与信息也会比较,即使不是可枚举的属性。
    • 可枚举的自身 Symbol 属性也会比较。
    • 对象封装器 会同时比较对象与解封装后的值。
    • Object 属性的比较是无序的。
    • Map 键名与 Set 子项的比较是无序的。
    • 当两边的值不相同或遇到循环引用时,递归会停止。
    • WeakMap 与 WeakSet 的比较不依赖于它们的值。
    const assert = require('assert').strict;
    
    // 失败,因为 1 !== '1'。
    assert.deepStrictEqual({ a: 1 }, { a: '1' });
    // AssertionError: Input A expected to strictly deep-equal input B:
    // + expected - actual
    //   {
    // -   a: 1
    // +   a: '1'
    //   }
    
    // 以下对象没有自身属性。
    const date = new Date();
    const object = {};
    const fakeDate = {};
    Object.setPrototypeOf(fakeDate, Date.prototype);
    
    // 原型不同:
    assert.deepStrictEqual(object, fakeDate);
    // AssertionError: Input A expected to strictly deep-equal input B:
    // + expected - actual
    // - {}
    // + Date {}
    
    // 类型标签不同:
    assert.deepStrictEqual(date, fakeDate);
    // AssertionError: Input A expected to strictly deep-equal input B:
    // + expected - actual
    // - 2018-04-26T00:49:08.604Z
    // + Date {}
    
    assert.deepStrictEqual(NaN, NaN);
    // 通过,因为使用的是 SameValue 比较法。
    
    // 解封装后的数值不同:
    assert.deepStrictEqual(new Number(1), new Number(2));
    // AssertionError: Input A expected to strictly deep-equal input B:
    // + expected - actual
    // - [Number: 1]
    // + [Number: 2]
    
    assert.deepStrictEqual(new String('foo'), Object('foo'));
    // 通过,因为对象与解封装后的字符串都完全相同。
    
    assert.deepStrictEqual(-0, -0);
    // 通过。
    
    // SameValue 比较法中 0 与 -0 不同:
    assert.deepStrictEqual(0, -0);
    // AssertionError: Input A expected to strictly deep-equal input B:
    // + expected - actual
    // - 0
    // + -0
    
    const symbol1 = Symbol();
    const symbol2 = Symbol();
    assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });
    // 通过,因为两边对象的 symbol 相同。
    assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 });
    // AssertionError [ERR_ASSERTION]: Input objects not identical:
    // {
    //   [Symbol()]: 1
    // }
    
    const weakMap1 = new WeakMap();
    const weakMap2 = new WeakMap([[{}, {}]]);
    const weakMap3 = new WeakMap();
    weakMap3.unequal = true;
    
    assert.deepStrictEqual(weakMap1, weakMap2);
    // 通过。
    
    // 失败,因为 weakMap3 有一个 weakMap1 没有的属性:
    assert.deepStrictEqual(weakMap1, weakMap3);
    // AssertionError: Input A expected to strictly deep-equal input B:
    // + expected - actual
    //   WeakMap {
    // -   [items unknown]
    // +   [items unknown],
    // +   unequal: true
    //   }
    

    如果两个值不相等,则抛出一个带有 message 属性的 AssertionError,其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined,则赋予默认的错误信息。 如果 message 参数是 Error 的实例,则会抛出它而不是 AssertionError。

    assert.doesNotReject(asyncFn[, error][, message])

    - asyncFn <Function> | <Promise>
    - error <RegExp> | <Function>
    - message <string>
    

    等待asyncFn承诺,或者,如果asyncFn是一个函数,立即调用函数并等待返回的承诺完成。然后它会检查承诺是否被拒绝。

    如果asyncFn是一个函数,它会同步抛出一个错误,assert.doesNotReject()会返回一个带有该错误的拒绝承诺。如果函数不返回一个promise, assert.doesNotReject()将返回一个被拒绝的promise,并且返回一个ERR_INVALID_RETURN_VALUE错误。在这两种情况下都跳过了错误处理程序。

    请注意:使用assert.doesNotReject()实际上是没有用的,因为捕获一个拒绝并再次拒绝它几乎没有什么好处。相反,考虑在特定的代码路径旁边添加一条注释,该注释不应该被拒绝,并尽可能保持错误消息的表达性。

    如果指定,错误可以是类、RegExp或验证函数。有关详细信息,请参阅assert.throw()。

    除了等待完成的异步性质,assert. notthrow()的行为与assert. notthrow()相同。

    (async () => {
      await assert.doesNotReject(
        async () => {
          throw new TypeError('Wrong value');
        },
        SyntaxError
      );
    })();
    
    assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
      .then(() => {
        // ...
      });
    

    assert.doesNotThrow(fn[, error][, message])

    - fn <Function>
    - error <RegExp> | <Function>
    - message <string>
    

    断言函数fn不会抛出错误。

    请注意:使用assert.doesNotThrow()实际上是没有用的,因为捕获错误并重新抛出它没有任何好处。相反,考虑在特定的代码路径旁边添加一条注释,该注释不应该抛出错误消息,并尽可能保持错误消息的表达性。

    当调用assert. notthrow()时,它将立即调用fn函数。

    如果抛出的错误与错误参数指定的类型相同,则抛出AssertionError。如果错误属于另一种类型,或者错误参数未定义,则将错误传播回调用者。

    如果指定,错误可以是类、RegExp或验证函数。有关详细信息,请参阅assert.throw()。

    例如,下面将抛出TypeError,因为断言中没有匹配的错误类型:

    assert.doesNotThrow(
      () => {
        throw new TypeError('Wrong value');
      },
      SyntaxError
    );
    

    但是,下面的消息将导致AssertionError,提示“得到不需要的异常…”

    assert.doesNotThrow(
      () => {
        throw new TypeError('Wrong value');
      },
      TypeError
    );
    

    如果引发了AssertionError,并且为消息参数提供了一个值,那么将向AssertionError消息追加消息的值:

    assert.doesNotThrow(
      () => {
        throw new TypeError('Wrong value');
      },
      /Wrong value/,
      'Whoops'
    );
    // Throws: AssertionError: Got unwanted exception: Whoops
    

    assert.equal(actual, expected[, message])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    

    使用抽象平等比较(==)测试实际参数和预期参数之间的浅层强制平等。

    const assert = require('assert');
    
    assert.equal(1, 1);
    // OK, 1 == 1
    assert.equal(1, '1');
    // OK, 1 == '1'
    
    assert.equal(1, 2);
    // AssertionError: 1 == 2
    assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
    // AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
    

    如果值不相等,将抛出AssertionError,其消息属性设置为等于消息参数的值。如果消息参数未定义,则会分配一个默认错误消息。如果消息参数是错误的实例,那么它将被抛出,而不是AssertionError。

    assert.fail([message])

    - message <string> | <Error> 默认为 'Failed'。
    

    抛出 AssertionError,并带上提供的错误信息或默认的错误信息。 如果 message 参数是 Error 的实例,则会抛出它而不是 AssertionError。

    const assert = require('assert').strict;
    
    assert.fail();
    // 抛出 AssertionError [ERR_ASSERTION]: Failed
    
    assert.fail('失败');
    // 抛出 AssertionError [ERR_ASSERTION]: 失败
    
    assert.fail(new TypeError('失败'));
    // 抛出 TypeError: 失败
    

    使用 assert.fail() 并带上多个参数的方法已被废弃。

    assert.fail(actual, expected[, message[, operator[, stackStartFn]]])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    - operator <string> Default: '!='
    - stackStartFn <Function> Default: assert.fail
    

    如果消息是false,则将错误消息设置为实际值和预期值,由提供的操作符分隔。如果只提供了两个实际的和预期的参数,操作符将默认为’!=’。如果消息作为第三个参数提供,它将用作错误消息,其他参数将作为抛出对象上的属性存储。如果提供了stackStartFn,那么该函数上面的所有堆栈帧都将从stacktrace中删除。如果没有提供参数,将使用默认消息Failed。

    const assert = require('assert').strict;
    
    assert.fail('a', 'b');
    // AssertionError [ERR_ASSERTION]: 'a' != 'b'
    
    assert.fail(1, 2, undefined, '>');
    // AssertionError [ERR_ASSERTION]: 1 > 2
    
    assert.fail(1, 2, 'fail');
    // AssertionError [ERR_ASSERTION]: fail
    
    assert.fail(1, 2, 'whoops', '>');
    // AssertionError [ERR_ASSERTION]: whoops
    
    assert.fail(1, 2, new TypeError('need array'));
    // TypeError: need array
    

    在最后三种情况下,实际的、预期的和操作符对错误消息没有影响。

    例如使用stackStartFn截断异常的stacktrace:

    function suppressFrame() {
      assert.fail('a', 'b', undefined, '!==', suppressFrame);
    }
    suppressFrame();
    // AssertionError [ERR_ASSERTION]: 'a' !== 'b'
    //     at repl:1:1
    //     at ContextifyScript.Script.runInThisContext (vm.js:44:33)
    //     ...
    

    assert.ifError(value)

    - value <any>
    

    如果 value 不为 undefined 或 null,则抛出 value。 可用于测试回调函数的 error 参数。 堆栈踪迹会包含传入 ifError() 的错误的所有帧,包括潜在的 ifError() 自身新增的帧。
    例子:

    const assert = require('assert').strict;
    
    assert.ifError(null);
    // 通过。
    assert.ifError(0);
    // 抛出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
    assert.ifError('错误信息');
    // 抛出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: '错误信息'
    assert.ifError(new Error());
    // 抛出 AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error
    
    // 添加一些错误帧。
    let err;
    (function errorFrame() {
      err = new Error('错误信息');
    })();
    
    (function ifErrorFrame() {
      assert.ifError(err);
    })();
    // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 错误信息
    //     at ifErrorFrame
    //     at errorFrame
    

    assert.notDeepEqual(actual, expected[, message])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    

    测试任何深度的不等式。相反assert.deepEqual()。

    const assert = require('assert');
    
    const obj1 = {
      a: {
        b: 1
      }
    };
    const obj2 = {
      a: {
        b: 2
      }
    };
    const obj3 = {
      a: {
        b: 1
      }
    };
    const obj4 = Object.create(obj1);
    
    assert.notDeepEqual(obj1, obj1);
    // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
    
    assert.notDeepEqual(obj1, obj2);
    // OK
    
    assert.notDeepEqual(obj1, obj3);
    // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
    
    assert.notDeepEqual(obj1, obj4);
    // OK
    

    如果值完全相等,将抛出AssertionError,其消息属性设置为等于消息参数的值。如果消息参数未定义,则会分配一个默认错误消息。如果消息参数是错误的实例,那么它将被抛出,而不是AssertionError。

    assert.notDeepStrictEqual(actual, expected[, message])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    

    测试 actual 参数与 expected 参数是否不深度全等。 与 assert.deepStrictEqual() 相反。

    const assert = require('assert').strict;
    
    assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
    // 测试通过。
    

    如果两个值深度全等,则抛出一个带有 message 属性的 AssertionError,其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined,则赋予默认的错误信息。 如果 message 参数是 Error 的实例,则会抛出它而不是 AssertionError。

    assert.notEqual(actual, expected[, message])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    
    const assert = require('assert');
    
    assert.notEqual(1, 2);
    // OK
    
    assert.notEqual(1, 1);
    // AssertionError: 1 != 1
    
    assert.notEqual(1, '1');
    // AssertionError: 1 != '1'
    

    如果值相等,将抛出AssertionError,其消息属性设置为等于消息参数的值。如果消息参数未定义,则会分配一个默认错误消息。如果消息参数是错误的实例,那么它将被抛出,而不是AssertionError。

    assert.notStrictEqual(actual, expected[, message])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    

    使用 SameValue比较法测试 actual 参数与 expected 参数是否不全等。

    const assert = require('assert').strict;
    
    assert.notStrictEqual(1, 2);
    // 测试通过。
    
    assert.notStrictEqual(1, 1);
    // 抛出 AssertionError [ERR_ASSERTION]: Identical input passed to notStrictEqual: 1
    
    assert.notStrictEqual(1, '1');
    // 测试通过。
    

    如果两个值全等,则抛出一个带有 message 属性的 AssertionError,其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined,则赋予默认的错误信息。 如果 message 参数是 Error 的实例,则会抛出它而不是 AssertionError。

    assert.ok(value[, message])

    - value <any>
    - message <string> | <Error>
    

    测试 value 是否为真值。 相当于 assert.equal(!!value, true, message)。

    如果 value 不为真值,则抛出一个带有 message 属性的 AssertionError,其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined,则赋予默认的错误信息。 如果 message 参数是 Error 的实例,则会抛出它而不是 AssertionError。 如果没有传入参数,则 message 会被设为字符串 'No value argument passed to assert.ok()

    const assert = require('assert').strict;
    
    assert.ok(true);
    // 测试通过。
    assert.ok(1);
    // 测试通过。
    
    assert.ok();
    // 抛出 AssertionError: No value argument passed to `assert.ok()`
    
    assert.ok(false, '不是真值');
    // 抛出 AssertionError: 不是真值
    
    // 在 repl 中:
    assert.ok(typeof 123 === 'string');
    // 抛出 AssertionError: false == true
    
    // 在文件中(例如 test.js):
    assert.ok(typeof 123 === 'string');
    // 抛出 AssertionError: The expression evaluated to a falsy value:
    //
    //   assert.ok(typeof 123 === 'string')
    assert.ok(false);
    // 抛出 AssertionError: The expression evaluated to a falsy value:
    //
    //   assert.ok(false)
    
    assert.ok(0);
    // 抛出 AssertionError: The expression evaluated to a falsy value:
    //
    //   assert.ok(0)
    
    // 等同于 `assert()`:
    assert(0);
    // 抛出 AssertionError: The expression evaluated to a falsy value:
    //
    //   assert(0)
    

    assert.rejects(asyncFn[, error][, message])

    - asyncFn <Function> | <Promise>
    - error <RegExp> | <Function> | <Object> | <Error>
    - message <string>
    

    等待asyncFn承诺,或者,如果asyncFn是一个函数,立即调用函数并等待返回的承诺完成。然后它会检查承诺是否被拒绝。

    如果asyncFn是一个函数,它同步抛出一个错误,assert.reject()会返回一个带有该错误的拒绝承诺。如果函数不返回一个promise, assert.reject()将返回一个拒绝的promise,并且返回一个ERR_INVALID_RETURN_VALUE错误。在这两种情况下都跳过了错误处理程序。

    除了等待完成的异步性质之外,assert.throw()的行为也一样。

    如果指定,错误可以是类、RegExp、验证函数、测试每个属性的对象或测试每个属性的错误实例(包括不可枚举的消息和名称属性)。

    如果指定了,如果asyncFn拒绝,消息将是AssertionError提供的消息。

    (async () => {
      await assert.rejects(
        async () => {
          throw new TypeError('Wrong value');
        },
        {
          name: 'TypeError',
          message: 'Wrong value'
        }
      );
    })();
    
    assert.rejects(
      Promise.reject(new Error('Wrong value')),
      Error
    ).then(() => {
      // ...
    });
    

    注意,错误不能是字符串。如果提供了一个字符串作为第二个参数,则假定忽略了错误,该字符串将被用于消息。这会导致容易忽略的错误。如果考虑使用字符串作为第二个参数,请仔细阅读assert.throw()中的示例。

    assert.strictEqual(actual, expected[, message])

    - actual <any>
    - expected <any>
    - message <string> | <Error>
    

    使用 SameValue比较法测试 actual 参数与 expected 参数是否全等。

    const assert = require('assert').strict;
    
    assert.strictEqual(1, 2);
    // 抛出 AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:
    // + expected - actual
    // - 1
    // + 2
    
    assert.strictEqual(1, 1);
    // 测试通过。
    
    assert.strictEqual(1, '1');
    // 抛出 AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:
    // + expected - actual
    // - 1
    // + '1'
    

    如果两个值不全等,则抛出一个带有 message 属性的 AssertionError,其中 message 属性的值等于传入的 message 参数的值。 如果 message 参数为 undefined,则赋予默认的错误信息。 如果 message 参数是 Error 的实例,则会抛出它而不是 AssertionError。

    assert.throws(fn[, error][, message])

    - fn <Function>
    - error <RegExp> | <Function> | <Object> | <Error>
    - message <string>
    

    期望函数fn抛出一个错误。

    如果指定,错误可以是类、RegExp、验证函数、验证对象,其中每个属性都将被测试为严格的深度相等,或者错误实例,其中每个属性都将被测试为严格的深度相等,包括不可枚举的消息和名称属性。在使用对象时,在对字符串属性进行验证时,也可以使用正则表达式。下面是一些例子。

    如果指定,如果fn调用未能抛出或错误验证失败,则会将消息追加到AssertionError提供的消息中。

    自定义验证对象/错误实例:

    const err = new TypeError('Wrong value');
    err.code = 404;
    err.foo = 'bar';
    err.info = {
      nested: true,
      baz: 'text'
    };
    err.reg = /abc/i;
    
    assert.throws(
      () => {
        throw err;
      },
      {
        name: 'TypeError',
        message: 'Wrong value',
        info: {
          nested: true,
          baz: 'text'
        }
        // Note that only properties on the validation object will be tested for.
        // Using nested objects requires all properties to be present. Otherwise
        // the validation is going to fail.
      }
    );
    
    // Using regular expressions to validate error properties:
    assert.throws(
      () => {
        throw err;
      },
      {
        // The `name` and `message` properties are strings and using regular
        // expressions on those will match against the string. If they fail, an
        // error is thrown.
        name: /^TypeError$/,
        message: /Wrong/,
        foo: 'bar',
        info: {
          nested: true,
          // It is not possible to use regular expressions for nested properties!
          baz: 'text'
        },
        // The `reg` property contains a regular expression and only if the
        // validation object contains an identical regular expression, it is going
        // to pass.
        reg: /abc/i
      }
    );
    
    // Fails due to the different `message` and `name` properties:
    assert.throws(
      () => {
        const otherErr = new Error('Not found');
        otherErr.code = 404;
        throw otherErr;
      },
      err // This tests for `message`, `name` and `code`.
    );
    

    Validate instanceof using constructor:

    assert.throws(
      () => {
        throw new Error('Wrong value');
      },
      Error
    );
    

    使用RegExp验证错误消息:

    使用正则表达式在错误对象上运行. tostring,因此还将包含错误名称。

    assert.throws(
      () => {
        throw new Error('Wrong value');
      },
      /^Error: Wrong value$/
    );
    

    自定义错误验证:

    assert.throws(
      () => {
        throw new Error('Wrong value');
      },
      function(err) {
        if ((err instanceof Error) && /value/.test(err)) {
          return true;
        }
      },
      'unexpected error'
    );
    

    注意,错误不能是字符串。如果提供了一个字符串作为第二个参数,则假定忽略了错误,该字符串将被用于消息。这会导致容易忽略的错误。使用与抛出错误消息相同的消息将导致err_ous_argument错误。如果考虑使用字符串作为第二个参数,请仔细阅读下面的示例:

    function throwingFirst() {
      throw new Error('First');
    }
    function throwingSecond() {
      throw new Error('Second');
    }
    function notThrowing() {}
    
    // The second argument is a string and the input function threw an Error.
    // The first case will not throw as it does not match for the error message
    // thrown by the input function!
    assert.throws(throwingFirst, 'Second');
    // In the next example the message has no benefit over the message from the
    // error and since it is not clear if the user intended to actually match
    // against the error message, Node.js thrown an `ERR_AMBIGUOUS_ARGUMENT` error.
    assert.throws(throwingSecond, 'Second');
    // Throws an error:
    // TypeError [ERR_AMBIGUOUS_ARGUMENT]
    
    // The string is only used (as message) in case the function does not throw:
    assert.throws(notThrowing, 'Second');
    // AssertionError [ERR_ASSERTION]: Missing expected exception: Second
    
    // If it was intended to match for the error message do this instead:
    assert.throws(throwingSecond, /Second$/);
    // Does not throw because the error messages match.
    assert.throws(throwingFirst, /Second$/);
    // Throws an error:
    // Error: First
    //     at throwingFirst (repl:2:9)
    

    由于符号混乱,建议不要使用字符串作为第二个参数。这可能会导致难以发现的错误。

    展开全文
  • 使用assert断言是学习assert 断言句语格式及用法很简单。在没完善一个程序之前,我们不知道程序在哪里会出错,与其让它在运行最崩溃,不如在出现错误条件时就崩溃,这时候就需要assert断言的帮助。本文主要是讲...
  • assert断言用法

    2019-09-30 16:46:37
    使用assert断言是学习python一个非常好的习惯,python assert 断言句语格式及用法很简单。在没完善一个程序之前,我们不知道程序在哪里会出错,与其让它在运行最崩溃,不如在出现错误条件时就崩溃,这时候就需要...
  • Python assert 断言函数

    2019-11-14 09:43:29
    使用assert断言是学习python一个非常好的习惯,python assert 断言句语格式及用法很简单。在没完善一个程序之前,我们不知道程序在哪里会出错,与其让它在运行最崩溃,不如在出现错误条件时就崩溃,这时候就需要...
  • python assert断言

    2019-04-20 13:37:26
    使用assert断言是学习python一个非常好的习惯,pythonassert 断言句语格式及用法很简单。在没完善一个程序之前,我们不知道程序在哪里会出错,与其让它在运行最崩溃,不如在出现错误条件时就崩溃,这时候就需要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,624
精华内容 25,849
关键字:

assert断言