1 | var test = require('tape');
|
2 | var forEach = require('for-each');
|
3 |
|
4 | var inspect = require('../');
|
5 |
|
6 | test('bad indent options', function (t) {
|
7 | forEach([
|
8 | undefined,
|
9 | true,
|
10 | false,
|
11 | -1,
|
12 | 1.2,
|
13 | Infinity,
|
14 | -Infinity,
|
15 | NaN
|
16 | ], function (indent) {
|
17 | t['throws'](
|
18 | function () { inspect('', { indent: indent }); },
|
19 | TypeError,
|
20 | inspect(indent) + ' is invalid'
|
21 | );
|
22 | });
|
23 |
|
24 | t.end();
|
25 | });
|
26 |
|
27 | test('simple object with indent', function (t) {
|
28 | t.plan(2);
|
29 |
|
30 | var obj = { a: 1, b: 2 };
|
31 |
|
32 | var expectedSpaces = [
|
33 | '{',
|
34 | ' a: 1,',
|
35 | ' b: 2',
|
36 | '}'
|
37 | ].join('\n');
|
38 | var expectedTabs = [
|
39 | '{',
|
40 | ' a: 1,',
|
41 | ' b: 2',
|
42 | '}'
|
43 | ].join('\n');
|
44 |
|
45 | t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
|
46 | t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
|
47 | });
|
48 |
|
49 | test('two deep object with indent', function (t) {
|
50 | t.plan(2);
|
51 |
|
52 | var obj = { a: 1, b: { c: 3, d: 4 } };
|
53 |
|
54 | var expectedSpaces = [
|
55 | '{',
|
56 | ' a: 1,',
|
57 | ' b: {',
|
58 | ' c: 3,',
|
59 | ' d: 4',
|
60 | ' }',
|
61 | '}'
|
62 | ].join('\n');
|
63 | var expectedTabs = [
|
64 | '{',
|
65 | ' a: 1,',
|
66 | ' b: {',
|
67 | ' c: 3,',
|
68 | ' d: 4',
|
69 | ' }',
|
70 | '}'
|
71 | ].join('\n');
|
72 |
|
73 | t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
|
74 | t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
|
75 | });
|
76 |
|
77 | test('simple array with all single line elements', function (t) {
|
78 | t.plan(2);
|
79 |
|
80 | var obj = [1, 2, 3, 'asdf\nsdf'];
|
81 |
|
82 | var expected = '[ 1, 2, 3, \'asdf\\nsdf\' ]';
|
83 |
|
84 | t.equal(inspect(obj, { indent: 2 }), expected, 'two');
|
85 | t.equal(inspect(obj, { indent: '\t' }), expected, 'tabs');
|
86 | });
|
87 |
|
88 | test('array with complex elements', function (t) {
|
89 | t.plan(2);
|
90 |
|
91 | var obj = [1, { a: 1, b: { c: 1 } }, 'asdf\nsdf'];
|
92 |
|
93 | var expectedSpaces = [
|
94 | '[',
|
95 | ' 1,',
|
96 | ' {',
|
97 | ' a: 1,',
|
98 | ' b: {',
|
99 | ' c: 1',
|
100 | ' }',
|
101 | ' },',
|
102 | ' \'asdf\\nsdf\'',
|
103 | ']'
|
104 | ].join('\n');
|
105 | var expectedTabs = [
|
106 | '[',
|
107 | ' 1,',
|
108 | ' {',
|
109 | ' a: 1,',
|
110 | ' b: {',
|
111 | ' c: 1',
|
112 | ' }',
|
113 | ' },',
|
114 | ' \'asdf\\nsdf\'',
|
115 | ']'
|
116 | ].join('\n');
|
117 |
|
118 | t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
|
119 | t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
|
120 | });
|
121 |
|
122 | test('values', function (t) {
|
123 | t.plan(2);
|
124 | var obj = [{}, [], { 'a-b': 5 }];
|
125 |
|
126 | var expectedSpaces = [
|
127 | '[',
|
128 | ' {},',
|
129 | ' [],',
|
130 | ' {',
|
131 | ' \'a-b\': 5',
|
132 | ' }',
|
133 | ']'
|
134 | ].join('\n');
|
135 | var expectedTabs = [
|
136 | '[',
|
137 | ' {},',
|
138 | ' [],',
|
139 | ' {',
|
140 | ' \'a-b\': 5',
|
141 | ' }',
|
142 | ']'
|
143 | ].join('\n');
|
144 |
|
145 | t.equal(inspect(obj, { indent: 2 }), expectedSpaces, 'two');
|
146 | t.equal(inspect(obj, { indent: '\t' }), expectedTabs, 'tabs');
|
147 | });
|
148 |
|
149 | test('Map', { skip: typeof Map !== 'function' }, function (t) {
|
150 | var map = new Map();
|
151 | map.set({ a: 1 }, ['b']);
|
152 | map.set(3, NaN);
|
153 |
|
154 | var expectedStringSpaces = [
|
155 | 'Map (2) {',
|
156 | ' { a: 1 } => [ \'b\' ],',
|
157 | ' 3 => NaN',
|
158 | '}'
|
159 | ].join('\n');
|
160 | var expectedStringTabs = [
|
161 | 'Map (2) {',
|
162 | ' { a: 1 } => [ \'b\' ],',
|
163 | ' 3 => NaN',
|
164 | '}'
|
165 | ].join('\n');
|
166 | var expectedStringTabsDoubleQuotes = [
|
167 | 'Map (2) {',
|
168 | ' { a: 1 } => [ "b" ],',
|
169 | ' 3 => NaN',
|
170 | '}'
|
171 | ].join('\n');
|
172 |
|
173 | t.equal(
|
174 | inspect(map, { indent: 2 }),
|
175 | expectedStringSpaces,
|
176 | 'Map keys are not indented (two)'
|
177 | );
|
178 | t.equal(
|
179 | inspect(map, { indent: '\t' }),
|
180 | expectedStringTabs,
|
181 | 'Map keys are not indented (tabs)'
|
182 | );
|
183 | t.equal(
|
184 | inspect(map, { indent: '\t', quoteStyle: 'double' }),
|
185 | expectedStringTabsDoubleQuotes,
|
186 | 'Map keys are not indented (tabs + double quotes)'
|
187 | );
|
188 |
|
189 | t.equal(inspect(new Map(), { indent: 2 }), 'Map (0) {}', 'empty Map should show as empty (two)');
|
190 | t.equal(inspect(new Map(), { indent: '\t' }), 'Map (0) {}', 'empty Map should show as empty (tabs)');
|
191 |
|
192 | var nestedMap = new Map();
|
193 | nestedMap.set(nestedMap, map);
|
194 | var expectedNestedSpaces = [
|
195 | 'Map (1) {',
|
196 | ' [Circular] => Map (2) {',
|
197 | ' { a: 1 } => [ \'b\' ],',
|
198 | ' 3 => NaN',
|
199 | ' }',
|
200 | '}'
|
201 | ].join('\n');
|
202 | var expectedNestedTabs = [
|
203 | 'Map (1) {',
|
204 | ' [Circular] => Map (2) {',
|
205 | ' { a: 1 } => [ \'b\' ],',
|
206 | ' 3 => NaN',
|
207 | ' }',
|
208 | '}'
|
209 | ].join('\n');
|
210 | t.equal(inspect(nestedMap, { indent: 2 }), expectedNestedSpaces, 'Map containing a Map should work (two)');
|
211 | t.equal(inspect(nestedMap, { indent: '\t' }), expectedNestedTabs, 'Map containing a Map should work (tabs)');
|
212 |
|
213 | t.end();
|
214 | });
|
215 |
|
216 | test('Set', { skip: typeof Set !== 'function' }, function (t) {
|
217 | var set = new Set();
|
218 | set.add({ a: 1 });
|
219 | set.add(['b']);
|
220 | var expectedStringSpaces = [
|
221 | 'Set (2) {',
|
222 | ' {',
|
223 | ' a: 1',
|
224 | ' },',
|
225 | ' [ \'b\' ]',
|
226 | '}'
|
227 | ].join('\n');
|
228 | var expectedStringTabs = [
|
229 | 'Set (2) {',
|
230 | ' {',
|
231 | ' a: 1',
|
232 | ' },',
|
233 | ' [ \'b\' ]',
|
234 | '}'
|
235 | ].join('\n');
|
236 | t.equal(inspect(set, { indent: 2 }), expectedStringSpaces, 'new Set([{ a: 1 }, ["b"]]) should show size and contents (two)');
|
237 | t.equal(inspect(set, { indent: '\t' }), expectedStringTabs, 'new Set([{ a: 1 }, ["b"]]) should show size and contents (tabs)');
|
238 |
|
239 | t.equal(inspect(new Set(), { indent: 2 }), 'Set (0) {}', 'empty Set should show as empty (two)');
|
240 | t.equal(inspect(new Set(), { indent: '\t' }), 'Set (0) {}', 'empty Set should show as empty (tabs)');
|
241 |
|
242 | var nestedSet = new Set();
|
243 | nestedSet.add(set);
|
244 | nestedSet.add(nestedSet);
|
245 | var expectedNestedSpaces = [
|
246 | 'Set (2) {',
|
247 | ' Set (2) {',
|
248 | ' {',
|
249 | ' a: 1',
|
250 | ' },',
|
251 | ' [ \'b\' ]',
|
252 | ' },',
|
253 | ' [Circular]',
|
254 | '}'
|
255 | ].join('\n');
|
256 | var expectedNestedTabs = [
|
257 | 'Set (2) {',
|
258 | ' Set (2) {',
|
259 | ' {',
|
260 | ' a: 1',
|
261 | ' },',
|
262 | ' [ \'b\' ]',
|
263 | ' },',
|
264 | ' [Circular]',
|
265 | '}'
|
266 | ].join('\n');
|
267 | t.equal(inspect(nestedSet, { indent: 2 }), expectedNestedSpaces, 'Set containing a Set should work (two)');
|
268 | t.equal(inspect(nestedSet, { indent: '\t' }), expectedNestedTabs, 'Set containing a Set should work (tabs)');
|
269 |
|
270 | t.end();
|
271 | });
|