Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
microsoft
GitHub Repository: microsoft/vscode
 Path: blob/main/src/vs/base/test/common/history.test.ts
3296 views
1
/*---------------------------------------------------------------------------------------------

2
 *  Copyright (c) Microsoft Corporation. All rights reserved.

3
 *  Licensed under the MIT License. See License.txt in the project root for license information.

4
 *--------------------------------------------------------------------------------------------*/

5
import assert from 'assert';

6
import { HistoryNavigator, HistoryNavigator2 } from '../../common/history.js';

7
import { ensureNoDisposablesAreLeakedInTestSuite } from './utils.js';

8


9
suite('History Navigator', () => {

10


11
	ensureNoDisposablesAreLeakedInTestSuite();

12


13
	test('create reduces the input to limit', () => {

14
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 2);

15


16
		assert.deepStrictEqual(['3', '4'], toArray(testObject));

17
	});

18


19
	test('create sets the position after last', () => {

20
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 100);

21


22
		assert.strictEqual(testObject.current(), null);

23
		assert.strictEqual(testObject.isNowhere(), true);

24
		assert.strictEqual(testObject.isFirst(), false);

25
		assert.strictEqual(testObject.isLast(), false);

26
		assert.strictEqual(testObject.next(), null);

27
		assert.strictEqual(testObject.previous(), '4');

28
		assert.strictEqual(testObject.isNowhere(), false);

29
		assert.strictEqual(testObject.isFirst(), false);

30
		assert.strictEqual(testObject.isLast(), true);

31
	});

32


33
	test('last returns last element', () => {

34
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 100);

35


36
		assert.strictEqual(testObject.first(), '1');

37
		assert.strictEqual(testObject.last(), '4');

38
		assert.strictEqual(testObject.isFirst(), false);

39
		assert.strictEqual(testObject.isLast(), true);

40
	});

41


42
	test('first returns first element', () => {

43
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 3);

44


45
		assert.strictEqual('2', testObject.first());

46
		assert.strictEqual(testObject.isFirst(), true);

47
		assert.strictEqual(testObject.isLast(), false);

48
	});

49


50
	test('next returns next element', () => {

51
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 3);

52


53
		testObject.first();

54


55
		assert.strictEqual(testObject.next(), '3');

56
		assert.strictEqual(testObject.next(), '4');

57
		assert.strictEqual(testObject.next(), null);

58
	});

59


60
	test('previous returns previous element', () => {

61
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 3);

62


63
		assert.strictEqual(testObject.previous(), '4');

64
		assert.strictEqual(testObject.previous(), '3');

65
		assert.strictEqual(testObject.previous(), '2');

66
		assert.strictEqual(testObject.previous(), null);

67
	});

68


69
	test('next on last element returns null and remains on last', () => {

70
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 3);

71


72
		testObject.first();

73
		testObject.last();

74


75
		assert.strictEqual(testObject.isLast(), true);

76
		assert.strictEqual(testObject.current(), '4');

77
		assert.strictEqual(testObject.next(), null);

78
		assert.strictEqual(testObject.isLast(), false); // Stepping past the last element, is no longer "last"

79
	});

80


81
	test('previous on first element returns null and remains on first', () => {

82
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 3);

83


84
		testObject.first();

85


86
		assert.strictEqual(testObject.isFirst(), true);

87
		assert.strictEqual(testObject.current(), '2');

88
		assert.strictEqual(testObject.previous(), null);

89
		assert.strictEqual(testObject.isFirst(), true);

90
	});

91


92
	test('add reduces the input to limit', () => {

93
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 2);

94


95
		testObject.add('5');

96


97
		assert.deepStrictEqual(toArray(testObject), ['4', '5']);

98
	});

99


100
	test('adding existing element changes the position', () => {

101
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 5);

102


103
		testObject.add('2');

104


105
		assert.deepStrictEqual(toArray(testObject), ['1', '3', '4', '2']);

106
	});

107


108
	test('add resets the navigator to last', () => {

109
		const testObject = new HistoryNavigator(new Set(['1', '2', '3', '4']), 3);

110


111
		testObject.first();

112
		testObject.add('5');

113


114
		assert.strictEqual(testObject.previous(), '5');

115
		assert.strictEqual(testObject.isLast(), true);

116
		assert.strictEqual(testObject.next(), null);

117
		assert.strictEqual(testObject.isLast(), false);

118
	});

119


120
	test('adding an existing item changes the order', () => {

121
		const testObject = new HistoryNavigator(new Set(['1', '2', '3']));

122


123
		testObject.add('1');

124


125
		assert.deepStrictEqual(['2', '3', '1'], toArray(testObject));

126
	});

127


128
	test('previous returns null if the current position is the first one', () => {

129
		const testObject = new HistoryNavigator(new Set(['1', '2', '3']));

130


131
		testObject.first();

132


133
		assert.deepStrictEqual(testObject.previous(), null);

134
		assert.strictEqual(testObject.isFirst(), true);

135
	});

136


137
	test('previous returns object if the current position is not the first one', () => {

138
		const testObject = new HistoryNavigator(new Set(['1', '2', '3']));

139


140
		testObject.first();

141
		testObject.next();

142


143
		assert.deepStrictEqual(testObject.previous(), '1');

144
	});

145


146
	test('next returns null if the current position is the last one', () => {

147
		const testObject = new HistoryNavigator(new Set(['1', '2', '3']));

148


149
		testObject.last();

150


151
		assert.strictEqual(testObject.isLast(), true);

152
		assert.deepStrictEqual(testObject.next(), null);

153
		assert.strictEqual(testObject.isLast(), false);

154
	});

