Changeset 206237 in webkit


Ignore:
Timestamp:
Sep 21, 2016 2:40:22 PM (8 years ago)
Author:
Matt Baker
Message:

Web Inspector: Improve output of TestHarness.expect* failures
​https://bugs.webkit.org/show_bug.cgi?id=162177
<rdar://problem/28367186>

Reviewed by Joseph Pecoraro.

Source/WebInspectorUI:

This patch adds specific expectation functions to TestHarness, to better
express intent when writing tests, and to allow more details to be logged
in the event of a failure.

For functions taking both actual and expected parameters, the actual
parameter comes first. This convention simplifies the implementation of
TestHarness, improves the readability of tests involving inequalities,
and is consistent with XCTest assertions.

  • UserInterface/Test/TestHarness.js:

(TestHarness):
(TestHarness.prototype.expectThat):
(TestHarness.prototype.expectFalse):
(TestHarness.prototype.expectNull):
(TestHarness.prototype.expectNotNull):
(TestHarness.prototype.expectEqual):
(TestHarness.prototype.expectNotEqual):
(TestHarness.prototype.expectShallowEqual):
(TestHarness.prototype.expectNotShallowEqual):
(TestHarness.prototype.expectEqualWithAccuracy):
(TestHarness.prototype.expectLessThan):
(TestHarness.prototype.expectLessThanOrEqual):
(TestHarness.prototype.expectGreaterThan):
(TestHarness.prototype.expectGreaterThanOrEqual):
New expectation functions, all of which call _expect under the hood.

(TestHarness.prototype._expect):
Helper method which calls pass or fail. Creates a message when no user
message is provided, and logs expected and actual values in the event
of a failure.

(TestHarness.prototype._expectationValueAsString):
(TestHarness.prototype._expectationMessageFormat):
Get a message format string for the expectation type. Used to create
pass/fail message when no user message is provided.

(TestHarness.prototype._expectedValueFormat):
Get a format string for displaying the expected value. Used to create
the "Expected: " failure message line.

LayoutTests:

Extend coverage to more TestHarness messages by omitting the optional
message parameter when calling expect* functions.

Other improvements:

  • expectEqual/expectNotEqual should test WebInspector object instances, to cover more TestHarness message formatting cases.
  • expectEqual/expectNotEqual should test shallow equal arrays, since the test is for strict equality.
  • inspector/indexeddb/requestData-expected.txt:
  • inspector/unit-tests/number-utilities-expected.txt:

Updated expectations for new TestHarness output.

  • inspector/unit-tests/test-harness-expect-functions-expected.txt:
  • inspector/unit-tests/test-harness-expect-functions.html:
Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r206232 r206237  
     12016-09-21  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Improve output of TestHarness.expect* failures
     4        https://bugs.webkit.org/show_bug.cgi?id=162177
     5        <rdar://problem/28367186>
     6
     7        Reviewed by Joseph Pecoraro.
     8
     9        Extend coverage to more TestHarness messages by omitting the optional
     10        `message` parameter when calling expect* functions.
     11
     12        Other improvements:
     13        - expectEqual/expectNotEqual should test WebInspector object instances,
     14          to cover more TestHarness message formatting cases.
     15        - expectEqual/expectNotEqual should test shallow equal arrays, since the
     16          test is for strict equality.
     17
     18        * inspector/indexeddb/requestData-expected.txt:
     19        * inspector/unit-tests/number-utilities-expected.txt:
     20        Updated expectations for new TestHarness output.
     21
     22        * inspector/unit-tests/test-harness-expect-functions-expected.txt:
     23        * inspector/unit-tests/test-harness-expect-functions.html:
     24
    1252016-09-21  Ryan Haddad  <ryanhaddad@apple.com>
    226

  • trunk/LayoutTests/inspector/indexeddb/requestData-expected.txt

    r205086 r206237  
    4242PASS: Value should be a remote object for: 'Monstrous Beaver'
    4343FAIL: Primary key should be ordered by email: 2
     44    Expected: truthy
     45    Actual: false
    4446PASS: Key should be ordered by email: 'hampster@webkit.org'
    4547PASS: Value should be a remote object for: 'Thirsty Hampster'
    4648FAIL: Primary key should be ordered by email: 1
     49    Expected: truthy
     50    Actual: false
    4751PASS: Key should be ordered by email: 'peacock@webkit.org'
    4852PASS: Value should be a remote object for: 'Jamming Peacock'

  • trunk/LayoutTests/inspector/unit-tests/number-utilities-expected.txt

    r199635 r206237  
    1313PASS: constrain of a value above max becomes max
    1414FAIL: constrain of NaN becomes min
     15    Expected: truthy
     16    Actual: false
    1517
    1618-- Running test case: Number.secondsToString

  • trunk/LayoutTests/inspector/unit-tests/test-harness-expect-functions-expected.txt

    r205834 r206237  
    1212Expected to FAIL
    1313FAIL: expectThat(false)
     14    Expected: truthy
     15    Actual: false
    1416FAIL: expectThat(0)
     17    Expected: truthy
     18    Actual: 0
    1519FAIL: expectThat("")
     20    Expected: truthy
     21    Actual: ""
    1622FAIL: expectThat(null)
     23    Expected: truthy
     24    Actual: null
    1725FAIL: expectThat(undefined)
     26    Expected: truthy
     27    Actual: undefined
    1828FAIL: expectThat(NaN)
     29    Expected: truthy
     30    Actual: NaN
    1931
    2032-- Running test case: InspectorTest.expectFalse
    … …  
    2840Expected to FAIL
    2941FAIL: expectFalse(true)
     42    Expected: falsey
     43    Actual: true
    3044FAIL: expectFalse(1)
     45    Expected: falsey
     46    Actual: 1
    3147FAIL: expectFalse("abc")
     48    Expected: falsey
     49    Actual: "abc"
    3250FAIL: expectFalse({})
     51    Expected: falsey
     52    Actual: {}
    3353FAIL: expectFalse([])
     54    Expected: falsey
     55    Actual: []
    3456
    3557-- Running test case: InspectorTest.expectNull
    … …  
    3860Expected to FAIL
    3961FAIL: expectNull(true)
     62    Expected: null
     63    Actual: true
    4064FAIL: expectNull(false)
     65    Expected: null
     66    Actual: false
    4167FAIL: expectNull(1)
     68    Expected: null
     69    Actual: 1
    4270FAIL: expectNull("")
     71    Expected: null
     72    Actual: ""
    4373FAIL: expectNull(undefined)
     74    Expected: null
     75    Actual: undefined
    4476FAIL: expectNull({})
     77    Expected: null
     78    Actual: {}
    4579FAIL: expectNull([])
     80    Expected: null
     81    Actual: []
    4682
    4783-- Running test case: InspectorTest.expectNotNull
    … …  
    5692Expected to FAIL
    5793FAIL: expectNotNull(null)
     94    Expected: not null
     95    Actual: null
    5896
    5997-- Running test case: InspectorTest.expectEqual
    … …  
    6199PASS: expectEqual(true, true)
    62100PASS: expectEqual({"a":1,"b":2}, {"a":1,"b":2})
     101PASS: expectEqual(CSSStyleDeclaration instance #1, CSSStyleDeclaration instance #1)
    63102PASS: expectEqual(1.23, 1.23)
    64103PASS: expectEqual("abc", "abc")
    … …  
    67106Expected to FAIL
    68107FAIL: expectEqual(true, false)
    69 FAIL: expectEqual({"a":1,"b":2}, {"c":3,"d":4})
     108    Expected: false
     109    Actual: true
     110FAIL: expectEqual({"a":1,"b":2}, {"a":1,"b":2})
     111    Expected: {"a":1,"b":2}
     112    Actual: {"a":1,"b":2}
     113FAIL: expectEqual(CSSStyleDeclaration instance #1, CSSRule instance #2)
     114    Expected: CSSRule instance #2
     115    Actual: CSSStyleDeclaration instance #1
    70116FAIL: expectEqual(1.23, 4.56)
     117    Expected: 4.56
     118    Actual: 1.23
    71119FAIL: expectEqual("abc", "def")
     120    Expected: "def"
     121    Actual: "abc"
    72122FAIL: expectEqual(null, undefined)
     123    Expected: undefined
     124    Actual: null
    73125FAIL: expectEqual(NaN, NaN)
     126    Expected: NaN
     127    Actual: NaN
    74128FAIL: expectEqual({}, {})
     129    Expected: {}
     130    Actual: {}
    75131FAIL: expectEqual([], [])
     132    Expected: []
     133    Actual: []
    76134
    77135-- Running test case: InspectorTest.expectNotEqual
    78136Expected to PASS
    79137PASS: expectNotEqual(true, false)
    80 PASS: expectNotEqual({"a":1,"b":2}, {"c":3,"d":4})
     138PASS: expectNotEqual({"a":1,"b":2}, {"a":1,"b":2})
     139PASS: expectNotEqual(CSSStyleDeclaration instance #1, CSSRule instance #2)
    81140PASS: expectNotEqual(1.23, 4.56)
    82141PASS: expectNotEqual("abc", "def")
    … …  
    87146Expected to FAIL
    88147FAIL: expectNotEqual(true, true)
     148    Expected: not true
     149    Actual: true
    89150FAIL: expectNotEqual({"a":1,"b":2}, {"a":1,"b":2})
     151    Expected: not {"a":1,"b":2}
     152    Actual: {"a":1,"b":2}
     153FAIL: expectNotEqual(CSSStyleDeclaration instance #1, CSSStyleDeclaration instance #1)
     154    Expected: not CSSStyleDeclaration instance #1
     155    Actual: CSSStyleDeclaration instance #1
    90156FAIL: expectNotEqual(1.23, 1.23)
     157    Expected: not 1.23
     158    Actual: 1.23
    91159FAIL: expectNotEqual("abc", "abc")
     160    Expected: not "abc"
     161    Actual: "abc"
    92162FAIL: expectNotEqual(null, null)
     163    Expected: not null
     164    Actual: null
    93165FAIL: expectNotEqual(undefined, undefined)
     166    Expected: not undefined
     167    Actual: undefined
    94168
    95169-- Running test case: InspectorTest.expectShallowEqual
    … …  
    100174Expected to FAIL
    101175FAIL: expectShallowEqual({"a":1,"b":2}, {"a":3,"b":4})
     176    Expected: {"a":3,"b":4}
     177    Actual: {"a":1,"b":2}
    102178FAIL: expectShallowEqual({}, [])
     179    Expected: []
     180    Actual: {}
    103181
    104182-- Running test case: InspectorTest.expectNotShallowEqual
    … …  
    108186Expected to FAIL
    109187FAIL: expectNotShallowEqual({"a":1,"b":2}, {"a":1,"b":2})
     188    Expected: not {"a":1,"b":2}
     189    Actual: {"a":1,"b":2}
    110190FAIL: expectNotShallowEqual({}, {})
     191    Expected: not {}
     192    Actual: {}
    111193FAIL: expectNotShallowEqual([], [])
     194    Expected: not []
     195    Actual: []
    112196
    113197-- Running test case: InspectorTest.expectEqualWithAccuracy
    … …  
    119203Expected to FAIL
    120204FAIL: expectEqualWithAccuracy(0, 2, 1)
     205    Expected: 2 +/- 1
     206    Actual: 0
    121207FAIL: expectEqualWithAccuracy(2, 0, 1)
     208    Expected: 0 +/- 1
     209    Actual: 2
    122210
    123211-- Running test case: InspectorTest.expectLessThan
    … …  
    127215Expected to FAIL
    128216FAIL: expectLessThan(0, 0)
     217    Expected: less than 0
     218    Actual: 0
    129219FAIL: expectLessThan(1, 0)
     220    Expected: less than 0
     221    Actual: 1
    130222FAIL: expectLessThan("abc", "abc")
     223    Expected: less than "abc"
     224    Actual: "abc"
    131225FAIL: expectLessThan("def", "abc")
     226    Expected: less than "abc"
     227    Actual: "def"
    132228
    133229-- Running test case: InspectorTest.expectLessThanOrEqual
    … …  
    139235Expected to FAIL
    140236FAIL: expectLessThanOrEqual(1, 0)
     237    Expected: less than or equal to 0
     238    Actual: 1
    141239FAIL: expectLessThanOrEqual("def", "abc")
     240    Expected: less than or equal to "abc"
     241    Actual: "def"
    142242
    143243-- Running test case: InspectorTest.expectGreaterThan
    … …  
    147247Expected to FAIL
    148248FAIL: expectGreaterThan(0, 0)
     249    Expected: greater than 0
     250    Actual: 0
    149251FAIL: expectGreaterThan(0, 1)
     252    Expected: greater than 1
     253    Actual: 0
    150254FAIL: expectGreaterThan("abc", "abc")
     255    Expected: greater than "abc"
     256    Actual: "abc"
    151257FAIL: expectGreaterThan("abc", "def")
     258    Expected: greater than "def"
     259    Actual: "abc"
    152260
    153261-- Running test case: InspectorTest.expectGreaterThanOrEqual
    … …  
    159267Expected to FAIL
    160268FAIL: expectGreaterThanOrEqual(0, 1)
     269    Expected: greater than or equal to 1
     270    Actual: 0
    161271FAIL: expectGreaterThanOrEqual("abc", "def")
    162 
     272    Expected: greater than or equal to "def"
     273    Actual: "abc"
     274

  • trunk/LayoutTests/inspector/unit-tests/test-harness-expect-functions.html

    r205834 r206237  
    66function test()
    77{
    8     console.assert(false, "FAIL ASSERTION!!!!!!!");
    9 
    108    let suite = InspectorTest.createSyncSuite("InspectorTestExpectFunctions");
    119
    1210    function toArray(a) {
    1311        return a instanceof Array && a.length ? a : [a];
    14     }
    15 
    16     function stringifyArguments(args) {
    17         return args.map((a) => {
    18             if (typeof a === "number")
    19                 return a;
    20             // Append empty string so `undefined` is displayed correctly.
    21             return JSON.stringify(a) + "";
    22         }).join(", ");
    2312    }
    2413
    … …  
    3726
    3827                    InspectorTest.log("Expected to " + (shouldPass ? "PASS" : "FAIL"));
    39                     for (let input of inputs.map(toArray)) {
    40                         let argumentsString = stringifyArguments(input);
    41                         functionUnderTest.call(InspectorTest, ...input, `${functionName}(${argumentsString})`);
    42                     }
     28                    for (let input of inputs.map(toArray))
     29                        functionUnderTest.call(InspectorTest, ...input);
    4330                }
    4431
    … …  
    7158
    7259    let object1 = {a: 1, b: 2};
    73     let object2 = {c: 3, d: 4};
     60    let object2 = {a: 1, b: 2};
     61    let customObject1 = new WebInspector.CSSStyleDeclaration;
     62    let customObject2 = new WebInspector.CSSRule;
    7463    let expectEqualTestCase = {
    7564        functionName: "expectEqual",
    … …  
    7766            [true, true],
    7867            [object1, object1],
     68            [customObject1, customObject1],
    7969            [1.23, 1.23],
    8070            ["abc", "abc"],
    … …  
    8575            [true, false],
    8676            [object1, object2],
     77            [customObject1, customObject2],
    8778            [1.23, 4.56],
    8879            ["abc", "def"],

  • trunk/Source/WebInspectorUI/ChangeLog

    r206195 r206237  
     12016-09-21  Matt Baker  <mattbaker@apple.com>
     2
     3        Web Inspector: Improve output of TestHarness.expect* failures
     4        https://bugs.webkit.org/show_bug.cgi?id=162177
     5        <rdar://problem/28367186>
     6
     7        Reviewed by Joseph Pecoraro.
     8
     9        This patch adds specific expectation functions to TestHarness, to better
     10        express intent when writing tests, and to allow more details to be logged
     11        in the event of a failure.
     12
     13        For functions taking both `actual` and `expected` parameters, the `actual`
     14        parameter comes first. This convention simplifies the implementation of
     15        TestHarness, improves the readability of tests involving inequalities,
     16        and is consistent with XCTest assertions.
     17
     18        * UserInterface/Test/TestHarness.js:
     19        (TestHarness):
     20        (TestHarness.prototype.expectThat):
     21        (TestHarness.prototype.expectFalse):
     22        (TestHarness.prototype.expectNull):
     23        (TestHarness.prototype.expectNotNull):
     24        (TestHarness.prototype.expectEqual):
     25        (TestHarness.prototype.expectNotEqual):
     26        (TestHarness.prototype.expectShallowEqual):
     27        (TestHarness.prototype.expectNotShallowEqual):
     28        (TestHarness.prototype.expectEqualWithAccuracy):
     29        (TestHarness.prototype.expectLessThan):
     30        (TestHarness.prototype.expectLessThanOrEqual):
     31        (TestHarness.prototype.expectGreaterThan):
     32        (TestHarness.prototype.expectGreaterThanOrEqual):
     33        New expectation functions, all of which call _expect under the hood.
     34
     35        (TestHarness.prototype._expect):
     36        Helper method which calls pass or fail. Creates a message when no user
     37        message is provided, and logs expected and actual values in the event
     38        of a failure.
     39
     40        (TestHarness.prototype._expectationValueAsString):
     41        (TestHarness.prototype._expectationMessageFormat):
     42        Get a message format string for the expectation type. Used to create
     43        pass/fail message when no user message is provided.
     44
     45        (TestHarness.prototype._expectedValueFormat):
     46        Get a format string for displaying the expected value. Used to create
     47        the "Expected: " failure message line.
     48
    1492016-09-20  Joseph Pecoraro  <pecoraro@apple.com>
    250

  • trunk/Source/WebInspectorUI/UserInterface/Test/TestHarness.js

    r205834 r206237  
    3131
    3232        this._logCount = 0;
     33        this._failureObjects = new Map;
     34        this._failureObjectIdentifier = 1;
    3335    }
    3436
    … …  
    9294    }
    9395
    94     expectThat(condition, message)
    95     {
    96         if (condition)
    97             this.pass(message);
    98         else
    99             this.fail(message);
    100     }
    101 
    102     expectFalse(expression, message)
    103     {
    104         this.expectThat(!expression, message);
    105     }
    106 
    107     expectNull(expression, message)
    108     {
    109         this.expectThat(expression === null, message);
    110     }
    111 
    112     expectNotNull(expression, message)
    113     {
    114         this.expectThat(expression !== null, message);
    115     }
    116 
    117     expectEqual(expression1, expression2, message)
    118     {
    119         this.expectThat(expression1 === expression2, message);
    120     }
    121 
    122     expectNotEqual(expression1, expression2, message)
    123     {
    124         this.expectThat(expression1 !== expression2, message);
    125     }
    126 
    127     expectShallowEqual(expression1, expression2, message)
    128     {
    129         this.expectThat(Object.shallowEqual(expression1, expression2), message);
    130     }
    131 
    132     expectNotShallowEqual(expression1, expression2, message)
    133     {
    134         this.expectThat(!Object.shallowEqual(expression1, expression2), message);
    135     }
    136 
    137     expectEqualWithAccuracy(expression1, expression2, accuracy, message)
    138     {
    139         console.assert(typeof expression1 === "number");
    140         console.assert(typeof expression2 === "number");
    141         this.expectThat(Math.abs(expression1 - expression2) <= accuracy, message);
    142     }
    143 
    144     expectLessThan(expression1, expression2, message)
    145     {
    146         this.expectThat(expression1 < expression2, message);
    147     }
    148 
    149     expectLessThanOrEqual(expression1, expression2, message)
    150     {
    151         this.expectThat(expression1 <= expression2, message);
    152     }
    153 
    154     expectGreaterThan(expression1, expression2, message)
    155     {
    156         this.expectThat(expression1 > expression2, message);
    157     }
    158 
    159     expectGreaterThanOrEqual(expression1, expression2, message)
    160     {
    161         this.expectThat(expression1 >= expression2, message);
     96    expectThat(actual, message)
     97    {
     98        this._expect(TestHarness.ExpectationType.True, !!actual, message, actual);
     99    }
     100
     101    expectFalse(actual, message)
     102    {
     103        this._expect(TestHarness.ExpectationType.False, !actual, message, actual);
     104    }
     105
     106    expectNull(actual, message)
     107    {
     108        this._expect(TestHarness.ExpectationType.Null, actual === null, message, actual, null);
     109    }
     110
     111    expectNotNull(actual, message)
     112    {
     113        this._expect(TestHarness.ExpectationType.NotNull, actual !== null, message, actual);
     114    }
     115
     116    expectEqual(actual, expected, message)
     117    {
     118        this._expect(TestHarness.ExpectationType.Equal, expected === actual, message, actual, expected);
     119    }
     120
     121    expectNotEqual(actual, expected, message)
     122    {
     123        this._expect(TestHarness.ExpectationType.NotEqual, expected !== actual, message, actual, expected);
     124    }
     125
     126    expectShallowEqual(actual, expected, message)
     127    {
     128        this._expect(TestHarness.ExpectationType.ShallowEqual, Object.shallowEqual(actual, expected), message, actual, expected);
     129    }
     130
     131    expectNotShallowEqual(actual, expected, message)
     132    {
     133        this._expect(TestHarness.ExpectationType.NotShallowEqual, !Object.shallowEqual(actual, expected), message, actual, expected);
     134    }
     135
     136    expectEqualWithAccuracy(actual, expected, accuracy, message)
     137    {
     138        console.assert(typeof expected === "number");
     139        console.assert(typeof actual === "number");
     140
     141        this._expect(TestHarness.ExpectationType.EqualWithAccuracy, Math.abs(expected - actual) <= accuracy, message, actual, expected, accuracy);
     142    }
     143
     144    expectLessThan(actual, expected, message)
     145    {
     146        this._expect(TestHarness.ExpectationType.LessThan, actual < expected, message, actual, expected);
     147    }
     148
     149    expectLessThanOrEqual(actual, expected, message)
     150    {
     151        this._expect(TestHarness.ExpectationType.LessThanOrEqual, actual <= expected, message, actual, expected);
     152    }
     153
     154    expectGreaterThan(actual, expected, message)
     155    {
     156        this._expect(TestHarness.ExpectationType.GreaterThan, actual > expected, message, actual, expected);
     157    }
     158
     159    expectGreaterThanOrEqual(actual, expected, message)
     160    {
     161        this._expect(TestHarness.ExpectationType.GreaterThanOrEqual, actual >= expected, message, actual, expected);
    162162    }
    163163
    … …  
    183183        return (typeof message !== "string") ? JSON.stringify(message) : message;
    184184    }
     185
     186    // Private
     187
     188    _expect(type, condition, message, ...values)
     189    {
     190        console.assert(values.length > 0, "Should have an 'actual' value.");
     191
     192        if (!message || !condition) {
     193            values = values.map(this._expectationValueAsString.bind(this));
     194            message = message || this._expectationMessageFormat(type).format(...values);
     195        }
     196
     197        if (condition) {
     198            this.pass(message);
     199            return;
     200        }
     201
     202        message += "\n    Expected: " + this._expectedValueFormat(type).format(...values.slice(1));
     203        message += "\n    Actual: " + values[0];
     204
     205        this.fail(message);
     206    }
     207
     208    _expectationValueAsString(value)
     209    {
     210        let instanceIdentifier = (object) => {
     211            let id = this._failureObjects.get(object);
     212            if (!id) {
     213                id = this._failureObjectIdentifier++;
     214                this._failureObjects.set(object, id);
     215            }
     216            return "#" + id;
     217        };
     218
     219        const maximumValueStringLength = 200;
     220        const defaultValueString = String(new Object); // [object Object]
     221
     222        // Special case for numbers, since JSON.stringify converts Infinity and NaN to null.
     223        if (typeof value === "number")
     224            return value;
     225
     226        try {
     227            let valueString = JSON.stringify(value);
     228            if (valueString.length <= maximumValueStringLength)
     229                return valueString;
     230        } catch (e) {}
     231
     232        try {
     233            let valueString = String(value);
     234            if (valueString === defaultValueString && value.constructor && value.constructor.name !== "Object")
     235                return value.constructor.name + " instance " + instanceIdentifier(value);
     236            return valueString;
     237        } catch (e) {
     238            return defaultValueString;
     239        }
     240    }
     241
     242    _expectationMessageFormat(type)
     243    {
     244        switch (type) {
     245        case TestHarness.ExpectationType.True:
     246            return "expectThat(%s)";
     247        case TestHarness.ExpectationType.False:
     248            return "expectFalse(%s)";
     249        case TestHarness.ExpectationType.Null:
     250            return "expectNull(%s)";
     251        case TestHarness.ExpectationType.NotNull:
     252            return "expectNotNull(%s)";
     253        case TestHarness.ExpectationType.Equal:
     254            return "expectEqual(%s, %s)";
     255        case TestHarness.ExpectationType.NotEqual:
     256            return "expectNotEqual(%s, %s)";
     257        case TestHarness.ExpectationType.ShallowEqual:
     258            return "expectShallowEqual(%s, %s)";
     259        case TestHarness.ExpectationType.NotShallowEqual:
     260            return "expectNotShallowEqual(%s, %s)";
     261        case TestHarness.ExpectationType.EqualWithAccuracy:
     262            return "expectEqualWithAccuracy(%s, %s, %s)";
     263        case TestHarness.ExpectationType.LessThan:
     264            return "expectLessThan(%s, %s)";
     265        case TestHarness.ExpectationType.LessThanOrEqual:
     266            return "expectLessThanOrEqual(%s, %s)";
     267        case TestHarness.ExpectationType.GreaterThan:
     268            return "expectGreaterThan(%s, %s)";
     269        case TestHarness.ExpectationType.GreaterThanOrEqual:
     270            return "expectGreaterThanOrEqual(%s, %s)";
     271        default:
     272            console.error("Unknown TestHarness.ExpectationType type: " + type);
     273            return null;
     274        }
     275    }
     276
     277    _expectedValueFormat(type)
     278    {
     279        switch (type) {
     280        case TestHarness.ExpectationType.True:
     281            return "truthy";
     282        case TestHarness.ExpectationType.False:
     283            return "falsey";
     284        case TestHarness.ExpectationType.NotNull:
     285            return "not null";
     286        case TestHarness.ExpectationType.NotEqual:
     287        case TestHarness.ExpectationType.NotShallowEqual:
     288            return "not %s";
     289        case TestHarness.ExpectationType.EqualWithAccuracy:
     290            return "%s +/- %s";
     291        case TestHarness.ExpectationType.LessThan:
     292            return "less than %s";
     293        case TestHarness.ExpectationType.LessThanOrEqual:
     294            return "less than or equal to %s";
     295        case TestHarness.ExpectationType.GreaterThan:
     296            return "greater than %s";
     297        case TestHarness.ExpectationType.GreaterThanOrEqual:
     298            return "greater than or equal to %s";
     299        default:
     300            return "%s";
     301        }
     302    }
    185303};
     304
     305TestHarness.ExpectationType = {
     306    True: Symbol("expect-true"),
     307    False: Symbol("expect-false"),
     308    Null: Symbol("expect-null"),
     309    NotNull: Symbol("expect-not-null"),
     310    Equal: Symbol("expect-equal"),
     311    NotEqual: Symbol("expect-not-equal"),
     312    ShallowEqual: Symbol("expect-shallow-equal"),
     313    NotShallowEqual: Symbol("expect-not-shallow-equal"),
     314    EqualWithAccuracy: Symbol("expect-equal-with-accuracy"),
     315    LessThan: Symbol("expect-less-than"),
     316    LessThanOrEqual: Symbol("expect-less-than-or-equal"),
     317    GreaterThan: Symbol("expect-greater-than"),
     318    GreaterThanOrEqual: Symbol("expect-greater-than-or-equal"),
     319};
Note: See TracChangeset for help on using the changeset viewer.