A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://github.com/bootstrap-vue/bootstrap-vue/commit/29fbcb58c5efed0dbbafa8b0bb5fc1d1651079cd below:

sort handling for numeric string values (closes #6092) … · bootstrap-vue/bootstrap-vue@29fbcb5 · GitHub

@@ -2,47 +2,53 @@ import defaultSortCompare from './default-sort-compare'

2 2 3 3

describe('table/helpers/default-sort-compare', () => {

4 4

it('sorts numbers correctly', async () => {

5 -

expect(defaultSortCompare({ a: 1 }, { a: 2 }, 'a')).toBe(-1)

6 -

expect(defaultSortCompare({ a: 2 }, { a: 1 }, 'a')).toBe(1)

7 -

expect(defaultSortCompare({ a: 1 }, { a: 1 }, 'a')).toBe(0)

8 -

expect(defaultSortCompare({ a: -1 }, { a: 1 }, 'a')).toBe(-1)

9 -

expect(defaultSortCompare({ a: 1 }, { a: -1 }, 'a')).toBe(1)

10 -

expect(defaultSortCompare({ a: 0 }, { a: 0 }, 'a')).toBe(0)

11 -

expect(defaultSortCompare({ a: 1.234 }, { a: 1.567 }, 'a')).toBe(-1)

12 -

expect(defaultSortCompare({ a: 1.561 }, { a: 1.234 }, 'a')).toBe(1)

5 +

const options = { sortBy: 'a' }

6 +

expect(defaultSortCompare({ a: 1 }, { a: 2 }, options)).toBe(-1)

7 +

expect(defaultSortCompare({ a: 2 }, { a: 1 }, options)).toBe(1)

8 +

expect(defaultSortCompare({ a: 1 }, { a: 1 }, options)).toBe(0)

9 +

expect(defaultSortCompare({ a: -1 }, { a: 1 }, options)).toBe(-1)

10 +

expect(defaultSortCompare({ a: 1 }, { a: -1 }, options)).toBe(1)

11 +

expect(defaultSortCompare({ a: 0 }, { a: 0 }, options)).toBe(0)

12 +

expect(defaultSortCompare({ a: 1.234 }, { a: 1.567 }, options)).toBe(-1)

13 +

expect(defaultSortCompare({ a: 1.561 }, { a: 1.234 }, options)).toBe(1)

13 14

})

14 15 15 16

it('sorts dates correctly', async () => {

16 17

const date1 = { a: new Date(2020, 1, 1) }

17 18

const date2 = { a: new Date(1999, 11, 31) }

18 19

const date3 = { a: new Date(1999, 1, 1) }

19 20

const date4 = { a: new Date(1999, 1, 1, 12, 12, 12, 12) }

21 +

const options = { sortBy: 'a' }

20 22 21 -

expect(defaultSortCompare(date1, date2, 'a')).toBe(1)

22 -

expect(defaultSortCompare(date1, date1, 'a')).toBe(0)

23 -

expect(defaultSortCompare(date2, date1, 'a')).toBe(-1)

24 -

expect(defaultSortCompare(date2, date3, 'a')).toBe(1)

25 -

expect(defaultSortCompare(date3, date2, 'a')).toBe(-1)

26 -

expect(defaultSortCompare(date3, date4, 'a')).toBe(-1)

27 -

expect(defaultSortCompare(date4, date3, 'a')).toBe(1)

28 -

expect(defaultSortCompare(date4, date4, 'a')).toBe(0)

23 +

expect(defaultSortCompare(date1, date2, options)).toBe(1)

24 +

expect(defaultSortCompare(date1, date1, options)).toBe(0)

25 +

expect(defaultSortCompare(date2, date1, options)).toBe(-1)

26 +

expect(defaultSortCompare(date2, date3, options)).toBe(1)

27 +

expect(defaultSortCompare(date3, date2, options)).toBe(-1)

28 +

expect(defaultSortCompare(date3, date4, options)).toBe(-1)

29 +

expect(defaultSortCompare(date4, date3, options)).toBe(1)

30 +

expect(defaultSortCompare(date4, date4, options)).toBe(0)

29 31

})

30 32 31 33

it('sorts strings correctly', async () => {

34 +

const options = { sortBy: 'a' }

35 + 32 36

// Note: string comparisons are locale based

33 -

expect(defaultSortCompare({ a: 'a' }, { a: 'b' }, 'a')).toBe(-1)

34 -

expect(defaultSortCompare({ a: 'b' }, { a: 'a' }, 'a')).toBe(1)

35 -

expect(defaultSortCompare({ a: 'a' }, { a: 'a' }, 'a')).toBe(0)

36 -

expect(defaultSortCompare({ a: 'a' }, { a: 'aaa' }, 'a')).toBe(-1)

37 -

expect(defaultSortCompare({ a: 'aaa' }, { a: 'a' }, 'a')).toBe(1)

37 +

expect(defaultSortCompare({ a: 'a' }, { a: 'b' }, options)).toBe(-1)

38 +

expect(defaultSortCompare({ a: 'b' }, { a: 'a' }, options)).toBe(1)

39 +

expect(defaultSortCompare({ a: 'a' }, { a: 'a' }, options)).toBe(0)

40 +

expect(defaultSortCompare({ a: 'a' }, { a: 'aaa' }, options)).toBe(-1)

41 +

expect(defaultSortCompare({ a: 'aaa' }, { a: 'a' }, options)).toBe(1)

38 42

})

39 43 40 44

it('sorts by nested key correctly', async () => {

45 +

const options = { sortBy: 'a.b' }

46 + 41 47

// Note: string comparisons are locale based

42 -

expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'b' } }, 'a.b')).toBe(-1)

43 -

expect(defaultSortCompare({ a: { b: 'b' } }, { a: { b: 'a' } }, 'a.b')).toBe(1)

44 -

expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'a' } }, 'a.b')).toBe(0)