155


156
	test('next returns object if the current position is not the last one', () => {

157
		const testObject = new HistoryNavigator(new Set(['1', '2', '3']));

158


159
		testObject.last();

160
		testObject.previous();

161


162
		assert.deepStrictEqual(testObject.next(), '3');

163
	});

164


165
	test('clear', () => {

166
		const testObject = new HistoryNavigator(new Set(['a', 'b', 'c']));

167
		assert.strictEqual(testObject.previous(), 'c');

168
		testObject.clear();

169
		assert.strictEqual(testObject.current(), null);

170
		assert.strictEqual(testObject.isNowhere(), true);

171
	});

172


173
	function toArray(historyNavigator: HistoryNavigator<string>): Array<string | null> {

174
		const result: Array<string | null> = [];

175
		historyNavigator.first();

176
		if (historyNavigator.current()) {

177
			do {

178
				result.push(historyNavigator.current()!);

179
			} while (historyNavigator.next());

180
		}

181
		return result;

182
	}

183
});

184


185
suite('History Navigator 2', () => {

186


187
	ensureNoDisposablesAreLeakedInTestSuite();

188


189
	test('constructor', () => {

190
		const testObject = new HistoryNavigator2(['1', '2', '3', '4']);

191


192
		assert.strictEqual(testObject.current(), '4');

193
		assert.strictEqual(testObject.isAtEnd(), true);

194
	});

195


196
	test('constructor - initial history is not empty', () => {

197
		assert.throws(() => new HistoryNavigator2([]));

198
	});

199


200
	test('constructor - capacity limit', () => {

201
		const testObject = new HistoryNavigator2(['1', '2', '3', '4'], 3);

202


203
		assert.strictEqual(testObject.current(), '4');

204
		assert.strictEqual(testObject.isAtEnd(), true);

205
		assert.strictEqual(testObject.has('1'), false);

206
	});

207


208
	test('constructor - duplicate values', () => {

209
		const testObject = new HistoryNavigator2(['1', '2', '3', '4', '3', '2', '1']);

210


211
		assert.strictEqual(testObject.current(), '1');

212
		assert.strictEqual(testObject.isAtEnd(), true);

213
	});

214


215
	test('navigation', () => {

216
		const testObject = new HistoryNavigator2(['1', '2', '3', '4']);

217


218
		assert.strictEqual(testObject.current(), '4');

219
		assert.strictEqual(testObject.isAtEnd(), true);

220


221
		assert.strictEqual(testObject.next(), '4');

222
		assert.strictEqual(testObject.previous(), '3');

223
		assert.strictEqual(testObject.previous(), '2');

224
		assert.strictEqual(testObject.previous(), '1');

225
		assert.strictEqual(testObject.previous(), '1');

226


227
		assert.strictEqual(testObject.current(), '1');

228
		assert.strictEqual(testObject.next(), '2');

229
		assert.strictEqual(testObject.resetCursor(), '4');

230
	});

231


232
	test('add', () => {

233
		const testObject = new HistoryNavigator2(['1', '2', '3', '4']);

234
		testObject.add('5');

235


236
		assert.strictEqual(testObject.current(), '5');

237
		assert.strictEqual(testObject.isAtEnd(), true);

238
	});

239


240
	test('add - existing value', () => {

241
		const testObject = new HistoryNavigator2(['1', '2', '3', '4']);

242
		testObject.add('2');

243


244
		assert.strictEqual(testObject.current(), '2');

245
		assert.strictEqual(testObject.isAtEnd(), true);

246


247
		assert.strictEqual(testObject.previous(), '4');

248
		assert.strictEqual(testObject.previous(), '3');

249
		assert.strictEqual(testObject.previous(), '1');

250
	});

251


252
	test('replaceLast', () => {

253
		const testObject = new HistoryNavigator2(['1', '2', '3', '4']);

254
		testObject.replaceLast('5');

255


256
		assert.strictEqual(testObject.current(), '5');

257
		assert.strictEqual(testObject.isAtEnd(), true);

258
		assert.strictEqual(testObject.has('4'), false);

259


260
		assert.strictEqual(testObject.previous(), '3');

261
		assert.strictEqual(testObject.previous(), '2');

262
		assert.strictEqual(testObject.previous(), '1');

263
	});

264


265
	test('replaceLast - existing value', () => {

266
		const testObject = new HistoryNavigator2(['1', '2', '3', '4']);

267
		testObject.replaceLast('2');

268


269
		assert.strictEqual(testObject.current(), '2');

270
		assert.strictEqual(testObject.isAtEnd(), true);

271
		assert.strictEqual(testObject.has('4'), false);

272


273
		assert.strictEqual(testObject.previous(), '3');

274
		assert.strictEqual(testObject.previous(), '1');

275
	});

276


277
	test('prepend', () => {

278
		const testObject = new HistoryNavigator2(['1', '2', '3', '4']);

279
		assert.strictEqual(testObject.current(), '4');

280
		assert.ok(testObject.isAtEnd());

281
		assert.deepStrictEqual(Array.from(testObject), ['1', '2', '3', '4']);

282


283
		testObject.prepend('0');

284
		assert.strictEqual(testObject.current(), '4');

285
		assert.ok(testObject.isAtEnd());

286
		assert.deepStrictEqual(Array.from(testObject), ['0', '1', '2', '3', '4']);

287


288
		testObject.prepend('2');

289
		assert.strictEqual(testObject.current(), '4');

290
		assert.ok(testObject.isAtEnd());

291
		assert.deepStrictEqual(Array.from(testObject), ['0', '1', '2', '3', '4']);

292
	});

293


294
});

295


296