CoCalc -- strings.test-example.3.summarized.ts

GitHub Repository: microsoft/vscode
Path: blob/main/extensions/copilot/src/extension/prompts/node/test/fixtures/strings.test-example.3.summarized.ts
¹³⁴⁰⁶ views
1
7: 
2
8: suite('Strings', () => {
3
115: 
4
116: 	test('format2', () => {…});
5
126: 
6
127: 	test('lcut', () => {…});
7
138: 
8
139: 	test('escape', () => {…});
9
146: 
10
147: 	test('ltrim', () => {
11
157: 		assert.strictEqual(strings.ltrim('', '/'), '');
12
158: 	});
13
159: 
14
160: 	test('rtrim', () => {
15
161: 		assert.strictEqual(strings.rtrim('foo', 'o'), 'f');
16
162: 		assert.strictEqual(strings.rtrim('foo', 'f'), 'foo');
17
163: 		assert.strictEqual(strings.rtrim('http://www.test.de', '.de'), 'http://www.test');
18
164: 		assert.strictEqual(strings.rtrim('/foo/', '/'), '/foo');
19
165: 		assert.strictEqual(strings.rtrim('/foo//', '/'), '/foo');
20
166: 		assert.strictEqual(strings.rtrim('/', ''), '/');
21
167: 		assert.strictEqual(strings.rtrim('/', '/'), '');
22
168: 		assert.strictEqual(strings.rtrim('///', '/'), '');
23
169: 		assert.strictEqual(strings.rtrim('', ''), '');
24
170: 		assert.strictEqual(strings.rtrim('', '/'), '');
25
171: 	});
26
172: 
27
173: 	test('trim', () => {
28
174: 		assert.strictEqual(strings.trim(' foo '), 'foo');
29
175: 		assert.strictEqual(strings.trim('  foo'), 'foo');
30
176: 		assert.strictEqual(strings.trim('bar  '), 'bar');
31
177: 		assert.strictEqual(strings.trim('   '), '');
32
178: 		assert.strictEqual(strings.trim('foo bar', 'bar'), 'foo ');
33
179: 	});
34
180: 
35
181: 	test('trimWhitespace', () => {
36
182: 		assert.strictEqual(' foo '.trim(), 'foo');
37
183: 		assert.strictEqual('	 foo	'.trim(), 'foo');
38
184: 		assert.strictEqual('  foo'.trim(), 'foo');
39
185: 		assert.strictEqual('bar  '.trim(), 'bar');
40
186: 		assert.strictEqual('   '.trim(), '');
41
187: 		assert.strictEqual(' 	  '.trim(), '');
42
188: 	});
43
189: 
44
190: 	test('lastNonWhitespaceIndex', () => {
45
191: 		assert.strictEqual(strings.lastNonWhitespaceIndex('abc  \t \t '), 2);
46
192: 		assert.strictEqual(strings.lastNonWhitespaceIndex('abc'), 2);
47
193: 		assert.strictEqual(strings.lastNonWhitespaceIndex('abc\t'), 2);
48
194: 		assert.strictEqual(strings.lastNonWhitespaceIndex('abc '), 2);
49
195: 		assert.strictEqual(strings.lastNonWhitespaceIndex('abc  \t \t '), 2);
50
196: 		assert.strictEqual(strings.lastNonWhitespaceIndex('abc  \t \t abc \t \t '), 11);
51
197: 		assert.strictEqual(strings.lastNonWhitespaceIndex('abc  \t \t abc \t \t ', 8), 2);
52
198: 		assert.strictEqual(strings.lastNonWhitespaceIndex('  \t \t '), -1);
53
199: 	});
54
200: 
55
201: 	test('containsRTL', () => {
56
202: 		assert.strictEqual(strings.containsRTL('a'), false);
57
203: 		assert.strictEqual(strings.containsRTL(''), false);
58
204: 		assert.strictEqual(strings.containsRTL(strings.UTF8_BOM_CHARACTER + 'a'), false);
59
205: 		assert.strictEqual(strings.containsRTL('hello world!'), false);
60
206: 		assert.strictEqual(strings.containsRTL('a📚📚b'), false);
61
207: 		assert.strictEqual(strings.containsRTL('هناك حقيقة مثبتة منذ زمن طويل'), true);
62
208: 		assert.strictEqual(strings.containsRTL('זוהי עובדה מבוססת שדעתו'), true);
63
209: 	});
64
210: 
65
211: 	test('issue #115221: isEmojiImprecise misses ⭐', () => {
66
212: 		const codePoint = strings.getNextCodePoint('⭐', '⭐'.length, 0);
67
213: 		assert.strictEqual(strings.isEmojiImprecise(codePoint), true);
68
214: 	});
69
215: 
70
216: 	test('isBasicASCII', () => {
71
217: 		function assertIsBasicASCII(str: string, expected: boolean): void {
72
218: 			assert.strictEqual(strings.isBasicASCII(str), expected, str + ` (${str.charCodeAt(0)})`);
73
219: 		}
74
220: 		assertIsBasicASCII('abcdefghijklmnopqrstuvwxyz', true);
75
221: 		assertIsBasicASCII('ABCDEFGHIJKLMNOPQRSTUVWXYZ', true);
76
222: 		assertIsBasicASCII('1234567890', true);
77
223: 		assertIsBasicASCII('`~!@#$%^&*()-_=+[{]}\\|;:\'",<.>/?', true);
78
224: 		assertIsBasicASCII(' ', true);
79
225: 		assertIsBasicASCII('\t', true);
80
226: 		assertIsBasicASCII('\n', true);
81
227: 		assertIsBasicASCII('\r', true);
82
228: 
83
229: 		let ALL = '\r\t\n';
84
230: 		for (let i = 32; i < 127; i++) {
85
231: 			ALL += String.fromCharCode(i);
86
232: 		}
87
233: 		assertIsBasicASCII(ALL, true);
88
234: 
89
235: 		assertIsBasicASCII(String.fromCharCode(31), false);
90
236: 		assertIsBasicASCII(String.fromCharCode(127), false);
91
237: 		assertIsBasicASCII('ü', false);
92
238: 		assertIsBasicASCII('a📚📚b', false);
93
239: 	});
94
240: 
95
241: 	test('createRegExp', () => {
96
242: 		// Empty
97
243: 		assert.throws(() => strings.createRegExp('', false));
98
244: 
99
245: 		// Escapes appropriately
100
246: 		assert.strictEqual(strings.createRegExp('abc', false).source, 'abc');
101
247: 		assert.strictEqual(strings.createRegExp('([^ ,.]*)', false).source, '\\(\\[\\^ ,\\.\\]\\*\\)');
102
248: 		assert.strictEqual(strings.createRegExp('([^ ,.]*)', true).source, '([^ ,.]*)');
103
249: 
104
250: 		// Whole word
105
251: 		assert.strictEqual(strings.createRegExp('abc', false, { wholeWord: true }).source, '\\babc\\b');
106
252: 		assert.strictEqual(strings.createRegExp('abc', true, { wholeWord: true }).source, '\\babc\\b');
107
253: 		assert.strictEqual(strings.createRegExp(' abc', true, { wholeWord: true }).source, ' abc\\b');
108
254: 		assert.strictEqual(strings.createRegExp('abc ', true, { wholeWord: true }).source, '\\babc ');
109
255: 		assert.strictEqual(strings.createRegExp(' abc ', true, { wholeWord: true }).source, ' abc ');
110
256: 
111
257: 		const regExpWithoutFlags = strings.createRegExp('abc', true);
112
258: 		assert(!regExpWithoutFlags.global);
113
259: 		assert(regExpWithoutFlags.ignoreCase);
114
260: 		assert(!regExpWithoutFlags.multiline);
115
261: 
116
262: 		const regExpWithFlags = strings.createRegExp('abc', true, { global: true, matchCase: true, multiline: true });
117
263: 		assert(regExpWithFlags.global);
118
264: 		assert(!regExpWithFlags.ignoreCase);
119
265: 		assert(regExpWithFlags.multiline);
120
266: 	});
121
267: 
122
268: 	test('regExpContainsBackreference', () => {
123
269: 		assert(strings.regExpContainsBackreference('foo \\5 bar'));
124
270: 		assert(strings.regExpContainsBackreference('\\2'));
125
271: 		assert(strings.regExpContainsBackreference('(\\d)(\\n)(\\1)'));
126
272: 		assert(strings.regExpContainsBackreference('(A).*?\\1'));
127
273: 		assert(strings.regExpContainsBackreference('\\\\\\1'));
128
274: 		assert(strings.regExpContainsBackreference('foo \\\\\\1'));
129
275: 
130
276: 		assert(!strings.regExpContainsBackreference(''));
131
277: 		assert(!strings.regExpContainsBackreference('\\\\1'));
132
278: 		assert(!strings.regExpContainsBackreference('foo \\\\1'));
133
279: 		assert(!strings.regExpContainsBackreference('(A).*?\\\\1'));
134
280: 		assert(!strings.regExpContainsBackreference('foo \\d1 bar'));
135
281: 		assert(!strings.regExpContainsBackreference('123'));
136
282: 	});
137
283: 
138
284: 	test('getLeadingWhitespace', () => {
139
285: 		assert.strictEqual(strings.getLeadingWhitespace('  foo'), '  ');
140
286: 		assert.strictEqual(strings.getLeadingWhitespace('  foo', 2), '');
141
287: 		assert.strictEqual(strings.getLeadingWhitespace('  foo', 1, 1), '');
142
288: 		assert.strictEqual(strings.getLeadingWhitespace('  foo', 0, 1), ' ');
143
289: 		assert.strictEqual(strings.getLeadingWhitespace('  '), '  ');
144
290: 		assert.strictEqual(strings.getLeadingWhitespace('  ', 1), ' ');
145
291: 		assert.strictEqual(strings.getLeadingWhitespace('  ', 0, 1), ' ');
146
292: 		assert.strictEqual(strings.getLeadingWhitespace('\t\tfunction foo(){', 0, 1), '\t');
147
293: 		assert.strictEqual(strings.getLeadingWhitespace('\t\tfunction foo(){', 0, 2), '\t\t');
148
294: 	});
149
295: 
150
296: 	test('fuzzyContains', () => {
151
297: 		assert.ok(!strings.fuzzyContains((undefined)!, null!));
152
298: 		assert.ok(strings.fuzzyContains('hello world', 'h'));
153
299: 		assert.ok(!strings.fuzzyContains('hello world', 'q'));
154
300: 		assert.ok(strings.fuzzyContains('hello world', 'hw'));
155
301: 		assert.ok(strings.fuzzyContains('hello world', 'horl'));
156
302: 		assert.ok(strings.fuzzyContains('hello world', 'd'));
157
303: 		assert.ok(!strings.fuzzyContains('hello world', 'wh'));
158
304: 		assert.ok(!strings.fuzzyContains('d', 'dd'));
159
305: 	});
160
306: 
161
307: 	test('startsWithUTF8BOM', () => {
162
308: 		assert(strings.startsWithUTF8BOM(strings.UTF8_BOM_CHARACTER));
163
309: 		assert(strings.startsWithUTF8BOM(strings.UTF8_BOM_CHARACTER + 'a'));
164
310: 		assert(strings.startsWithUTF8BOM(strings.UTF8_BOM_CHARACTER + 'aaaaaaaaaa'));
165
311: 		assert(!strings.startsWithUTF8BOM(' ' + strings.UTF8_BOM_CHARACTER));
166
312: 		assert(!strings.startsWithUTF8BOM('foo'));
167
313: 		assert(!strings.startsWithUTF8BOM(''));
168
314: 	});
169
315: 
170
316: 	test('stripUTF8BOM', () => {
171
317: 		assert.strictEqual(strings.stripUTF8BOM(strings.UTF8_BOM_CHARACTER), '');
172
318: 		assert.strictEqual(strings.stripUTF8BOM(strings.UTF8_BOM_CHARACTER + 'foobar'), 'foobar');
173
319: 		assert.strictEqual(strings.stripUTF8BOM('foobar' + strings.UTF8_BOM_CHARACTER), 'foobar' + strings.UTF8_BOM_CHARACTER);
174
320: 		assert.strictEqual(strings.stripUTF8BOM('abc'), 'abc');
175
321: 		assert.strictEqual(strings.stripUTF8BOM(''), '');
176
322: 	});
177
323: 
178
324: 	test('containsUppercaseCharacter', () => {
179
325: 		[
180
326: 			[null, false],
181
327: 			['', false],
182
328: 			['foo', false],
183
329: 			['föö', false],
184
330: 			['ناك', false],
185
331: 			['מבוססת', false],
186
332: 			['😀', false],
187
333: 			['(#@()*&%()@*#&09827340982374}{:">?></\'\\~`', false],
188
334: 
189
335: 			['Foo', true],
190
336: 			['FOO', true],
191
337: 			['FöÖ', true],
192
338: 			['FöÖ', true],
193
339: 			['\\Foo', true],
194
340: 		].forEach(([str, result]) => {
195
341: 			assert.strictEqual(strings.containsUppercaseCharacter(<string>str), result, `Wrong result for ${str}`);
196
342: 		});
197
343: 	});
198
344: 
199
345: 
200
346: 
201
347: 	test('containsUppercaseCharacter (ignoreEscapedChars)', () => {
202
348: 		[
203
349: 			['\\Woo', false],
204
350: 			['f\\S\\S', false],
205
351: 			['foo', false],
206
352: 
207
353: 			['Foo', true],
208
354: 		].forEach(([str, result]) => {
209
355: 			assert.strictEqual(strings.containsUppercaseCharacter(<string>str, true), result, `Wrong result for ${str}`);
210
356: 		});
211
357: 	});
212
358: 
213
359: });
214

215
Product

Resources

Company
