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

GitHub Repository: microsoft/vscode
Path: blob/main/extensions/copilot/src/extension/prompts/node/test/fixtures/strings.test-example.2.summarized.ts
¹³⁴⁰⁶ views
1

2
suite('Strings', () => {
3
	/* Lines 9-104 omitted */
4

5
	test('format', () => {/* Lines 106-114 omitted */});
6

7
	test('format2', () => {/* Lines 117-125 omitted */});
8

9
	test('lcut', () => {
10
		/* Lines 128-136 omitted */
11
		assert.strictEqual(strings.lcut('a', 10), 'a');
12
	});
13

14
	test('escape', () => {
15
		assert.strictEqual(strings.escape(''), '');
16
		assert.strictEqual(strings.escape('foo'), 'foo');
17
		assert.strictEqual(strings.escape('foo bar'), 'foo bar');
18
		assert.strictEqual(strings.escape('<foo bar>'), '&lt;foo bar&gt;');
19
		assert.strictEqual(strings.escape('<foo>Hello</foo>'), '&lt;foo&gt;Hello&lt;/foo&gt;');
20
	});
21

22
	test('ltrim', () => {
23
		assert.strictEqual(strings.ltrim('foo', 'f'), 'oo');
24
		assert.strictEqual(strings.ltrim('foo', 'o'), 'foo');
25
		assert.strictEqual(strings.ltrim('http://www.test.de', 'http://'), 'www.test.de');
26
		assert.strictEqual(strings.ltrim('/foo/', '/'), 'foo/');
27
		assert.strictEqual(strings.ltrim('//foo/', '/'), 'foo/');
28
		assert.strictEqual(strings.ltrim('/', ''), '/');
29
		assert.strictEqual(strings.ltrim('/', '/'), '');
30
		assert.strictEqual(strings.ltrim('///', '/'), '');
31
		assert.strictEqual(strings.ltrim('', ''), '');
32
		assert.strictEqual(strings.ltrim('', '/'), '');
33
	});
34

35
	test('rtrim', () => {
36
		assert.strictEqual(strings.rtrim('foo', 'o'), 'f');
37
		assert.strictEqual(strings.rtrim('foo', 'f'), 'foo');
38
		assert.strictEqual(strings.rtrim('http://www.test.de', '.de'), 'http://www.test');
39
		assert.strictEqual(strings.rtrim('/foo/', '/'), '/foo');
40
		assert.strictEqual(strings.rtrim('/foo//', '/'), '/foo');
41
		assert.strictEqual(strings.rtrim('/', ''), '/');
42
		assert.strictEqual(strings.rtrim('/', '/'), '');
43
		assert.strictEqual(strings.rtrim('///', '/'), '');
44
		assert.strictEqual(strings.rtrim('', ''), '');
45
		assert.strictEqual(strings.rtrim('', '/'), '');
46
	});
47

48
	test('trim', () => {
49
		assert.strictEqual(strings.trim(' foo '), 'foo');
50
		assert.strictEqual(strings.trim('  foo'), 'foo');
51
		assert.strictEqual(strings.trim('bar  '), 'bar');
52
		assert.strictEqual(strings.trim('   '), '');
53
		assert.strictEqual(strings.trim('foo bar', 'bar'), 'foo ');
54
	});
55

56
	test('trimWhitespace', () => {
57
		assert.strictEqual(' foo '.trim(), 'foo');
58
		assert.strictEqual('	 foo	'.trim(), 'foo');
59
		assert.strictEqual('  foo'.trim(), 'foo');
60
		assert.strictEqual('bar  '.trim(), 'bar');
61
		assert.strictEqual('   '.trim(), '');
62
		assert.strictEqual(' 	  '.trim(), '');
63
	});
64

65
	test('lastNonWhitespaceIndex', () => {
66
		assert.strictEqual(strings.lastNonWhitespaceIndex('abc  \t \t '), 2);
67
		assert.strictEqual(strings.lastNonWhitespaceIndex('abc'), 2);
68
		assert.strictEqual(strings.lastNonWhitespaceIndex('abc\t'), 2);
69
		assert.strictEqual(strings.lastNonWhitespaceIndex('abc '), 2);
70
		assert.strictEqual(strings.lastNonWhitespaceIndex('abc  \t \t '), 2);
71
		assert.strictEqual(strings.lastNonWhitespaceIndex('abc  \t \t abc \t \t '), 11);
72
		assert.strictEqual(strings.lastNonWhitespaceIndex('abc  \t \t abc \t \t ', 8), 2);
73
		assert.strictEqual(strings.lastNonWhitespaceIndex('  \t \t '), -1);
74
	});
75

76
	test('containsRTL', () => {
77
		assert.strictEqual(strings.containsRTL('a'), false);
78
		assert.strictEqual(strings.containsRTL(''), false);
79
		assert.strictEqual(strings.containsRTL(strings.UTF8_BOM_CHARACTER + 'a'), false);
80
		assert.strictEqual(strings.containsRTL('hello world!'), false);
81
		assert.strictEqual(strings.containsRTL('a📚📚b'), false);
82
		assert.strictEqual(strings.containsRTL('هناك حقيقة مثبتة منذ زمن طويل'), true);
83
		assert.strictEqual(strings.containsRTL('זוהי עובדה מבוססת שדעתו'), true);
84
	});
85

86
	test('issue #115221: isEmojiImprecise misses ⭐', () => {
87
		const codePoint = strings.getNextCodePoint('⭐', '⭐'.length, 0);
88
		assert.strictEqual(strings.isEmojiImprecise(codePoint), true);
89
	});
90

91
	test('isBasicASCII', () => {
92
		function assertIsBasicASCII(str: string, expected: boolean): void {
93
			assert.strictEqual(strings.isBasicASCII(str), expected, str + ` (${str.charCodeAt(0)})`);
94
		}
95
		assertIsBasicASCII('abcdefghijklmnopqrstuvwxyz', true);
96
		assertIsBasicASCII('ABCDEFGHIJKLMNOPQRSTUVWXYZ', true);
97
		assertIsBasicASCII('1234567890', true);
98
		assertIsBasicASCII('`~!@#$%^&*()-_=+[{]}\\|;:\'",<.>/?', true);
99
		assertIsBasicASCII(' ', true);
100
		assertIsBasicASCII('\t', true);
101
		assertIsBasicASCII('\n', true);
102
		assertIsBasicASCII('\r', true);
103

104
		let ALL = '\r\t\n';
105
		for (let i = 32; i < 127; i++) {
106
			ALL += String.fromCharCode(i);
107
		}
108
		assertIsBasicASCII(ALL, true);
109

110
		assertIsBasicASCII(String.fromCharCode(31), false);
111
		assertIsBasicASCII(String.fromCharCode(127), false);
112
		assertIsBasicASCII('ü', false);
113
		assertIsBasicASCII('a📚📚b', false);
114
	});
115

116
	test('createRegExp', () => {
117
		// Empty
118
		assert.throws(() => strings.createRegExp('', false));
119

120
		// Escapes appropriately
121
		assert.strictEqual(strings.createRegExp('abc', false).source, 'abc');
122
		assert.strictEqual(strings.createRegExp('([^ ,.]*)', false).source, '\\(\\[\\^ ,\\.\\]\\*\\)');
123
		assert.strictEqual(strings.createRegExp('([^ ,.]*)', true).source, '([^ ,.]*)');
124

125
		// Whole word
126
		assert.strictEqual(strings.createRegExp('abc', false, { wholeWord: true }).source, '\\babc\\b');
127
		assert.strictEqual(strings.createRegExp('abc', true, { wholeWord: true }).source, '\\babc\\b');
128
		assert.strictEqual(strings.createRegExp(' abc', true, { wholeWord: true }).source, ' abc\\b');
129
		assert.strictEqual(strings.createRegExp('abc ', true, { wholeWord: true }).source, '\\babc ');
130
		assert.strictEqual(strings.createRegExp(' abc ', true, { wholeWord: true }).source, ' abc ');
131

132
		const regExpWithoutFlags = strings.createRegExp('abc', true);
133
		assert(!regExpWithoutFlags.global);
134
		assert(regExpWithoutFlags.ignoreCase);
135
		assert(!regExpWithoutFlags.multiline);
136

137
		const regExpWithFlags = strings.createRegExp('abc', true, { global: true, matchCase: true, multiline: true });
138
		assert(regExpWithFlags.global);
139
		assert(!regExpWithFlags.ignoreCase);
140
		assert(regExpWithFlags.multiline);
141
	});
142

143
	test('regExpContainsBackreference', () => {
144
		assert(strings.regExpContainsBackreference('foo \\5 bar'));
145
		assert(strings.regExpContainsBackreference('\\2'));
146
		assert(strings.regExpContainsBackreference('(\\d)(\\n)(\\1)'));
147
		assert(strings.regExpContainsBackreference('(A).*?\\1'));
148
		assert(strings.regExpContainsBackreference('\\\\\\1'));
149
		assert(strings.regExpContainsBackreference('foo \\\\\\1'));
150

151
		assert(!strings.regExpContainsBackreference(''));
152
		assert(!strings.regExpContainsBackreference('\\\\1'));
153
		assert(!strings.regExpContainsBackreference('foo \\\\1'));
154
		assert(!strings.regExpContainsBackreference('(A).*?\\\\1'));
155
		assert(!strings.regExpContainsBackreference('foo \\d1 bar'));
156
		assert(!strings.regExpContainsBackreference('123'));
157
	});
158

159
	test('getLeadingWhitespace', () => {
160
		assert.strictEqual(strings.getLeadingWhitespace('  foo'), '  ');
161
		assert.strictEqual(strings.getLeadingWhitespace('  foo', 2), '');
162
		assert.strictEqual(strings.getLeadingWhitespace('  foo', 1, 1), '');
163
		assert.strictEqual(strings.getLeadingWhitespace('  foo', 0, 1), ' ');
164
		assert.strictEqual(strings.getLeadingWhitespace('  '), '  ');
165
		assert.strictEqual(strings.getLeadingWhitespace('  ', 1), ' ');
166
		assert.strictEqual(strings.getLeadingWhitespace('  ', 0, 1), ' ');
167
		assert.strictEqual(strings.getLeadingWhitespace('\t\tfunction foo(){', 0, 1), '\t');
168
		assert.strictEqual(strings.getLeadingWhitespace('\t\tfunction foo(){', 0, 2), '\t\t');
169
	});
170

171
	test('fuzzyContains', () => {
172
		assert.ok(!strings.fuzzyContains((undefined)!, null!));
173
		assert.ok(strings.fuzzyContains('hello world', 'h'));
174
		assert.ok(!strings.fuzzyContains('hello world', 'q'));
175
		assert.ok(strings.fuzzyContains('hello world', 'hw'));
176
		assert.ok(strings.fuzzyContains('hello world', 'horl'));
177
		assert.ok(strings.fuzzyContains('hello world', 'd'));
178
		assert.ok(!strings.fuzzyContains('hello world', 'wh'));
179
		assert.ok(!strings.fuzzyContains('d', 'dd'));
180
	});
181

182
	test('startsWithUTF8BOM', () => {
183
		assert(strings.startsWithUTF8BOM(strings.UTF8_BOM_CHARACTER));
184
		assert(strings.startsWithUTF8BOM(strings.UTF8_BOM_CHARACTER + 'a'));
185
		assert(strings.startsWithUTF8BOM(strings.UTF8_BOM_CHARACTER + 'aaaaaaaaaa'));
186
		assert(!strings.startsWithUTF8BOM(' ' + strings.UTF8_BOM_CHARACTER));
187
		assert(!strings.startsWithUTF8BOM('foo'));
188
		assert(!strings.startsWithUTF8BOM(''));
189
	});
190

191
	test('stripUTF8BOM', () => {
192
		assert.strictEqual(strings.stripUTF8BOM(strings.UTF8_BOM_CHARACTER), '');
193
		assert.strictEqual(strings.stripUTF8BOM(strings.UTF8_BOM_CHARACTER + 'foobar'), 'foobar');
194
		assert.strictEqual(strings.stripUTF8BOM('foobar' + strings.UTF8_BOM_CHARACTER), 'foobar' + strings.UTF8_BOM_CHARACTER);
195
		assert.strictEqual(strings.stripUTF8BOM('abc'), 'abc');
196
		assert.strictEqual(strings.stripUTF8BOM(''), '');
197
	});
198

199
	test('containsUppercaseCharacter', () => {
200
		[
201
			[null, false],
202
			['', false],
203
			['foo', false],
204
			['föö', false],
205
			['ناك', false],
206
			['מבוססת', false],
207
			['😀', false],
208
			['(#@()*&%()@*#&09827340982374}{:">?></\'\\~`', false],
209

210
			['Foo', true],
211
			['FOO', true],
212
			['FöÖ', true],
213
			['FöÖ', true],
214
			['\\Foo', true],
215
		].forEach(([str, result]) => {
216
			assert.strictEqual(strings.containsUppercaseCharacter(<string>str), result, `Wrong result for ${str}`);
217
		});
218
	});
219

220

221

222
	test('containsUppercaseCharacter (ignoreEscapedChars)', () => {
223
		[
224
			['\\Woo', false],
225
			['f\\S\\S', false],
226
			['foo', false],
227

228
			['Foo', true],
229
		].forEach(([str, result]) => {
230
			assert.strictEqual(strings.containsUppercaseCharacter(<string>str, true), result, `Wrong result for ${str}`);
231
		});
232
	});
233

234
});
235

236
Product

Resources

Company