45 -

expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'aaa' } }, 'a.b')).toBe(-1)

48 +

expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'b' } }, options)).toBe(-1)

49 +

expect(defaultSortCompare({ a: { b: 'b' } }, { a: { b: 'a' } }, options)).toBe(1)

50 +

expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'a' } }, options)).toBe(0)

51 +

expect(defaultSortCompare({ a: { b: 'a' } }, { a: { b: 'aaa' } }, options)).toBe(-1)

46 52

})

47 53 48 54

it('sorts using provided formatter correctly', async () => {

@@ -53,34 +59,37 @@ describe('table/helpers/default-sort-compare', () => {

53 59

.reverse()

54 60

.join('')

55 61

}

56 -

expect(defaultSortCompare({ a: 'ab' }, { a: 'b' }, 'a')).toBe(-1)

57 -

expect(defaultSortCompare({ a: 'ab' }, { a: 'b' }, 'a', false, formatter)).toBe(1)

62 + 63 +

expect(defaultSortCompare({ a: 'ab' }, { a: 'b' }, { sortBy: 'a' })).toBe(-1)

64 +

expect(defaultSortCompare({ a: 'ab' }, { a: 'b' }, { sortBy: 'a', formatter })).toBe(1)

58 65

})

59 66 60 67

it('sorts nulls always last when sor-null-lasst is set', async () => {

61 68

const x = { a: 'ab' }

62 69

const y = { a: null }

63 70

const z = {}

64 71

const w = { a: '' }

65 -

const u = undefined

72 +

const options = { sortBy: 'a', localeOptions: { numeric: true } }

73 +

const optionsNullLast = { ...options, nullLast: true }

66 74 67 75

// Without nullLast set (false)

68 -

expect(defaultSortCompare(x, y, 'a', u, u, { numeric: true }, u, false)).toBe(1)

69 -

expect(defaultSortCompare(y, x, 'a', u, u, { numeric: true }, u, false)).toBe(-1)

70 -

expect(defaultSortCompare(x, z, 'a', u, u, { numeric: true }, u, false)).toBe(1)

71 -

expect(defaultSortCompare(z, x, 'a', u, u, { numeric: true }, u, false)).toBe(-1)

72 -

expect(defaultSortCompare(y, z, 'a', u, u, { numeric: true }, u, false)).toBe(0)

73 -

expect(defaultSortCompare(z, y, 'a', u, u, { numeric: true }, u, false)).toBe(0)

74 -

expect(defaultSortCompare(x, w, 'a', u, u, { numeric: true }, u, false)).toBe(1)

75 -

expect(defaultSortCompare(w, x, 'a', u, u, { numeric: true }, u, false)).toBe(-1)

76 +

expect(defaultSortCompare(x, y, options)).toBe(1)

77 +

expect(defaultSortCompare(y, x, options)).toBe(-1)

78 +

expect(defaultSortCompare(x, z, options)).toBe(1)

79 +

expect(defaultSortCompare(z, x, options)).toBe(-1)

80 +

expect(defaultSortCompare(y, z, options)).toBe(0)

81 +

expect(defaultSortCompare(z, y, options)).toBe(0)

82 +

expect(defaultSortCompare(x, w, options)).toBe(1)

83 +

expect(defaultSortCompare(w, x, options)).toBe(-1)

84 + 76 85

// With nullLast set

77 -

expect(defaultSortCompare(x, y, 'a', u, u, { numeric: true }, u, true)).toBe(-1)

78 -

expect(defaultSortCompare(y, x, 'a', u, u, { numeric: true }, u, true)).toBe(1)

79 -

expect(defaultSortCompare(x, z, 'a', u, u, { numeric: true }, u, true)).toBe(-1)

80 -

expect(defaultSortCompare(z, x, 'a', u, u, { numeric: true }, u, true)).toBe(1)

81 -

expect(defaultSortCompare(y, z, 'a', u, u, { numeric: true }, u, true)).toBe(0)

82 -

expect(defaultSortCompare(z, y, 'a', u, u, { numeric: true }, u, true)).toBe(0)

83 -

expect(defaultSortCompare(x, w, 'a', u, u, { numeric: true }, u, true)).toBe(-1)

84 -

expect(defaultSortCompare(w, x, 'a', u, u, { numeric: true }, u, true)).toBe(1)

86 +

expect(defaultSortCompare(x, y, optionsNullLast)).toBe(-1)

87 +

expect(defaultSortCompare(y, x, optionsNullLast)).toBe(1)

88 +

expect(defaultSortCompare(x, z, optionsNullLast)).toBe(-1)

89 +

expect(defaultSortCompare(z, x, optionsNullLast)).toBe(1)

90 +

expect(defaultSortCompare(y, z, optionsNullLast)).toBe(0)

91 +

expect(defaultSortCompare(z, y, optionsNullLast)).toBe(0)

92 +

expect(defaultSortCompare(x, w, optionsNullLast)).toBe(-1)

93 +

expect(defaultSortCompare(w, x, optionsNullLast)).toBe(1)

85 94

})

86 95

})


RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4