├── README.md
├── classes.html
├── classes.js
├── destructuring.html
├── destructuring.js
├── for-in-delete.html
├── for-in-delete.js
├── higher-order.html
├── higher-order.js
├── index.html
├── nesting.html
├── nesting.js
└── test
├── MIT.LICENSE
├── lib
└── jasmine-2.3.4
│ ├── boot.js
│ ├── console.js
│ ├── jasmine-html.js
│ ├── jasmine.css
│ ├── jasmine.js
│ └── jasmine_favicon.png
└── spec
├── classesSpec.js
├── destructuringSpec.js
├── for-in-delete-spec.js
├── higher-order-spec.js
└── nestingSpec.js
/README.md:
--------------------------------------------------------------------------------
1 | Pyton Tutor . Just make sure to change the code to `JavaScript ES6`.
20 |
21 | ## Contributions
22 |
23 | If you see a problem or a typo, please fork, make the necessary changes, and create a pull request so we can review your changes and merge them into the master repo and branch.
24 |
25 | ## Copyright
26 |
27 | © DevMountain LLC, 2017. Unauthorized use and/or duplication of this material without express and written permission from DevMountain, LLC is strictly prohibited. Excerpts and links may be used, provided that full and clear credit is given to DevMountain with appropriate and specific direction to the original content.
28 |
29 |
30 |
--------------------------------------------------------------------------------
/classes.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Jasmine Spec Runner v2.3.4
6 |
7 | Jasmine Spec Runner v2.3.4
6 |
7 | Jasmine Spec Runner v2.3.4
6 |
7 | Jasmine Spec Runner v2.3.4
6 |
7 | Javascript and Debugging
6 |
7 |
8 |
9 | Spec Runners:
10 |
17 |
18 | To use the debugger, right click this page and press Inspect. You can also use the hotkey combination of L-CTRL ( Mac: L-Command ) + L-SHIFT + C
19 |
20 | Now that the debugger is visible on your screen, look for the Sources tab and open it.
21 |
22 | Refresh the page while you have the debugger open and the Sources tab active.
23 |
24 | Select the JavaScript file you would like to debug.
25 |
26 | For more information, checkout: Chrome DevTools
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
--------------------------------------------------------------------------------
/nesting.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Jasmine Spec Runner v2.3.4
6 |
7 | ');
1595 | } else if (value.jasmineToString) {
1596 | this.emitScalar(value.jasmineToString());
1597 | } else if (typeof value === 'string') {
1598 | this.emitString(value);
1599 | } else if (j$.isSpy(value)) {
1600 | this.emitScalar('spy on ' + value.and.identity());
1601 | } else if (value instanceof RegExp) {
1602 | this.emitScalar(value.toString());
1603 | } else if (typeof value === 'function') {
1604 | this.emitScalar('Function');
1605 | } else if (typeof value.nodeType === 'number') {
1606 | this.emitScalar('HTMLNode');
1607 | } else if (value instanceof Date) {
1608 | this.emitScalar('Date(' + value + ')');
1609 | } else if (j$.util.arrayContains(this.seen, value)) {
1610 | this.emitScalar('');
1611 | } else if (j$.isArray_(value) || j$.isA_('Object', value)) {
1612 | this.seen.push(value);
1613 | if (j$.isArray_(value)) {
1614 | this.emitArray(value);
1615 | } else {
1616 | this.emitObject(value);
1617 | }
1618 | this.seen.pop();
1619 | } else {
1620 | this.emitScalar(value.toString());
1621 | }
1622 | } finally {
1623 | this.ppNestLevel_--;
1624 | }
1625 | };
1626 |
1627 | PrettyPrinter.prototype.iterateObject = function(obj, fn) {
1628 | for (var property in obj) {
1629 | if (!Object.prototype.hasOwnProperty.call(obj, property)) { continue; }
1630 | fn(property, obj.__lookupGetter__ ? (!j$.util.isUndefined(obj.__lookupGetter__(property)) &&
1631 | obj.__lookupGetter__(property) !== null) : false);
1632 | }
1633 | };
1634 |
1635 | PrettyPrinter.prototype.emitArray = j$.unimplementedMethod_;
1636 | PrettyPrinter.prototype.emitObject = j$.unimplementedMethod_;
1637 | PrettyPrinter.prototype.emitScalar = j$.unimplementedMethod_;
1638 | PrettyPrinter.prototype.emitString = j$.unimplementedMethod_;
1639 |
1640 | function StringPrettyPrinter() {
1641 | PrettyPrinter.call(this);
1642 |
1643 | this.string = '';
1644 | }
1645 |
1646 | j$.util.inherit(StringPrettyPrinter, PrettyPrinter);
1647 |
1648 | StringPrettyPrinter.prototype.emitScalar = function(value) {
1649 | this.append(value);
1650 | };
1651 |
1652 | StringPrettyPrinter.prototype.emitString = function(value) {
1653 | this.append('\'' + value + '\'');
1654 | };
1655 |
1656 | StringPrettyPrinter.prototype.emitArray = function(array) {
1657 | if (this.ppNestLevel_ > j$.MAX_PRETTY_PRINT_DEPTH) {
1658 | this.append('Array');
1659 | return;
1660 | }
1661 | var length = Math.min(array.length, j$.MAX_PRETTY_PRINT_ARRAY_LENGTH);
1662 | this.append('[ ');
1663 | for (var i = 0; i < length; i++) {
1664 | if (i > 0) {
1665 | this.append(', ');
1666 | }
1667 | this.format(array[i]);
1668 | }
1669 | if(array.length > length){
1670 | this.append(', ...');
1671 | }
1672 |
1673 | var self = this;
1674 | var first = array.length === 0;
1675 | this.iterateObject(array, function(property, isGetter) {
1676 | if (property.match(/^\d+$/)) {
1677 | return;
1678 | }
1679 |
1680 | if (first) {
1681 | first = false;
1682 | } else {
1683 | self.append(', ');
1684 | }
1685 |
1686 | self.formatProperty(array, property, isGetter);
1687 | });
1688 |
1689 | this.append(' ]');
1690 | };
1691 |
1692 | StringPrettyPrinter.prototype.emitObject = function(obj) {
1693 | var constructorName = obj.constructor ? j$.fnNameFor(obj.constructor) : 'null';
1694 | this.append(constructorName);
1695 |
1696 | if (this.ppNestLevel_ > j$.MAX_PRETTY_PRINT_DEPTH) {
1697 | return;
1698 | }
1699 |
1700 | var self = this;
1701 | this.append('({ ');
1702 | var first = true;
1703 |
1704 | this.iterateObject(obj, function(property, isGetter) {
1705 | if (first) {
1706 | first = false;
1707 | } else {
1708 | self.append(', ');
1709 | }
1710 |
1711 | self.formatProperty(obj, property, isGetter);
1712 | });
1713 |
1714 | this.append(' })');
1715 | };
1716 |
1717 | StringPrettyPrinter.prototype.formatProperty = function(obj, property, isGetter) {
1718 | this.append(property);
1719 | this.append(': ');
1720 | if (isGetter) {
1721 | this.append('');
1722 | } else {
1723 | this.format(obj[property]);
1724 | }
1725 | };
1726 |
1727 | StringPrettyPrinter.prototype.append = function(value) {
1728 | this.string += value;
1729 | };
1730 |
1731 | return function(value) {
1732 | var stringPrettyPrinter = new StringPrettyPrinter();
1733 | stringPrettyPrinter.format(value);
1734 | return stringPrettyPrinter.string;
1735 | };
1736 | };
1737 |
1738 | getJasmineRequireObj().QueueRunner = function(j$) {
1739 |
1740 | function once(fn) {
1741 | var called = false;
1742 | return function() {
1743 | if (!called) {
1744 | called = true;
1745 | fn();
1746 | }
1747 | };
1748 | }
1749 |
1750 | function QueueRunner(attrs) {
1751 | this.queueableFns = attrs.queueableFns || [];
1752 | this.onComplete = attrs.onComplete || function() {};
1753 | this.clearStack = attrs.clearStack || function(fn) {fn();};
1754 | this.onException = attrs.onException || function() {};
1755 | this.catchException = attrs.catchException || function() { return true; };
1756 | this.userContext = attrs.userContext || {};
1757 | this.timeout = attrs.timeout || {setTimeout: setTimeout, clearTimeout: clearTimeout};
1758 | this.fail = attrs.fail || function() {};
1759 | }
1760 |
1761 | QueueRunner.prototype.execute = function() {
1762 | this.run(this.queueableFns, 0);
1763 | };
1764 |
1765 | QueueRunner.prototype.run = function(queueableFns, recursiveIndex) {
1766 | var length = queueableFns.length,
1767 | self = this,
1768 | iterativeIndex;
1769 |
1770 |
1771 | for(iterativeIndex = recursiveIndex; iterativeIndex < length; iterativeIndex++) {
1772 | var queueableFn = queueableFns[iterativeIndex];
1773 | if (queueableFn.fn.length > 0) {
1774 | attemptAsync(queueableFn);
1775 | return;
1776 | } else {
1777 | attemptSync(queueableFn);
1778 | }
1779 | }
1780 |
1781 | var runnerDone = iterativeIndex >= length;
1782 |
1783 | if (runnerDone) {
1784 | this.clearStack(this.onComplete);
1785 | }
1786 |
1787 | function attemptSync(queueableFn) {
1788 | try {
1789 | queueableFn.fn.call(self.userContext);
1790 | } catch (e) {
1791 | handleException(e, queueableFn);
1792 | }
1793 | }
1794 |
1795 | function attemptAsync(queueableFn) {
1796 | var clearTimeout = function () {
1797 | Function.prototype.apply.apply(self.timeout.clearTimeout, [j$.getGlobal(), [timeoutId]]);
1798 | },
1799 | next = once(function () {
1800 | clearTimeout(timeoutId);
1801 | self.run(queueableFns, iterativeIndex + 1);
1802 | }),
1803 | timeoutId;
1804 |
1805 | next.fail = function() {
1806 | self.fail.apply(null, arguments);
1807 | next();
1808 | };
1809 |
1810 | if (queueableFn.timeout) {
1811 | timeoutId = Function.prototype.apply.apply(self.timeout.setTimeout, [j$.getGlobal(), [function() {
1812 | var error = new Error('Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.');
1813 | onException(error, queueableFn);
1814 | next();
1815 | }, queueableFn.timeout()]]);
1816 | }
1817 |
1818 | try {
1819 | queueableFn.fn.call(self.userContext, next);
1820 | } catch (e) {
1821 | handleException(e, queueableFn);
1822 | next();
1823 | }
1824 | }
1825 |
1826 | function onException(e, queueableFn) {
1827 | self.onException(e);
1828 | }
1829 |
1830 | function handleException(e, queueableFn) {
1831 | onException(e, queueableFn);
1832 | if (!self.catchException(e)) {
1833 | //TODO: set a var when we catch an exception and
1834 | //use a finally block to close the loop in a nice way..
1835 | throw e;
1836 | }
1837 | }
1838 | };
1839 |
1840 | return QueueRunner;
1841 | };
1842 |
1843 | getJasmineRequireObj().ReportDispatcher = function() {
1844 | function ReportDispatcher(methods) {
1845 |
1846 | var dispatchedMethods = methods || [];
1847 |
1848 | for (var i = 0; i < dispatchedMethods.length; i++) {
1849 | var method = dispatchedMethods[i];
1850 | this[method] = (function(m) {
1851 | return function() {
1852 | dispatch(m, arguments);
1853 | };
1854 | }(method));
1855 | }
1856 |
1857 | var reporters = [];
1858 |
1859 | this.addReporter = function(reporter) {
1860 | reporters.push(reporter);
1861 | };
1862 |
1863 | return this;
1864 |
1865 | function dispatch(method, args) {
1866 | for (var i = 0; i < reporters.length; i++) {
1867 | var reporter = reporters[i];
1868 | if (reporter[method]) {
1869 | reporter[method].apply(reporter, args);
1870 | }
1871 | }
1872 | }
1873 | }
1874 |
1875 | return ReportDispatcher;
1876 | };
1877 |
1878 |
1879 | getJasmineRequireObj().SpyRegistry = function(j$) {
1880 |
1881 | function SpyRegistry(options) {
1882 | options = options || {};
1883 | var currentSpies = options.currentSpies || function() { return []; };
1884 |
1885 | this.spyOn = function(obj, methodName) {
1886 | if (j$.util.isUndefined(obj)) {
1887 | throw new Error('spyOn could not find an object to spy upon for ' + methodName + '()');
1888 | }
1889 |
1890 | if (j$.util.isUndefined(methodName)) {
1891 | throw new Error('No method name supplied');
1892 | }
1893 |
1894 | if (j$.util.isUndefined(obj[methodName])) {
1895 | throw new Error(methodName + '() method does not exist');
1896 | }
1897 |
1898 | if (obj[methodName] && j$.isSpy(obj[methodName])) {
1899 | //TODO?: should this return the current spy? Downside: may cause user confusion about spy state
1900 | throw new Error(methodName + ' has already been spied upon');
1901 | }
1902 |
1903 | var spy = j$.createSpy(methodName, obj[methodName]);
1904 |
1905 | currentSpies().push({
1906 | spy: spy,
1907 | baseObj: obj,
1908 | methodName: methodName,
1909 | originalValue: obj[methodName]
1910 | });
1911 |
1912 | obj[methodName] = spy;
1913 |
1914 | return spy;
1915 | };
1916 |
1917 | this.clearSpies = function() {
1918 | var spies = currentSpies();
1919 | for (var i = 0; i < spies.length; i++) {
1920 | var spyEntry = spies[i];
1921 | spyEntry.baseObj[spyEntry.methodName] = spyEntry.originalValue;
1922 | }
1923 | };
1924 | }
1925 |
1926 | return SpyRegistry;
1927 | };
1928 |
1929 | getJasmineRequireObj().SpyStrategy = function() {
1930 |
1931 | function SpyStrategy(options) {
1932 | options = options || {};
1933 |
1934 | var identity = options.name || 'unknown',
1935 | originalFn = options.fn || function() {},
1936 | getSpy = options.getSpy || function() {},
1937 | plan = function() {};
1938 |
1939 | this.identity = function() {
1940 | return identity;
1941 | };
1942 |
1943 | this.exec = function() {
1944 | return plan.apply(this, arguments);
1945 | };
1946 |
1947 | this.callThrough = function() {
1948 | plan = originalFn;
1949 | return getSpy();
1950 | };
1951 |
1952 | this.returnValue = function(value) {
1953 | plan = function() {
1954 | return value;
1955 | };
1956 | return getSpy();
1957 | };
1958 |
1959 | this.returnValues = function() {
1960 | var values = Array.prototype.slice.call(arguments);
1961 | plan = function () {
1962 | return values.shift();
1963 | };
1964 | return getSpy();
1965 | };
1966 |
1967 | this.throwError = function(something) {
1968 | var error = (something instanceof Error) ? something : new Error(something);
1969 | plan = function() {
1970 | throw error;
1971 | };
1972 | return getSpy();
1973 | };
1974 |
1975 | this.callFake = function(fn) {
1976 | plan = fn;
1977 | return getSpy();
1978 | };
1979 |
1980 | this.stub = function(fn) {
1981 | plan = function() {};
1982 | return getSpy();
1983 | };
1984 | }
1985 |
1986 | return SpyStrategy;
1987 | };
1988 |
1989 | getJasmineRequireObj().Suite = function(j$) {
1990 | function Suite(attrs) {
1991 | this.env = attrs.env;
1992 | this.id = attrs.id;
1993 | this.parentSuite = attrs.parentSuite;
1994 | this.description = attrs.description;
1995 | this.expectationFactory = attrs.expectationFactory;
1996 | this.expectationResultFactory = attrs.expectationResultFactory;
1997 | this.throwOnExpectationFailure = !!attrs.throwOnExpectationFailure;
1998 |
1999 | this.beforeFns = [];
2000 | this.afterFns = [];
2001 | this.beforeAllFns = [];
2002 | this.afterAllFns = [];
2003 | this.disabled = false;
2004 |
2005 | this.children = [];
2006 |
2007 | this.result = {
2008 | id: this.id,
2009 | description: this.description,
2010 | fullName: this.getFullName(),
2011 | failedExpectations: []
2012 | };
2013 | }
2014 |
2015 | Suite.prototype.expect = function(actual) {
2016 | return this.expectationFactory(actual, this);
2017 | };
2018 |
2019 | Suite.prototype.getFullName = function() {
2020 | var fullName = this.description;
2021 | for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
2022 | if (parentSuite.parentSuite) {
2023 | fullName = parentSuite.description + ' ' + fullName;
2024 | }
2025 | }
2026 | return fullName;
2027 | };
2028 |
2029 | Suite.prototype.disable = function() {
2030 | this.disabled = true;
2031 | };
2032 |
2033 | Suite.prototype.beforeEach = function(fn) {
2034 | this.beforeFns.unshift(fn);
2035 | };
2036 |
2037 | Suite.prototype.beforeAll = function(fn) {
2038 | this.beforeAllFns.push(fn);
2039 | };
2040 |
2041 | Suite.prototype.afterEach = function(fn) {
2042 | this.afterFns.unshift(fn);
2043 | };
2044 |
2045 | Suite.prototype.afterAll = function(fn) {
2046 | this.afterAllFns.push(fn);
2047 | };
2048 |
2049 | Suite.prototype.addChild = function(child) {
2050 | this.children.push(child);
2051 | };
2052 |
2053 | Suite.prototype.status = function() {
2054 | if (this.disabled) {
2055 | return 'disabled';
2056 | }
2057 |
2058 | if (this.result.failedExpectations.length > 0) {
2059 | return 'failed';
2060 | } else {
2061 | return 'finished';
2062 | }
2063 | };
2064 |
2065 | Suite.prototype.isExecutable = function() {
2066 | return !this.disabled;
2067 | };
2068 |
2069 | Suite.prototype.canBeReentered = function() {
2070 | return this.beforeAllFns.length === 0 && this.afterAllFns.length === 0;
2071 | };
2072 |
2073 | Suite.prototype.getResult = function() {
2074 | this.result.status = this.status();
2075 | return this.result;
2076 | };
2077 |
2078 | Suite.prototype.sharedUserContext = function() {
2079 | if (!this.sharedContext) {
2080 | this.sharedContext = this.parentSuite ? clone(this.parentSuite.sharedUserContext()) : {};
2081 | }
2082 |
2083 | return this.sharedContext;
2084 | };
2085 |
2086 | Suite.prototype.clonedSharedUserContext = function() {
2087 | return clone(this.sharedUserContext());
2088 | };
2089 |
2090 | Suite.prototype.onException = function() {
2091 | if (arguments[0] instanceof j$.errors.ExpectationFailed) {
2092 | return;
2093 | }
2094 |
2095 | if(isAfterAll(this.children)) {
2096 | var data = {
2097 | matcherName: '',
2098 | passed: false,
2099 | expected: '',
2100 | actual: '',
2101 | error: arguments[0]
2102 | };
2103 | this.result.failedExpectations.push(this.expectationResultFactory(data));
2104 | } else {
2105 | for (var i = 0; i < this.children.length; i++) {
2106 | var child = this.children[i];
2107 | child.onException.apply(child, arguments);
2108 | }
2109 | }
2110 | };
2111 |
2112 | Suite.prototype.addExpectationResult = function () {
2113 | if(isAfterAll(this.children) && isFailure(arguments)){
2114 | var data = arguments[1];
2115 | this.result.failedExpectations.push(this.expectationResultFactory(data));
2116 | if(this.throwOnExpectationFailure) {
2117 | throw new j$.errors.ExpectationFailed();
2118 | }
2119 | } else {
2120 | for (var i = 0; i < this.children.length; i++) {
2121 | var child = this.children[i];
2122 | try {
2123 | child.addExpectationResult.apply(child, arguments);
2124 | } catch(e) {
2125 | // keep going
2126 | }
2127 | }
2128 | }
2129 | };
2130 |
2131 | function isAfterAll(children) {
2132 | return children && children[0].result.status;
2133 | }
2134 |
2135 | function isFailure(args) {
2136 | return !args[0];
2137 | }
2138 |
2139 | function clone(obj) {
2140 | var clonedObj = {};
2141 | for (var prop in obj) {
2142 | if (obj.hasOwnProperty(prop)) {
2143 | clonedObj[prop] = obj[prop];
2144 | }
2145 | }
2146 |
2147 | return clonedObj;
2148 | }
2149 |
2150 | return Suite;
2151 | };
2152 |
2153 | if (typeof window == void 0 && typeof exports == 'object') {
2154 | exports.Suite = jasmineRequire.Suite;
2155 | }
2156 |
2157 | getJasmineRequireObj().Timer = function() {
2158 | var defaultNow = (function(Date) {
2159 | return function() { return new Date().getTime(); };
2160 | })(Date);
2161 |
2162 | function Timer(options) {
2163 | options = options || {};
2164 |
2165 | var now = options.now || defaultNow,
2166 | startTime;
2167 |
2168 | this.start = function() {
2169 | startTime = now();
2170 | };
2171 |
2172 | this.elapsed = function() {
2173 | return now() - startTime;
2174 | };
2175 | }
2176 |
2177 | return Timer;
2178 | };
2179 |
2180 | getJasmineRequireObj().TreeProcessor = function() {
2181 | function TreeProcessor(attrs) {
2182 | var tree = attrs.tree,
2183 | runnableIds = attrs.runnableIds,
2184 | queueRunnerFactory = attrs.queueRunnerFactory,
2185 | nodeStart = attrs.nodeStart || function() {},
2186 | nodeComplete = attrs.nodeComplete || function() {},
2187 | stats = { valid: true },
2188 | processed = false,
2189 | defaultMin = Infinity,
2190 | defaultMax = 1 - Infinity;
2191 |
2192 | this.processTree = function() {
2193 | processNode(tree, false);
2194 | processed = true;
2195 | return stats;
2196 | };
2197 |
2198 | this.execute = function(done) {
2199 | if (!processed) {
2200 | this.processTree();
2201 | }
2202 |
2203 | if (!stats.valid) {
2204 | throw 'invalid order';
2205 | }
2206 |
2207 | var childFns = wrapChildren(tree, 0);
2208 |
2209 | queueRunnerFactory({
2210 | queueableFns: childFns,
2211 | userContext: tree.sharedUserContext(),
2212 | onException: function() {
2213 | tree.onException.apply(tree, arguments);
2214 | },
2215 | onComplete: done
2216 | });
2217 | };
2218 |
2219 | function runnableIndex(id) {
2220 | for (var i = 0; i < runnableIds.length; i++) {
2221 | if (runnableIds[i] === id) {
2222 | return i;
2223 | }
2224 | }
2225 | }
2226 |
2227 | function processNode(node, parentEnabled) {
2228 | var executableIndex = runnableIndex(node.id);
2229 |
2230 | if (executableIndex !== undefined) {
2231 | parentEnabled = true;
2232 | }
2233 |
2234 | parentEnabled = parentEnabled && node.isExecutable();
2235 |
2236 | if (!node.children) {
2237 | stats[node.id] = {
2238 | executable: parentEnabled && node.isExecutable(),
2239 | segments: [{
2240 | index: 0,
2241 | owner: node,
2242 | nodes: [node],
2243 | min: startingMin(executableIndex),
2244 | max: startingMax(executableIndex)
2245 | }]
2246 | };
2247 | } else {
2248 | var hasExecutableChild = false;
2249 |
2250 | for (var i = 0; i < node.children.length; i++) {
2251 | var child = node.children[i];
2252 |
2253 | processNode(child, parentEnabled);
2254 |
2255 | if (!stats.valid) {
2256 | return;
2257 | }
2258 |
2259 | var childStats = stats[child.id];
2260 |
2261 | hasExecutableChild = hasExecutableChild || childStats.executable;
2262 | }
2263 |
2264 | stats[node.id] = {
2265 | executable: hasExecutableChild
2266 | };
2267 |
2268 | segmentChildren(node, stats[node.id], executableIndex);
2269 |
2270 | if (!node.canBeReentered() && stats[node.id].segments.length > 1) {
2271 | stats = { valid: false };
2272 | }
2273 | }
2274 | }
2275 |
2276 | function startingMin(executableIndex) {
2277 | return executableIndex === undefined ? defaultMin : executableIndex;
2278 | }
2279 |
2280 | function startingMax(executableIndex) {
2281 | return executableIndex === undefined ? defaultMax : executableIndex;
2282 | }
2283 |
2284 | function segmentChildren(node, nodeStats, executableIndex) {
2285 | var currentSegment = { index: 0, owner: node, nodes: [], min: startingMin(executableIndex), max: startingMax(executableIndex) },
2286 | result = [currentSegment],
2287 | lastMax = defaultMax,
2288 | orderedChildSegments = orderChildSegments(node.children);
2289 |
2290 | function isSegmentBoundary(minIndex) {
2291 | return lastMax !== defaultMax && minIndex !== defaultMin && lastMax < minIndex - 1;
2292 | }
2293 |
2294 | for (var i = 0; i < orderedChildSegments.length; i++) {
2295 | var childSegment = orderedChildSegments[i],
2296 | maxIndex = childSegment.max,
2297 | minIndex = childSegment.min;
2298 |
2299 | if (isSegmentBoundary(minIndex)) {
2300 | currentSegment = {index: result.length, owner: node, nodes: [], min: defaultMin, max: defaultMax};
2301 | result.push(currentSegment);
2302 | }
2303 |
2304 | currentSegment.nodes.push(childSegment);
2305 | currentSegment.min = Math.min(currentSegment.min, minIndex);
2306 | currentSegment.max = Math.max(currentSegment.max, maxIndex);
2307 | lastMax = maxIndex;
2308 | }
2309 |
2310 | nodeStats.segments = result;
2311 | }
2312 |
2313 | function orderChildSegments(children) {
2314 | var specifiedOrder = [],
2315 | unspecifiedOrder = [];
2316 |
2317 | for (var i = 0; i < children.length; i++) {
2318 | var child = children[i],
2319 | segments = stats[child.id].segments;
2320 |
2321 | for (var j = 0; j < segments.length; j++) {
2322 | var seg = segments[j];
2323 |
2324 | if (seg.min === defaultMin) {
2325 | unspecifiedOrder.push(seg);
2326 | } else {
2327 | specifiedOrder.push(seg);
2328 | }
2329 | }
2330 | }
2331 |
2332 | specifiedOrder.sort(function(a, b) {
2333 | return a.min - b.min;
2334 | });
2335 |
2336 | return specifiedOrder.concat(unspecifiedOrder);
2337 | }
2338 |
2339 | function executeNode(node, segmentNumber) {
2340 | if (node.children) {
2341 | return {
2342 | fn: function(done) {
2343 | nodeStart(node);
2344 |
2345 | queueRunnerFactory({
2346 | onComplete: function() {
2347 | nodeComplete(node, node.getResult());
2348 | done();
2349 | },
2350 | queueableFns: wrapChildren(node, segmentNumber),
2351 | userContext: node.sharedUserContext(),
2352 | onException: function() {
2353 | node.onException.apply(node, arguments);
2354 | }
2355 | });
2356 | }
2357 | };
2358 | } else {
2359 | return {
2360 | fn: function(done) { node.execute(done, stats[node.id].executable); }
2361 | };
2362 | }
2363 | }
2364 |
2365 | function wrapChildren(node, segmentNumber) {
2366 | var result = [],
2367 | segmentChildren = stats[node.id].segments[segmentNumber].nodes;
2368 |
2369 | for (var i = 0; i < segmentChildren.length; i++) {
2370 | result.push(executeNode(segmentChildren[i].owner, segmentChildren[i].index));
2371 | }
2372 |
2373 | if (!stats[node.id].executable) {
2374 | return result;
2375 | }
2376 |
2377 | return node.beforeAllFns.concat(result).concat(node.afterAllFns);
2378 | }
2379 | }
2380 |
2381 | return TreeProcessor;
2382 | };
2383 |
2384 | getJasmineRequireObj().Any = function(j$) {
2385 |
2386 | function Any(expectedObject) {
2387 | this.expectedObject = expectedObject;
2388 | }
2389 |
2390 | Any.prototype.asymmetricMatch = function(other) {
2391 | if (this.expectedObject == String) {
2392 | return typeof other == 'string' || other instanceof String;
2393 | }
2394 |
2395 | if (this.expectedObject == Number) {
2396 | return typeof other == 'number' || other instanceof Number;
2397 | }
2398 |
2399 | if (this.expectedObject == Function) {
2400 | return typeof other == 'function' || other instanceof Function;
2401 | }
2402 |
2403 | if (this.expectedObject == Object) {
2404 | return typeof other == 'object';
2405 | }
2406 |
2407 | if (this.expectedObject == Boolean) {
2408 | return typeof other == 'boolean';
2409 | }
2410 |
2411 | return other instanceof this.expectedObject;
2412 | };
2413 |
2414 | Any.prototype.jasmineToString = function() {
2415 | return '';
2416 | };
2417 |
2418 | return Any;
2419 | };
2420 |
2421 | getJasmineRequireObj().Anything = function(j$) {
2422 |
2423 | function Anything() {}
2424 |
2425 | Anything.prototype.asymmetricMatch = function(other) {
2426 | return !j$.util.isUndefined(other) && other !== null;
2427 | };
2428 |
2429 | Anything.prototype.jasmineToString = function() {
2430 | return '';
2431 | };
2432 |
2433 | return Anything;
2434 | };
2435 |
2436 | getJasmineRequireObj().ArrayContaining = function(j$) {
2437 | function ArrayContaining(sample) {
2438 | this.sample = sample;
2439 | }
2440 |
2441 | ArrayContaining.prototype.asymmetricMatch = function(other) {
2442 | var className = Object.prototype.toString.call(this.sample);
2443 | if (className !== '[object Array]') { throw new Error('You must provide an array to arrayContaining, not \'' + this.sample + '\'.'); }
2444 |
2445 | for (var i = 0; i < this.sample.length; i++) {
2446 | var item = this.sample[i];
2447 | if (!j$.matchersUtil.contains(other, item)) {
2448 | return false;
2449 | }
2450 | }
2451 |
2452 | return true;
2453 | };
2454 |
2455 | ArrayContaining.prototype.jasmineToString = function () {
2456 | return '';
2457 | };
2458 |
2459 | return ArrayContaining;
2460 | };
2461 |
2462 | getJasmineRequireObj().ObjectContaining = function(j$) {
2463 |
2464 | function ObjectContaining(sample) {
2465 | this.sample = sample;
2466 | }
2467 |
2468 | function getPrototype(obj) {
2469 | if (Object.getPrototypeOf) {
2470 | return Object.getPrototypeOf(obj);
2471 | }
2472 |
2473 | if (obj.constructor.prototype == obj) {
2474 | return null;
2475 | }
2476 |
2477 | return obj.constructor.prototype;
2478 | }
2479 |
2480 | function hasProperty(obj, property) {
2481 | if (!obj) {
2482 | return false;
2483 | }
2484 |
2485 | if (Object.prototype.hasOwnProperty.call(obj, property)) {
2486 | return true;
2487 | }
2488 |
2489 | return hasProperty(getPrototype(obj), property);
2490 | }
2491 |
2492 | ObjectContaining.prototype.asymmetricMatch = function(other) {
2493 | if (typeof(this.sample) !== 'object') { throw new Error('You must provide an object to objectContaining, not \''+this.sample+'\'.'); }
2494 |
2495 | for (var property in this.sample) {
2496 | if (!hasProperty(other, property) ||
2497 | !j$.matchersUtil.equals(this.sample[property], other[property])) {
2498 | return false;
2499 | }
2500 | }
2501 |
2502 | return true;
2503 | };
2504 |
2505 | ObjectContaining.prototype.jasmineToString = function() {
2506 | return '';
2507 | };
2508 |
2509 | return ObjectContaining;
2510 | };
2511 |
2512 | getJasmineRequireObj().StringMatching = function(j$) {
2513 |
2514 | function StringMatching(expected) {
2515 | if (!j$.isString_(expected) && !j$.isA_('RegExp', expected)) {
2516 | throw new Error('Expected is not a String or a RegExp');
2517 | }
2518 |
2519 | this.regexp = new RegExp(expected);
2520 | }
2521 |
2522 | StringMatching.prototype.asymmetricMatch = function(other) {
2523 | return this.regexp.test(other);
2524 | };
2525 |
2526 | StringMatching.prototype.jasmineToString = function() {
2527 | return '';
2528 | };
2529 |
2530 | return StringMatching;
2531 | };
2532 |
2533 | getJasmineRequireObj().errors = function() {
2534 | function ExpectationFailed() {}
2535 |
2536 | ExpectationFailed.prototype = new Error();
2537 | ExpectationFailed.prototype.constructor = ExpectationFailed;
2538 |
2539 | return {
2540 | ExpectationFailed: ExpectationFailed
2541 | };
2542 | };
2543 | getJasmineRequireObj().matchersUtil = function(j$) {
2544 | // TODO: what to do about jasmine.pp not being inject? move to JSON.stringify? gut PrettyPrinter?
2545 |
2546 | return {
2547 | equals: function(a, b, customTesters) {
2548 | customTesters = customTesters || [];
2549 |
2550 | return eq(a, b, [], [], customTesters);
2551 | },
2552 |
2553 | contains: function(haystack, needle, customTesters) {
2554 | customTesters = customTesters || [];
2555 |
2556 | if ((Object.prototype.toString.apply(haystack) === '[object Array]') ||
2557 | (!!haystack && !haystack.indexOf))
2558 | {
2559 | for (var i = 0; i < haystack.length; i++) {
2560 | if (eq(haystack[i], needle, [], [], customTesters)) {
2561 | return true;
2562 | }
2563 | }
2564 | return false;
2565 | }
2566 |
2567 | return !!haystack && haystack.indexOf(needle) >= 0;
2568 | },
2569 |
2570 | buildFailureMessage: function() {
2571 | var args = Array.prototype.slice.call(arguments, 0),
2572 | matcherName = args[0],
2573 | isNot = args[1],
2574 | actual = args[2],
2575 | expected = args.slice(3),
2576 | englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
2577 |
2578 | var message = 'Expected ' +
2579 | j$.pp(actual) +
2580 | (isNot ? ' not ' : ' ') +
2581 | englishyPredicate;
2582 |
2583 | if (expected.length > 0) {
2584 | for (var i = 0; i < expected.length; i++) {
2585 | if (i > 0) {
2586 | message += ',';
2587 | }
2588 | message += ' ' + j$.pp(expected[i]);
2589 | }
2590 | }
2591 |
2592 | return message + '.';
2593 | }
2594 | };
2595 |
2596 | function isAsymmetric(obj) {
2597 | return obj && j$.isA_('Function', obj.asymmetricMatch);
2598 | }
2599 |
2600 | function asymmetricMatch(a, b) {
2601 | var asymmetricA = isAsymmetric(a),
2602 | asymmetricB = isAsymmetric(b);
2603 |
2604 | if (asymmetricA && asymmetricB) {
2605 | return undefined;
2606 | }
2607 |
2608 | if (asymmetricA) {
2609 | return a.asymmetricMatch(b);
2610 | }
2611 |
2612 | if (asymmetricB) {
2613 | return b.asymmetricMatch(a);
2614 | }
2615 | }
2616 |
2617 | // Equality function lovingly adapted from isEqual in
2618 | // [Underscore](http://underscorejs.org)
2619 | function eq(a, b, aStack, bStack, customTesters) {
2620 | var result = true;
2621 |
2622 | var asymmetricResult = asymmetricMatch(a, b);
2623 | if (!j$.util.isUndefined(asymmetricResult)) {
2624 | return asymmetricResult;
2625 | }
2626 |
2627 | for (var i = 0; i < customTesters.length; i++) {
2628 | var customTesterResult = customTesters[i](a, b);
2629 | if (!j$.util.isUndefined(customTesterResult)) {
2630 | return customTesterResult;
2631 | }
2632 | }
2633 |
2634 | if (a instanceof Error && b instanceof Error) {
2635 | return a.message == b.message;
2636 | }
2637 |
2638 | // Identical objects are equal. `0 === -0`, but they aren't identical.
2639 | // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
2640 | if (a === b) { return a !== 0 || 1 / a == 1 / b; }
2641 | // A strict comparison is necessary because `null == undefined`.
2642 | if (a === null || b === null) { return a === b; }
2643 | var className = Object.prototype.toString.call(a);
2644 | if (className != Object.prototype.toString.call(b)) { return false; }
2645 | switch (className) {
2646 | // Strings, numbers, dates, and booleans are compared by value.
2647 | case '[object String]':
2648 | // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
2649 | // equivalent to `new String("5")`.
2650 | return a == String(b);
2651 | case '[object Number]':
2652 | // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
2653 | // other numeric values.
2654 | return a != +a ? b != +b : (a === 0 ? 1 / a == 1 / b : a == +b);
2655 | case '[object Date]':
2656 | case '[object Boolean]':
2657 | // Coerce dates and booleans to numeric primitive values. Dates are compared by their
2658 | // millisecond representations. Note that invalid dates with millisecond representations
2659 | // of `NaN` are not equivalent.
2660 | return +a == +b;
2661 | // RegExps are compared by their source patterns and flags.
2662 | case '[object RegExp]':
2663 | return a.source == b.source &&
2664 | a.global == b.global &&
2665 | a.multiline == b.multiline &&
2666 | a.ignoreCase == b.ignoreCase;
2667 | }
2668 | if (typeof a != 'object' || typeof b != 'object') { return false; }
2669 |
2670 | var aIsDomNode = j$.isDomNode(a);
2671 | var bIsDomNode = j$.isDomNode(b);
2672 | if (aIsDomNode && bIsDomNode) {
2673 | // At first try to use DOM3 method isEqualNode
2674 | if (a.isEqualNode) {
2675 | return a.isEqualNode(b);
2676 | }
2677 | // IE8 doesn't support isEqualNode, try to use outerHTML && innerText
2678 | var aIsElement = a instanceof Element;
2679 | var bIsElement = b instanceof Element;
2680 | if (aIsElement && bIsElement) {
2681 | return a.outerHTML == b.outerHTML;
2682 | }
2683 | if (aIsElement || bIsElement) {
2684 | return false;
2685 | }
2686 | return a.innerText == b.innerText && a.textContent == b.textContent;
2687 | }
2688 | if (aIsDomNode || bIsDomNode) {
2689 | return false;
2690 | }
2691 |
2692 | // Assume equality for cyclic structures. The algorithm for detecting cyclic
2693 | // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
2694 | var length = aStack.length;
2695 | while (length--) {
2696 | // Linear search. Performance is inversely proportional to the number of
2697 | // unique nested structures.
2698 | if (aStack[length] == a) { return bStack[length] == b; }
2699 | }
2700 | // Add the first object to the stack of traversed objects.
2701 | aStack.push(a);
2702 | bStack.push(b);
2703 | var size = 0;
2704 | // Recursively compare objects and arrays.
2705 | // Compare array lengths to determine if a deep comparison is necessary.
2706 | if (className == '[object Array]' && a.length !== b.length) {
2707 | result = false;
2708 | }
2709 |
2710 | if (result) {
2711 | // Objects with different constructors are not equivalent, but `Object`s
2712 | // or `Array`s from different frames are.
2713 | if (className !== '[object Array]') {
2714 | var aCtor = a.constructor, bCtor = b.constructor;
2715 | if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor &&
2716 | isFunction(bCtor) && bCtor instanceof bCtor)) {
2717 | return false;
2718 | }
2719 | }
2720 | // Deep compare objects.
2721 | for (var key in a) {
2722 | if (has(a, key)) {
2723 | // Count the expected number of properties.
2724 | size++;
2725 | // Deep compare each member.
2726 | if (!(result = has(b, key) && eq(a[key], b[key], aStack, bStack, customTesters))) { break; }
2727 | }
2728 | }
2729 | // Ensure that both objects contain the same number of properties.
2730 | if (result) {
2731 | for (key in b) {
2732 | if (has(b, key) && !(size--)) { break; }
2733 | }
2734 | result = !size;
2735 | }
2736 | }
2737 | // Remove the first object from the stack of traversed objects.
2738 | aStack.pop();
2739 | bStack.pop();
2740 |
2741 | return result;
2742 |
2743 | function has(obj, key) {
2744 | return Object.prototype.hasOwnProperty.call(obj, key);
2745 | }
2746 |
2747 | function isFunction(obj) {
2748 | return typeof obj === 'function';
2749 | }
2750 | }
2751 | };
2752 |
2753 | getJasmineRequireObj().toBe = function() {
2754 | function toBe() {
2755 | return {
2756 | compare: function(actual, expected) {
2757 | return {
2758 | pass: actual === expected
2759 | };
2760 | }
2761 | };
2762 | }
2763 |
2764 | return toBe;
2765 | };
2766 |
2767 | getJasmineRequireObj().toBeCloseTo = function() {
2768 |
2769 | function toBeCloseTo() {
2770 | return {
2771 | compare: function(actual, expected, precision) {
2772 | if (precision !== 0) {
2773 | precision = precision || 2;
2774 | }
2775 |
2776 | return {
2777 | pass: Math.abs(expected - actual) < (Math.pow(10, -precision) / 2)
2778 | };
2779 | }
2780 | };
2781 | }
2782 |
2783 | return toBeCloseTo;
2784 | };
2785 |
2786 | getJasmineRequireObj().toBeDefined = function() {
2787 | function toBeDefined() {
2788 | return {
2789 | compare: function(actual) {
2790 | return {
2791 | pass: (void 0 !== actual)
2792 | };
2793 | }
2794 | };
2795 | }
2796 |
2797 | return toBeDefined;
2798 | };
2799 |
2800 | getJasmineRequireObj().toBeFalsy = function() {
2801 | function toBeFalsy() {
2802 | return {
2803 | compare: function(actual) {
2804 | return {
2805 | pass: !!!actual
2806 | };
2807 | }
2808 | };
2809 | }
2810 |
2811 | return toBeFalsy;
2812 | };
2813 |
2814 | getJasmineRequireObj().toBeGreaterThan = function() {
2815 |
2816 | function toBeGreaterThan() {
2817 | return {
2818 | compare: function(actual, expected) {
2819 | return {
2820 | pass: actual > expected
2821 | };
2822 | }
2823 | };
2824 | }
2825 |
2826 | return toBeGreaterThan;
2827 | };
2828 |
2829 |
2830 | getJasmineRequireObj().toBeLessThan = function() {
2831 | function toBeLessThan() {
2832 | return {
2833 |
2834 | compare: function(actual, expected) {
2835 | return {
2836 | pass: actual < expected
2837 | };
2838 | }
2839 | };
2840 | }
2841 |
2842 | return toBeLessThan;
2843 | };
2844 | getJasmineRequireObj().toBeNaN = function(j$) {
2845 |
2846 | function toBeNaN() {
2847 | return {
2848 | compare: function(actual) {
2849 | var result = {
2850 | pass: (actual !== actual)
2851 | };
2852 |
2853 | if (result.pass) {
2854 | result.message = 'Expected actual not to be NaN.';
2855 | } else {
2856 | result.message = function() { return 'Expected ' + j$.pp(actual) + ' to be NaN.'; };
2857 | }
2858 |
2859 | return result;
2860 | }
2861 | };
2862 | }
2863 |
2864 | return toBeNaN;
2865 | };
2866 |
2867 | getJasmineRequireObj().toBeNull = function() {
2868 |
2869 | function toBeNull() {
2870 | return {
2871 | compare: function(actual) {
2872 | return {
2873 | pass: actual === null
2874 | };
2875 | }
2876 | };
2877 | }
2878 |
2879 | return toBeNull;
2880 | };
2881 |
2882 | getJasmineRequireObj().toBeTruthy = function() {
2883 |
2884 | function toBeTruthy() {
2885 | return {
2886 | compare: function(actual) {
2887 | return {
2888 | pass: !!actual
2889 | };
2890 | }
2891 | };
2892 | }
2893 |
2894 | return toBeTruthy;
2895 | };
2896 |
2897 | getJasmineRequireObj().toBeUndefined = function() {
2898 |
2899 | function toBeUndefined() {
2900 | return {
2901 | compare: function(actual) {
2902 | return {
2903 | pass: void 0 === actual
2904 | };
2905 | }
2906 | };
2907 | }
2908 |
2909 | return toBeUndefined;
2910 | };
2911 |
2912 | getJasmineRequireObj().toContain = function() {
2913 | function toContain(util, customEqualityTesters) {
2914 | customEqualityTesters = customEqualityTesters || [];
2915 |
2916 | return {
2917 | compare: function(actual, expected) {
2918 |
2919 | return {
2920 | pass: util.contains(actual, expected, customEqualityTesters)
2921 | };
2922 | }
2923 | };
2924 | }
2925 |
2926 | return toContain;
2927 | };
2928 |
2929 | getJasmineRequireObj().toEqual = function() {
2930 |
2931 | function toEqual(util, customEqualityTesters) {
2932 | customEqualityTesters = customEqualityTesters || [];
2933 |
2934 | return {
2935 | compare: function(actual, expected) {
2936 | var result = {
2937 | pass: false
2938 | };
2939 |
2940 | result.pass = util.equals(actual, expected, customEqualityTesters);
2941 |
2942 | return result;
2943 | }
2944 | };
2945 | }
2946 |
2947 | return toEqual;
2948 | };
2949 |
2950 | getJasmineRequireObj().toHaveBeenCalled = function(j$) {
2951 |
2952 | function toHaveBeenCalled() {
2953 | return {
2954 | compare: function(actual) {
2955 | var result = {};
2956 |
2957 | if (!j$.isSpy(actual)) {
2958 | throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
2959 | }
2960 |
2961 | if (arguments.length > 1) {
2962 | throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
2963 | }
2964 |
2965 | result.pass = actual.calls.any();
2966 |
2967 | result.message = result.pass ?
2968 | 'Expected spy ' + actual.and.identity() + ' not to have been called.' :
2969 | 'Expected spy ' + actual.and.identity() + ' to have been called.';
2970 |
2971 | return result;
2972 | }
2973 | };
2974 | }
2975 |
2976 | return toHaveBeenCalled;
2977 | };
2978 |
2979 | getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
2980 |
2981 | function toHaveBeenCalledWith(util, customEqualityTesters) {
2982 | return {
2983 | compare: function() {
2984 | var args = Array.prototype.slice.call(arguments, 0),
2985 | actual = args[0],
2986 | expectedArgs = args.slice(1),
2987 | result = { pass: false };
2988 |
2989 | if (!j$.isSpy(actual)) {
2990 | throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
2991 | }
2992 |
2993 | if (!actual.calls.any()) {
2994 | result.message = function() { return 'Expected spy ' + actual.and.identity() + ' to have been called with ' + j$.pp(expectedArgs) + ' but it was never called.'; };
2995 | return result;
2996 | }
2997 |
2998 | if (util.contains(actual.calls.allArgs(), expectedArgs, customEqualityTesters)) {
2999 | result.pass = true;
3000 | result.message = function() { return 'Expected spy ' + actual.and.identity() + ' not to have been called with ' + j$.pp(expectedArgs) + ' but it was.'; };
3001 | } else {
3002 | result.message = function() { return 'Expected spy ' + actual.and.identity() + ' to have been called with ' + j$.pp(expectedArgs) + ' but actual calls were ' + j$.pp(actual.calls.allArgs()).replace(/^\[ | \]$/g, '') + '.'; };
3003 | }
3004 |
3005 | return result;
3006 | }
3007 | };
3008 | }
3009 |
3010 | return toHaveBeenCalledWith;
3011 | };
3012 |
3013 | getJasmineRequireObj().toMatch = function(j$) {
3014 |
3015 | function toMatch() {
3016 | return {
3017 | compare: function(actual, expected) {
3018 | if (!j$.isString_(expected) && !j$.isA_('RegExp', expected)) {
3019 | throw new Error('Expected is not a String or a RegExp');
3020 | }
3021 |
3022 | var regexp = new RegExp(expected);
3023 |
3024 | return {
3025 | pass: regexp.test(actual)
3026 | };
3027 | }
3028 | };
3029 | }
3030 |
3031 | return toMatch;
3032 | };
3033 |
3034 | getJasmineRequireObj().toThrow = function(j$) {
3035 |
3036 | function toThrow(util) {
3037 | return {
3038 | compare: function(actual, expected) {
3039 | var result = { pass: false },
3040 | threw = false,
3041 | thrown;
3042 |
3043 | if (typeof actual != 'function') {
3044 | throw new Error('Actual is not a Function');
3045 | }
3046 |
3047 | try {
3048 | actual();
3049 | } catch (e) {
3050 | threw = true;
3051 | thrown = e;
3052 | }
3053 |
3054 | if (!threw) {
3055 | result.message = 'Expected function to throw an exception.';
3056 | return result;
3057 | }
3058 |
3059 | if (arguments.length == 1) {
3060 | result.pass = true;
3061 | result.message = function() { return 'Expected function not to throw, but it threw ' + j$.pp(thrown) + '.'; };
3062 |
3063 | return result;
3064 | }
3065 |
3066 | if (util.equals(thrown, expected)) {
3067 | result.pass = true;
3068 | result.message = function() { return 'Expected function not to throw ' + j$.pp(expected) + '.'; };
3069 | } else {
3070 | result.message = function() { return 'Expected function to throw ' + j$.pp(expected) + ', but it threw ' + j$.pp(thrown) + '.'; };
3071 | }
3072 |
3073 | return result;
3074 | }
3075 | };
3076 | }
3077 |
3078 | return toThrow;
3079 | };
3080 |
3081 | getJasmineRequireObj().toThrowError = function(j$) {
3082 | function toThrowError (util) {
3083 | return {
3084 | compare: function(actual) {
3085 | var threw = false,
3086 | pass = {pass: true},
3087 | fail = {pass: false},
3088 | thrown;
3089 |
3090 | if (typeof actual != 'function') {
3091 | throw new Error('Actual is not a Function');
3092 | }
3093 |
3094 | var errorMatcher = getMatcher.apply(null, arguments);
3095 |
3096 | try {
3097 | actual();
3098 | } catch (e) {
3099 | threw = true;
3100 | thrown = e;
3101 | }
3102 |
3103 | if (!threw) {
3104 | fail.message = 'Expected function to throw an Error.';
3105 | return fail;
3106 | }
3107 |
3108 | if (!(thrown instanceof Error)) {
3109 | fail.message = function() { return 'Expected function to throw an Error, but it threw ' + j$.pp(thrown) + '.'; };
3110 | return fail;
3111 | }
3112 |
3113 | if (errorMatcher.hasNoSpecifics()) {
3114 | pass.message = 'Expected function not to throw an Error, but it threw ' + j$.fnNameFor(thrown) + '.';
3115 | return pass;
3116 | }
3117 |
3118 | if (errorMatcher.matches(thrown)) {
3119 | pass.message = function() {
3120 | return 'Expected function not to throw ' + errorMatcher.errorTypeDescription + errorMatcher.messageDescription() + '.';
3121 | };
3122 | return pass;
3123 | } else {
3124 | fail.message = function() {
3125 | return 'Expected function to throw ' + errorMatcher.errorTypeDescription + errorMatcher.messageDescription() +
3126 | ', but it threw ' + errorMatcher.thrownDescription(thrown) + '.';
3127 | };
3128 | return fail;
3129 | }
3130 | }
3131 | };
3132 |
3133 | function getMatcher() {
3134 | var expected = null,
3135 | errorType = null;
3136 |
3137 | if (arguments.length == 2) {
3138 | expected = arguments[1];
3139 | if (isAnErrorType(expected)) {
3140 | errorType = expected;
3141 | expected = null;
3142 | }
3143 | } else if (arguments.length > 2) {
3144 | errorType = arguments[1];
3145 | expected = arguments[2];
3146 | if (!isAnErrorType(errorType)) {
3147 | throw new Error('Expected error type is not an Error.');
3148 | }
3149 | }
3150 |
3151 | if (expected && !isStringOrRegExp(expected)) {
3152 | if (errorType) {
3153 | throw new Error('Expected error message is not a string or RegExp.');
3154 | } else {
3155 | throw new Error('Expected is not an Error, string, or RegExp.');
3156 | }
3157 | }
3158 |
3159 | function messageMatch(message) {
3160 | if (typeof expected == 'string') {
3161 | return expected == message;
3162 | } else {
3163 | return expected.test(message);
3164 | }
3165 | }
3166 |
3167 | return {
3168 | errorTypeDescription: errorType ? j$.fnNameFor(errorType) : 'an exception',
3169 | thrownDescription: function(thrown) {
3170 | var thrownName = errorType ? j$.fnNameFor(thrown.constructor) : 'an exception',
3171 | thrownMessage = '';
3172 |
3173 | if (expected) {
3174 | thrownMessage = ' with message ' + j$.pp(thrown.message);
3175 | }
3176 |
3177 | return thrownName + thrownMessage;
3178 | },
3179 | messageDescription: function() {
3180 | if (expected === null) {
3181 | return '';
3182 | } else if (expected instanceof RegExp) {
3183 | return ' with a message matching ' + j$.pp(expected);
3184 | } else {
3185 | return ' with message ' + j$.pp(expected);
3186 | }
3187 | },
3188 | hasNoSpecifics: function() {
3189 | return expected === null && errorType === null;
3190 | },
3191 | matches: function(error) {
3192 | return (errorType === null || error instanceof errorType) &&
3193 | (expected === null || messageMatch(error.message));
3194 | }
3195 | };
3196 | }
3197 |
3198 | function isStringOrRegExp(potential) {
3199 | return potential instanceof RegExp || (typeof potential == 'string');
3200 | }
3201 |
3202 | function isAnErrorType(type) {
3203 | if (typeof type !== 'function') {
3204 | return false;
3205 | }
3206 |
3207 | var Surrogate = function() {};
3208 | Surrogate.prototype = type.prototype;
3209 | return (new Surrogate()) instanceof Error;
3210 | }
3211 | }
3212 |
3213 | return toThrowError;
3214 | };
3215 |
3216 | getJasmineRequireObj().interface = function(jasmine, env) {
3217 | var jasmineInterface = {
3218 | describe: function(description, specDefinitions) {
3219 | return env.describe(description, specDefinitions);
3220 | },
3221 |
3222 | xdescribe: function(description, specDefinitions) {
3223 | return env.xdescribe(description, specDefinitions);
3224 | },
3225 |
3226 | fdescribe: function(description, specDefinitions) {
3227 | return env.fdescribe(description, specDefinitions);
3228 | },
3229 |
3230 | it: function() {
3231 | return env.it.apply(env, arguments);
3232 | },
3233 |
3234 | xit: function() {
3235 | return env.xit.apply(env, arguments);
3236 | },
3237 |
3238 | fit: function() {
3239 | return env.fit.apply(env, arguments);
3240 | },
3241 |
3242 | beforeEach: function() {
3243 | return env.beforeEach.apply(env, arguments);
3244 | },
3245 |
3246 | afterEach: function() {
3247 | return env.afterEach.apply(env, arguments);
3248 | },
3249 |
3250 | beforeAll: function() {
3251 | return env.beforeAll.apply(env, arguments);
3252 | },
3253 |
3254 | afterAll: function() {
3255 | return env.afterAll.apply(env, arguments);
3256 | },
3257 |
3258 | expect: function(actual) {
3259 | return env.expect(actual);
3260 | },
3261 |
3262 | pending: function() {
3263 | return env.pending.apply(env, arguments);
3264 | },
3265 |
3266 | fail: function() {
3267 | return env.fail.apply(env, arguments);
3268 | },
3269 |
3270 | spyOn: function(obj, methodName) {
3271 | return env.spyOn(obj, methodName);
3272 | },
3273 |
3274 | jsApiReporter: new jasmine.JsApiReporter({
3275 | timer: new jasmine.Timer()
3276 | }),
3277 |
3278 | jasmine: jasmine
3279 | };
3280 |
3281 | jasmine.addCustomEqualityTester = function(tester) {
3282 | env.addCustomEqualityTester(tester);
3283 | };
3284 |
3285 | jasmine.addMatchers = function(matchers) {
3286 | return env.addMatchers(matchers);
3287 | };
3288 |
3289 | jasmine.clock = function() {
3290 | return env.clock;
3291 | };
3292 |
3293 | return jasmineInterface;
3294 | };
3295 |
3296 | getJasmineRequireObj().version = function() {
3297 | return '2.3.4';
3298 | };
3299 |
--------------------------------------------------------------------------------
/test/lib/jasmine-2.3.4/jasmine_favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DevMountain/javascript-3-afternoon/1585995084f5607df7ec3f1168938004ccbffbc4/test/lib/jasmine-2.3.4/jasmine_favicon.png
--------------------------------------------------------------------------------
/test/spec/classesSpec.js:
--------------------------------------------------------------------------------
1 | // ========================
2 |
3 | describe('Classes', function () {
4 | describe('Employee', function () {
5 | it('exists', function () {
6 | expect(new Employee()).not.toBeNull();
7 | })
8 | it('sets all four properties in the constructor', function () {
9 | let emp = new Employee("Dallin", "Anderson", "Dallin@DallinDallin.com", 25);
10 |
11 | expect(emp.first_name).toEqual("Dallin")
12 | expect(emp.last_name).toEqual("Anderson")
13 | expect(emp.email).toEqual("Dallin@DallinDallin.com")
14 | expect(emp.age).toEqual(25)
15 | })
16 | it('can make a widget', function () {
17 | let emp = new Employee("Dallin", "Anderson", "Dallin@DallinDallin.com", 25)
18 | let result = emp.makeWidget()
19 |
20 | expect(result).toEqual("Dallin Anderson Widget")
21 | })
22 | })
23 |
24 | describe('Manager', function () {
25 | it('exists', function () {
26 | expect(new Manager()).not.toBeNull();
27 | })
28 | it('sets all four properties in the constructor and the report', function () {
29 | let emp = new Manager("Dallin", "Anderson", "Dallin@DallinDallin.com", 25);
30 |
31 | expect(emp.first_name).toEqual("Dallin")
32 | expect(emp.last_name).toEqual("Anderson")
33 | expect(emp.email).toEqual("Dallin@DallinDallin.com")
34 | expect(emp.age).toEqual(25)
35 | expect(emp.reports).not.toBeNull();
36 | expect(emp.reports.length).toEqual(0)
37 | })
38 | it('can hire new employees', function () {
39 | let emp = new Manager("Dallin", "Anderson", "Dallin@DallinDallin.com", 25)
40 | emp.hire(new Employee("Ballin", "BAnderson", "Ballin@BallinBallin.com", 22));
41 |
42 | expect(emp.reports.length).toEqual(1)
43 | expect(emp.reports[0].first_name).toEqual("Ballin")
44 | })
45 | it('can fire new employees', function () {
46 | let emp = new Manager("Dallin", "Anderson", "Dallin@DallinDallin.com", 25)
47 | emp.hire(new Employee("Ballin0", "BAnderson", "Ballin@BallinBallin.com", 22));
48 | emp.hire(new Employee("Ballin1", "BAnderson", "Ballin@BallinBallin.com", 22));
49 | emp.hire(new Employee("Ballin2", "BAnderson", "Ballin@BallinBallin.com", 22));
50 | emp.fire(1);
51 |
52 | expect(emp.reports.length).toEqual(2)
53 | expect(emp.reports[0].first_name).toEqual("Ballin0")
54 | expect(emp.reports[1].first_name).toEqual("Ballin2")
55 | })
56 | })
57 |
58 | describe('ProgressiveManager', function () {
59 | it('exists', function () {
60 | expect(new ProgressiveManager()).not.toBeNull();
61 | })
62 | it('sets all properties in the constructor and title and bonus', function () {
63 | let emp = new ProgressiveManager("Dallin", "Anderson", "Dallin@DallinDallin.com", 25);
64 |
65 |
66 | expect(emp.first_name).toEqual("Dallin")
67 | expect(emp.last_name).toEqual("Anderson")
68 | expect(emp.email).toEqual("Dallin@DallinDallin.com")
69 | expect(emp.age).toEqual(25)
70 | expect(emp.reports).not.toBeNull();
71 | expect(emp.reports.length).toEqual(0)
72 | expect(emp.title).toEqual("Not a manager")
73 | expect(emp.bonus).toEqual(0)
74 | })
75 | it('updates title on hire', function () {
76 | let emp = new ProgressiveManager("Dallin", "Anderson", "Dallin@DallinDallin.com", 25)
77 |
78 | emp.hire(new Employee("Ballin", "BAnderson", "Ballin@BallinBallin.com", 22));
79 | expect(emp.title).toEqual("Barely Manager")
80 |
81 | hireTimes(5, emp);
82 | expect(emp.title).toEqual("Mostly Manager")
83 |
84 | hireTimes(20, emp);
85 | expect(emp.title).toEqual("Manager")
86 |
87 | hireTimes(50, emp);
88 | expect(emp.title).toEqual("Manager Plus")
89 |
90 | hireTimes(50, emp);
91 | expect(emp.title).toEqual("Bestest Manager")
92 | })
93 | it('can fire employees for bonuses', function () {
94 | let emp = new ProgressiveManager("Dallin", "Anderson", "Dallin@DallinDallin.com", 25)
95 | hireTimes(10, emp);
96 | emp.fire(1);
97 | expect(emp.bonus).toEqual(100)
98 |
99 | emp.fire(1);
100 | emp.fire(1);
101 | emp.fire(1);
102 | expect(emp.bonus).toEqual(400)
103 | })
104 |
105 | function hireTimes(times, manager) {
106 | for (var i = 0; i < times; i++) {
107 | manager.hire(new Employee("Ballin", "BAnderson", "Ballin@BallinBallin.com", 22));
108 | }
109 | }
110 | })
111 |
112 |
113 | describe('Machine', function () {
114 | it('exists', function () {
115 | expect(new Machine()).not.toBeNull();
116 | })
117 | it('sets all properties in the constructor and the report', function () {
118 | let machine = new Machine();
119 |
120 | expect(machine.widgets_made_count).toEqual(0)
121 | expect(machine.wear_and_tear_count).toEqual(0)
122 | expect(machine.needs_reboot).toEqual(false)
123 | })
124 | it('can make widgets', function () {
125 | let machine = new Machine();
126 |
127 | machine.makeWidgets(50)
128 | expect(machine.widgets_made_count).toEqual(50)
129 | expect(machine.wear_and_tear_count).toEqual(1)
130 | expect(machine.needs_reboot).toEqual(false)
131 | })
132 | it('updates wear and tear when making widgets', function () {
133 | let machine = new Machine();
134 |
135 | machine.makeWidgets(50);
136 | expect(machine.widgets_made_count).toEqual(50)
137 | expect(machine.wear_and_tear_count).toEqual(1)
138 | expect(machine.needs_reboot).toEqual(false)
139 |
140 | machine.makeWidgets(500);
141 | expect(machine.widgets_made_count).toEqual(550)
142 | expect(machine.wear_and_tear_count).toEqual(11)
143 | expect(machine.needs_reboot).toEqual(false)
144 | })
145 | it('can register fixes', function () {
146 | let machine = new Machine();
147 |
148 | machine.makeWidgets(5000);
149 | machine.fixMachine();
150 |
151 | expect(machine.needs_reboot).toBe(true);
152 | })
153 | it('can update wear and tear after fixes and reboot', function () {
154 | let machine = new Machine();
155 | machine.makeWidgets(5000);
156 | machine.fixMachine();
157 |
158 | let rebootComplete = machine.reboot();
159 | // Ensure the values haven't been changed yet.
160 | expect(machine.wear_and_tear_count).toEqual(100, 'wear_and_tear_count should be 100 until function returned by machine.reboot() is executed.');
161 | expect(machine.needs_reboot).toBe(true, 'needs_reboot should be true until function returned by machine.reboot() is executed.');
162 |
163 | rebootComplete();
164 | expect(machine.wear_and_tear_count).toEqual(90);
165 | expect(machine.needs_reboot).toBe(false);
166 | })
167 | })
168 | })
169 |
--------------------------------------------------------------------------------
/test/spec/destructuringSpec.js:
--------------------------------------------------------------------------------
1 | // ========================
2 |
3 | describe('Object destructuring for new variables', function () {
4 | describe('color', function () {
5 | it('should exist', function () {
6 | expect(color).toBeDefined();
7 | })
8 | it('should have the correct value', function () {
9 | expect(color).toBe('red');
10 | })
11 | })
12 |
13 | describe('model', function () {
14 | it('should exist', function () {
15 | expect(model).toBeDefined();
16 | })
17 | it('should have the correct value', function () {
18 | expect(model).toBe('tacoma');
19 | })
20 | })
21 |
22 | describe('make', function () {
23 | it('should exist', function () {
24 | expect(make).toBeDefined();
25 | })
26 | it('should have the correct value', function () {
27 | expect(make).toBe('toyota');
28 | })
29 | })
30 |
31 | describe('year', function () {
32 | it('should exist', function () {
33 | expect(year).toBeDefined();
34 | })
35 | it('should have the correct value', function () {
36 | expect(year).toBe(1994);
37 | })
38 | })
39 | })
40 |
41 |
42 | // ========================
43 |
44 |
45 | describe('greeting', function () {
46 | it('should exist', function () {
47 | expect(greeting).toBeDefined();
48 | })
49 | it('should return the correct value', function () {
50 | expect(greeting({firstName: 'Henry', lastName: 'Von Eckleberry', title: 'Sir'})).toBe('Hello, Sir Henry Von Eckleberry!');
51 | expect(greeting({firstName: 'Betty', lastName: 'LeJavascript', title: 'Queen'})).toBe('Hello, Queen Betty LeJavascript!');
52 | })
53 | })
54 |
55 |
56 | // ========================
57 |
58 |
59 | describe('totalPopulation', function () {
60 | it('should exist', function () {
61 | expect(totalPopulation).toBeDefined();
62 | })
63 | it('should return the correct value', function () {
64 | expect(totalPopulation({utah: 10, california: 29087, texas: 82937, arizona: 28347})).toBe(140381);
65 | expect(totalPopulation({utah: 1045, california: 987, texas: 192937, arizona: 347})).toBe(195316);
66 | })
67 | })
68 |
69 |
70 | // ========================
71 |
72 |
73 | describe('ingredients', function () {
74 | it('should exist', function () {
75 | expect(ingredients).toBeDefined();
76 | })
77 | it('should return the correct value', function () {
78 | expect(ingredients({carb: 'flour', fat: 'butter', protein: 'eggs'}).sort()).toEqual([ 'flour', 'butter', 'eggs' ].sort());
79 | expect(ingredients({carb: 'rice', fat: 'bacon grease', protein: 'chicken'}).sort()).toEqual([ 'rice', 'bacon grease', 'chicken' ].sort());
80 | })
81 | })
82 |
83 |
84 | // ========================
85 |
86 |
87 | describe('largeNumbers', function () {
88 | it('should exist', function () {
89 | expect(largeNumbers).toBeDefined();
90 | })
91 | it('should return the correct value', function () {
92 | expect(largeNumbers({first: 10, second: 2, third: 90})).toBe(2);
93 | expect(largeNumbers({first: 1, second: 2, third: 80})).toBe(1);
94 | })
95 | })
96 |
97 |
98 | // ========================
99 |
100 |
101 | describe('numberGroups', function () {
102 | it('should exist', function () {
103 | expect(numberGroups).toBeDefined();
104 | })
105 | it('should return the correct value', function () {
106 | expect(numberGroups({a:[1, 2, 3], b:[1], c:[1, 2, 3, 4, 5]})).toEqual([ 1, 2, 3, 4, 5 ]);
107 | expect(numberGroups({a:[1, 2, 3], b:[1, 2, 3, 4], c:[1, 2, 3]})).toEqual([ 1, 2, 3, 4 ]);
108 | })
109 | })
110 |
--------------------------------------------------------------------------------
/test/spec/for-in-delete-spec.js:
--------------------------------------------------------------------------------
1 | describe('showValues', function () {
2 | it('should exist', function () {
3 | expect(showValues).toBeDefined();
4 | })
5 | it('should return the correct value', function () {
6 | expect(showValues({one: 'These', two: ' are', three: ' the', four: ' property', five: ' values.'})).toBe('These are the property values.');
7 | expect(showValues({one: 'Conquer', two: ' the', three: ' world', four: ' as a', five: ' javascript ninja!'})).toBe('Conquer the world as a javascript ninja!');
8 | })
9 | })
10 |
11 | // ========================
12 |
13 | describe('greaterThan10', function () {
14 | it('should exist', function () {
15 | expect(greaterThan10).toBeDefined();
16 | })
17 | it('should return the correct value', function () {
18 | expect(greaterThan10({one: 1, two: 2, three: 11, four: 44, five: 5})).toEqual({ one: 1, two: 2, three: 0, four: 0, five: 5 });
19 | expect(greaterThan10({one: 10, two: 20, three: 11, four: 4, five: 335})).toEqual({ one: 10, two: 0, three: 0, four: 4, five: 0 });
20 | })
21 | })
22 |
23 | // ========================
24 |
25 |
26 | describe('double', function () {
27 | it('should exist', function () {
28 | expect(double).toBeDefined();
29 | })
30 | it('should return the correct value', function () {
31 | expect(double({one: 1, two: 2, three: 3})).toEqual({ one: 2, two: 4, three: 6 });
32 | expect(double({one: 177, two: 2234, three: 23})).toEqual({ one: 354, two: 4468, three: 46 });
33 | })
34 | })
35 |
36 |
37 | // ========================
38 |
39 |
40 | describe('secrets', function () {
41 | it('should exist', function () {
42 | expect(secrets).toBeDefined();
43 | })
44 | it('should return the correct value', function () {
45 | expect(secrets({shhh: 'I really', one: 'this is no secret', shake: ', really love ', shed: 'javascript!', two: 'this also does not belong'})).toBe('I really, really love javascript!');
46 |
47 | expect(secrets({sh: 'Cheese', sally: 'this is no secret', shake: ' is', shed: ' disgusting :(', sue: 'this also does not belong', s: 'nope!'})).toBe('Cheese is disgusting :(');
48 | })
49 | })
50 |
51 |
52 | // ========================
53 |
54 |
55 | describe('removePassword', function () {
56 | it('should exist', function () {
57 | expect(removePassword).toBeDefined();
58 | })
59 | it('should return the correct value', function () {
60 | expect(removePassword({username: 'happyCow23', password: '123jumptheMoon'})).toEqual({ username: 'happyCow23' });
61 | expect(removePassword({username: 'JSQueen', password: 'es6RulesTheWorld'})).toEqual({ username: 'JSQueen' });
62 | })
63 | })
64 |
65 |
66 | // ========================
67 |
68 |
69 | describe('deleteTheBigNumbers', function () {
70 | it('should exist', function () {
71 | expect(deleteTheBigNumbers).toBeDefined();
72 | })
73 | it('properties should be deleted in the for in loop', function () {
74 | expect(deleteTheBigNumbers).toEqual({first: 10, second: 20});
75 | })
76 | })
77 |
78 |
79 | // ========================
80 |
81 |
82 | describe('startsWithK', function () {
83 | it('should exist', function () {
84 | expect(startsWithK).toBeDefined();
85 | })
86 | it('should return the correct value', function () {
87 | expect(startsWithK({kitty: 2, dog: 3, cat: 4})).toEqual({ dog: 3, cat: 4 });
88 | expect(startsWithK({snake: 2, cougar: 3, kangaroo: 4})).toEqual({ snake: 2, cougar: 3 });
89 | })
90 | })
91 |
92 |
93 | // ========================
94 |
95 |
96 | describe('hiddenTreasure', function () {
97 | it('should exist', function () {
98 | expect(hiddenTreasure).toBeDefined();
99 | })
100 | it('should return the correct value', function () {
101 | expect(hiddenTreasure({one: 'this has none', two: 'big treasure!', three: 'only disappointment'})).toEqual({ two: 'big treasure!' });
102 | expect(hiddenTreasure({one: 'happiness but no money', two: 'puppies are always a treasure', three: 'rocks, lots of rocks'})).toEqual({ two: 'puppies are always a treasure' });
103 | })
104 | })
--------------------------------------------------------------------------------
/test/spec/higher-order-spec.js:
--------------------------------------------------------------------------------
1 | describe('filters1', ()=>{
2 | describe('evenNumbers', ()=>{
3 | it('should exist', ()=>{
4 | expect(evenNumbers).toBeDefined();
5 | })
6 | it('should be an array', ()=>{
7 | expect(evenNumbers.length).toBeDefined();
8 | })
9 | it('should have 8 elements', ()=>{
10 | expect(evenNumbers.length).toBe(8);
11 | })
12 | it('should have the correct elements', ()=>{
13 | expect(evenNumbers.sort().toString()).toBe([6, 2, 6, 8, 4, 2, 8, 4].sort().toString());
14 | })
15 | })
16 | })
17 |
18 | describe('map1', ()=>{
19 | describe('postTaxPrices', ()=>{
20 | it('should exist', ()=>{
21 | expect(postTaxPrices).toBeDefined();
22 | })
23 | it('should be an array', ()=>{
24 | expect(postTaxPrices.length).toBeDefined();
25 | })
26 | it('should have 9 elements', ()=>{
27 | expect(postTaxPrices.length).toBe(9);
28 | })
29 | it('should have the correct prices', ()=>{
30 | let incorrect = [16.05, 24.610000000000003, 83.46000000000001, 36.38,
31 | 12.84, 92.02000000000001, 12.84, 84.53, 34.24].reduce(
32 | (p, e, i)=>p||(Math.abs(e-postTaxPrices[i])>.02), false)
33 | expect(incorrect).toBe(false);
34 | })
35 | })
36 | })
37 |
38 | describe('reduce1', ()=>{
39 | describe('totalPopulation', ()=>{
40 | it('should exist', ()=>{
41 | expect(totalPopulation).toBeDefined();
42 | })
43 | it('should have the correct total', ()=>{
44 | expect(totalPopulation).toBe(16763615);
45 | })
46 | })
47 | })
48 |
49 | describe('filters2', ()=>{
50 | describe('myStrongest', ()=>{
51 | it('should exist', ()=>{
52 | expect(myStrongest).toBeDefined();
53 | })
54 | it('should be an array', ()=>{
55 | expect(myStrongest.length).toBeDefined();
56 | })
57 | it('should have 9 elements', ()=>{
58 | expect(myStrongest.length).toBe(9);
59 | })
60 | it('should have the correct monsters', ()=>{
61 | expect(myStrongest.map(e=>e.monster).sort().toString())
62 | .toEqual(monstersInYourPocket.filter(e=>e.CP>200).map(e=>e.monster).sort().toString());
63 | expect(myStrongest.map(e=>e.CP).sort().toString())
64 | .toEqual(monstersInYourPocket.filter(e=>e.CP>200).map(e=>e.CP).sort().toString());
65 | })
66 | })
67 | })
68 |
69 | describe('map2', ()=>{
70 | describe('orderTotals', ()=>{
71 | it('should exist', ()=>{
72 | expect(orderTotals).toBeDefined();
73 | })
74 | it('should be an array', ()=>{
75 | expect(orderTotals.length).toBeDefined();
76 | })
77 | it('should have 10 elements', ()=>{
78 | expect(orderTotals.length).toBe(10);
79 | })
80 | it('should have the correct prices', ()=>{
81 | for (let i = 0; i < orders.length; i++) {
82 | const answer = orders[i].price * (1 + orders[i].tax);
83 | expect(orderTotals[i]).toBe(answer, `Expected orderTotals index ${i} to be ${answer}, got ${orderTotals[i]}`)
84 | if (orderTotals[i] != answer) {
85 | break;
86 | }
87 | }
88 | })
89 | })
90 | })
91 |
92 | describe('reduce2', ()=>{
93 | describe('bobsTotal', ()=>{
94 | it('should exist', ()=>{
95 | expect(bobsTotal).toBeDefined();
96 | })
97 | it('should have the correct total', ()=>{
98 | expect(bobsTotal).toBe(891);
99 | })
100 | })
101 | })
102 |
103 | // describe('fns-and-scope', function () {
104 | //
105 | //
106 | // describe('isTyler', function () {
107 | // it('should exist', function () {
108 | // expect(isTyler).toBeDefined();
109 | // })
110 | // it('should return true if passed "Tyler"', function () {
111 | // expect(isTyler('Tyler')).toBe(true);
112 | // })
113 | // it('should return false if passed something other than "Tyler"', function () {
114 | // expect(isTyler('Stan')).toBe(false);
115 | // })
116 | // })
117 | //
118 | // describe('getName', function () {
119 | // beforeEach(function () {
120 | // // var prompt = function () {
121 | // // return true;
122 | // // }
123 | //
124 | // spyOn(window, 'prompt').and.returnValue('My Name');
125 | //
126 | // })
127 | // it('should exist', function () {
128 | // expect(getName).toBeDefined();
129 | // })
130 | // it('should invoke prompt()', function () {
131 | // getName();
132 | // expect(window.prompt).toHaveBeenCalled();
133 | // })
134 | // it('should return the name input from the prompt', function () {
135 | // var name = getName();
136 | // expect(name).toBe('My Name');
137 | // })
138 | // })
139 | //
140 | // describe('welcome', function () {
141 | // beforeEach(function () {
142 | // spyOn(window, 'prompt').and.returnValue('Rockstar');
143 | // spyOn(window, 'alert').and.returnValue('Welcome ' + prompt());
144 | // spyOn(window, 'getName').and.returnValue('Rockstar');
145 | // // var getName = jasmine.createSpy().and.returnValue('Rockstar');
146 | // })
147 | // it('should exist', function () {
148 | // expect(welcome).toBeDefined();
149 | // })
150 | // it('should invoke getName()', function () {
151 | // welcome();
152 | // expect(getName).toHaveBeenCalled();
153 | // })
154 | // it('should invoke alert()', function () {
155 | // welcome();
156 | // expect(alert).toHaveBeenCalled();
157 | // })
158 | // it('should alert "Welcome, " plus the name', function () {
159 | // welcome();
160 | // expect(alert).toHaveBeenCalledWith('Welcome, Rockstar')
161 | // })
162 | // })
163 | //
164 | // describe('myName', function () {
165 | // it('should exist', function () {
166 | // expect(myName).toBeDefined();
167 | // })
168 | // it('should return a string', function () {
169 | // var name = myName();
170 | // expect(name).toEqual(jasmine.any(String));
171 | // })
172 | // })
173 | //
174 | // describe('newMyName', function () {
175 | // it('should exist', function () {
176 | // expect(newMyName).toBeDefined();
177 | // })
178 | // it('should be a function', function () {
179 | // expect(newMyName).toEqual(jasmine.any(Function));
180 | // })
181 | // })
182 | //
183 | // describe('outerFn', function () {
184 | // it('should exist', function () {
185 | // expect(outerFn).toBeDefined();
186 | // })
187 | // it('should return a function', function () {
188 | // var fn = outerFn();
189 | // expect(fn).toEqual(jasmine.any(Function));
190 | // })
191 | // it('should return a function that returns a string', function () {
192 | // var fn = outerFn();
193 | // var str = fn();
194 | // expect(str).toEqual(jasmine.any(String));
195 | // })
196 | // })
197 | //
198 | // describe('innerFn', function () {
199 | // it('should exist', function () {
200 | // expect(innerFn).toBeDefined();
201 | // })
202 | // it('should be a function', function () {
203 | // expect(innerFn).toEqual(jasmine.any(Function));
204 | // })
205 | // it('should return a string', function () {
206 | // var str = innerFn();
207 | // expect(str).toEqual(jasmine.any(String));
208 | // })
209 | // })
210 | //
211 | // })
212 |
--------------------------------------------------------------------------------
/test/spec/nestingSpec.js:
--------------------------------------------------------------------------------
1 | describe('Update Employee Info', function() {
2 | var returnedArr;
3 | it('Theo Trill object should be removed', function() {
4 | returnedArr = employeeUpdater();
5 | var flag = true;
6 | returnedArr.map(function(employee) {
7 | if (employee.firstName === 'Theo') flag = false;
8 | })
9 | expect(flag).toEqual(true);
10 | })
11 |
12 | it('Lorie should be in HR department', function() {
13 | var flag = true;
14 | var lorie = returnedArr.filter(e => e.firstName === 'Lorie')
15 | expect(lorie[0].department).toEqual('HR');
16 | })
17 | })
18 |
19 | describe('Workplace accidents', function() {
20 | it('removeDuplicates function should exist', function() {
21 | expect(removeDuplicates).toEqual(jasmine.any(Function));
22 | })
23 | it('removeDuplicates should return the array of workplace accidents', function() {
24 | returnedArr = removeDuplicates([12, 56, 44, 3, 29, 56, 56, 3, 7, 12])
25 | expect(returnedArr).toEqual(jasmine.any(Array));
26 | })
27 | it ('Should remove all duplicate entries', function() {
28 | var returnedArr = removeDuplicates([12, 56, 44, 3, 29, 56, 56, 3, 7, 12]).sort(function(a,b) {
29 | return a - b;
30 | });
31 | expect(returnedArr).toEqual(jasmine.any(Array));
32 | var answer = [3,7,12,29,44,56];
33 | var flag = true;
34 | returnedArr.map( (n,i) => {
35 | if( n[i] !== answer[i]) flag = false;
36 | })
37 | expect(returnedArr.length).toEqual(6);
38 | })
39 | })
40 |
41 | describe('Fluffy & friends', function() {
42 |
43 | it('grumpyActivity value should be \'eat food\'', function() {
44 | expect(grumpyActivity).toEqual('eat food')
45 | })
46 | it('fluffy2ndFriend should be "Lazy Bones"', function() {
47 | expect(fluffy2ndFriend).toEqual('Lazy Bones');
48 | })
49 | })
50 |
51 | describe('Driving record', function() {
52 | it('recordCleaner should exist', function() {
53 | expect(recordCleaner).toEqual(jasmine.any(Function));
54 | })
55 | it('No longer at fault for accidents', function() {
56 | recordCleaner();
57 | console.log(myCar)
58 | var flag = true;
59 | myCar.accidents.map(function(accident) {
60 | if (accident.atFaultForAccident) {
61 | flag = false;
62 | }
63 | })
64 | expect(flag).toEqual(true);
65 | })
66 | })
67 |
68 | describe('Looper', function() {
69 | it('looper should exist', function() {
70 | expect(looper).toEqual(jasmine.any(Function));
71 | })
72 | it('Array should be filled with "odd" and "even" instead of numbers', function() {
73 | var answer = [ [ 'odd', 'even', 'odd', 'even' ], [ 'odd', 'even' ],[ 'odd', 'even', 'odd', 'even', 'odd' ] ]
74 | var userAnswer = looper();
75 | var flag = true;
76 | for (var i = 0; i < answer.length; i++) {
77 | for(var j = 0; j < answer[i].length; j++) {
78 | if (answer[i][j] !== userAnswer[i][j]) {
79 | flag = false;
80 | }
81 | }
82 | }
83 | expect(flag).toEqual(true);
84 | })
85 |
86 | })
--------------------------------------------------------------------------------
31 |