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

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

2
suite('Strings', () => {
3

4
	test('format', () => {…});
5

6
	test('format2', () => {…});
7

8
	test('lcut', () => {
9
		assert.strictEqual(strings.lcut('test string 0.1.2.3', 3), '2.3');
10

11
		assert.strictEqual(strings.lcut('', 10), '');
12
		assert.strictEqual(strings.lcut('a', 10), 'a');
13
	});
14

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

221

222

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

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

235
});
236

237
Product

Resources

Company
