1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
/*! * chai * http://chaijs.com * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com> * MIT Licensed */
var config = require('./config');
module.exports = function (_chai, util) {  /*!   * Module dependencies.   */
  var AssertionError = _chai.AssertionError    , flag = util.flag;
  /*!   * Module export.   */
  _chai.Assertion = Assertion;
  /*!   * Assertion Constructor   *   * Creates object for chaining.   *   * `Assertion` objects contain metadata in the form of flags. Three flags can   * be assigned during instantiation by passing arguments to this constructor:   *   * - `object`: This flag contains the target of the assertion. For example, in   *   the assertion `expect(numKittens).to.equal(7);`, the `object` flag will   *   contain `numKittens` so that the `equal` assertion can reference it when   *   needed.   *   * - `message`: This flag contains an optional custom error message to be   *   prepended to the error message that's generated by the assertion when it   *   fails.   *   * - `ssfi`: This flag stands for "start stack function indicator". It   *   contains a function reference that serves as the starting point for   *   removing frames from the stack trace of the error that's created by the   *   assertion when it fails. The goal is to provide a cleaner stack trace to   *   end users by removing Chai's internal functions. Note that it only works   *   in environments that support `Error.captureStackTrace`, and only when   *   `Chai.config.includeStack` hasn't been set to `false`.   *   * - `lockSsfi`: This flag controls whether or not the given `ssfi` flag   *   should retain its current value, even as assertions are chained off of   *   this object. This is usually set to `true` when creating a new assertion   *   from within another assertion. It's also temporarily set to `true` before   *   an overwritten assertion gets called by the overwriting assertion.   *   * @param {Mixed} obj target of the assertion   * @param {String} msg (optional) custom error message   * @param {Function} ssfi (optional) starting point for removing stack frames   * @param {Boolean} lockSsfi (optional) whether or not the ssfi flag is locked   * @api private   */
  function Assertion (obj, msg, ssfi, lockSsfi) {    flag(this, 'ssfi', ssfi || Assertion);    flag(this, 'lockSsfi', lockSsfi);    flag(this, 'object', obj);    flag(this, 'message', msg);
    return util.proxify(this);  }
  Object.defineProperty(Assertion, 'includeStack', {    get: function() {      console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');      return config.includeStack;    },    set: function(value) {      console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');      config.includeStack = value;    }  });
  Object.defineProperty(Assertion, 'showDiff', {    get: function() {      console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');      return config.showDiff;    },    set: function(value) {      console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');      config.showDiff = value;    }  });
  Assertion.addProperty = function (name, fn) {    util.addProperty(this.prototype, name, fn);  };
  Assertion.addMethod = function (name, fn) {    util.addMethod(this.prototype, name, fn);  };
  Assertion.addChainableMethod = function (name, fn, chainingBehavior) {    util.addChainableMethod(this.prototype, name, fn, chainingBehavior);  };
  Assertion.overwriteProperty = function (name, fn) {    util.overwriteProperty(this.prototype, name, fn);  };
  Assertion.overwriteMethod = function (name, fn) {    util.overwriteMethod(this.prototype, name, fn);  };
  Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {    util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);  };
  /**   * ### .assert(expression, message, negateMessage, expected, actual, showDiff)   *   * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.   *   * @name assert   * @param {Philosophical} expression to be tested   * @param {String|Function} message or function that returns message to display if expression fails   * @param {String|Function} negatedMessage or function that returns negatedMessage to display if negated expression fails   * @param {Mixed} expected value (remember to check for negation)   * @param {Mixed} actual (optional) will default to `this.obj`   * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails   * @api private   */
  Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {    var ok = util.test(this, arguments);    if (false !== showDiff) showDiff = true;    if (undefined === expected && undefined === _actual) showDiff = false;    if (true !== config.showDiff) showDiff = false;
    if (!ok) {      msg = util.getMessage(this, arguments);      var actual = util.getActual(this, arguments);      var assertionErrorObjectProperties = {          actual: actual        , expected: expected        , showDiff: showDiff      };
      var operator = util.getOperator(this, arguments);      if (operator) {        assertionErrorObjectProperties.operator = operator;      }
      throw new AssertionError(        msg,        assertionErrorObjectProperties,        (config.includeStack) ? this.assert : flag(this, 'ssfi'));    }  };
  /*!   * ### ._obj   *   * Quick reference to stored `actual` value for plugin developers.   *   * @api private   */
  Object.defineProperty(Assertion.prototype, '_obj',    { get: function () {        return flag(this, 'object');      }    , set: function (val) {        flag(this, 'object', val);      }  });};