mirror of
https://gitlab.linphone.org/BC/public/linphone-desktop.git
synced 2026-01-18 11:58:11 +00:00
403 lines
11 KiB
QML
403 lines
11 KiB
QML
import QtQuick 2.7
|
|
import QtTest 1.1
|
|
|
|
// Explicit import, `utils.js` is not accessible in resources file
|
|
// when tests are executed.
|
|
import './utils.js' as Utils
|
|
|
|
// =============================================================================
|
|
|
|
TestCase {
|
|
id: testCase
|
|
|
|
// ===========================================================================
|
|
// QML helpers.
|
|
// ===========================================================================
|
|
|
|
function test_clearTimeout_data () {
|
|
return [
|
|
{ time: 0 },
|
|
{ time: 100 }
|
|
]
|
|
}
|
|
|
|
function test_clearTimeout (data) {
|
|
var failed = false
|
|
var timeout = Utils.setTimeout(testCase, data.time, function () {
|
|
failed = true
|
|
})
|
|
|
|
if (failed) {
|
|
fail('`setTimeout` callback was called before `wait`.')
|
|
}
|
|
|
|
Utils.clearTimeout(timeout)
|
|
wait(100)
|
|
|
|
if (failed) {
|
|
fail('`setTimeout` callback was called after `wait`.')
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_qmlTypeof_data () {
|
|
return [
|
|
{
|
|
component: 'import QtQuick 2.7; ListModel {}',
|
|
result: true,
|
|
type: 'QQmlListModel'
|
|
}, {
|
|
component: 'import QtQuick 2.7; ListView {}',
|
|
result: true,
|
|
type: 'QQuickListView'
|
|
}, {
|
|
component: 'import QtQuick 2.7; MouseArea {}',
|
|
result: true,
|
|
type: 'QQuickMouseArea'
|
|
}, {
|
|
component: 'import QtQuick 2.7; import QtQuick.Window 2.2; Window {}',
|
|
result: true,
|
|
type: 'QQuickWindowQmlImpl'
|
|
}
|
|
]
|
|
}
|
|
|
|
function test_qmlTypeof (data) {
|
|
var object = Qt.createQmlObject(data.component, testCase)
|
|
verify(object)
|
|
|
|
compare(Utils.qmlTypeof(object, data.type), data.result)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_setTimeoutWithoutParent () {
|
|
try {
|
|
Utils.setTimeout(null, 0, function () {
|
|
fail('`setTimeout` was called without parent.')
|
|
})
|
|
} catch (e) {
|
|
compare(e, 'Error: Qt.createQmlObject(): Missing parent object')
|
|
}
|
|
}
|
|
|
|
function test_setTimeout_data () {
|
|
return [
|
|
{ time: 0 },
|
|
{ time: 100 }
|
|
]
|
|
}
|
|
|
|
function test_setTimeout (data) {
|
|
var failed = true
|
|
Utils.setTimeout(testCase, data.time, function () {
|
|
failed = false
|
|
})
|
|
|
|
if (!failed) {
|
|
fail('`setTimeout` callback was called before `wait`.')
|
|
}
|
|
|
|
wait(200)
|
|
|
|
if (failed) {
|
|
fail('`setTimeout` failed because callback it was not called in due course.')
|
|
}
|
|
}
|
|
|
|
// ===========================================================================
|
|
// GENERIC.
|
|
// ===========================================================================
|
|
|
|
function test_ensureArray_data () {
|
|
return [
|
|
{ input: [ 1, 2, 3 ], output: [ 1, 2, 3 ] },
|
|
{ input: { toto: 4, ro: 5 }, output: [ 4, 5 ] },
|
|
{ input: new Object(), output: [] },
|
|
{ input: new Array(), output: [] },
|
|
{ input: { a: 0, b: 1, c: 0 }, output: [ 0, 1, 0 ] }
|
|
]
|
|
}
|
|
|
|
function test_ensureArray (data) {
|
|
// Use `sort` because transform a object in array hasn't a
|
|
// guarantee ordering.
|
|
compare(Utils.ensureArray(data.input).sort(), data.output.sort())
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_execAll_data () {
|
|
return [
|
|
{
|
|
cb: function () {
|
|
return 'failed'
|
|
},
|
|
regex: /x/g,
|
|
text: '',
|
|
|
|
output: []
|
|
}, {
|
|
cb: function (c, valid) {
|
|
return !valid && c
|
|
},
|
|
regex: /x/g,
|
|
text: 'n',
|
|
|
|
output: [ 'n' ]
|
|
}, {
|
|
cb: function (c, valid) {
|
|
return valid && String.fromCharCode(c.charCodeAt(0) + 1)
|
|
},
|
|
regex: /[a-z]/g,
|
|
text: 'abcdefgh',
|
|
|
|
output: [ 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i' ]
|
|
}, {
|
|
cb: function (n, valid) {
|
|
return !valid ? '*' : Math.abs(n)
|
|
},
|
|
regex: /\d+/g,
|
|
text: 'abc 5 def -4 ghi 452-12',
|
|
|
|
output: [ '*', 5, '*', 4, '*', 452, '*', 12 ]
|
|
}, {
|
|
regex: /candy-shop/g,
|
|
text: 'candy-hop candy-shop cndy-shop candyshop',
|
|
|
|
output: [ 'candy-hop ', 'candy-shop', ' cndy-shop candyshop' ]
|
|
}, {
|
|
cb: function (text, valid) {
|
|
return valid ? text + ' Batman!' : text
|
|
},
|
|
regex: /(?:na)+\.\.\./g,
|
|
text: 'Nananana. Nanananananananana... Nanananananananana... Nananananananananananana...',
|
|
|
|
output: [
|
|
'Nananana. Na',
|
|
'nananananananana... Batman!',
|
|
' Na',
|
|
'nananananananana... Batman!',
|
|
' Na',
|
|
'nanananananananananana... Batman!'
|
|
]
|
|
}
|
|
]
|
|
}
|
|
|
|
function test_execAll (data) {
|
|
compare(Utils.execAll(data.regex, data.text, data.cb), data.output)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_genRandomNumber_data () {
|
|
return [
|
|
{ min: 42, max: 3600 },
|
|
{ min: 10, max: 100 },
|
|
{ min: 58, max: 61 },
|
|
{ min: 2, max: 3 }
|
|
]
|
|
}
|
|
|
|
function test_genRandomNumber (data) {
|
|
Utils.times(10, function () {
|
|
var n = Utils.genRandomNumber(data.min, data.max)
|
|
compare(n >= data.min && n < data.max, true)
|
|
})
|
|
}
|
|
|
|
function test_genRandomNumberId () {
|
|
compare(Utils.genRandomNumber(42, 42), 42)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_genRandomNumberBetweenIntervals_data () {
|
|
return [
|
|
{ intervals: [ [ 1, 5 ] ] },
|
|
{ intervals: [ [ 8, 9 ], [ 10, 15 ] ] },
|
|
{ intervals: [ [ 1, 4 ], [ 8, 16 ], [ 22, 25 ] ] },
|
|
{ intervals: [ [ 11, 12 ], [ 50, 80 ], [ 92, 93 ], [ 1000, 1100 ] ] },
|
|
{ intervals: [ [ -5, -2 ] ] },
|
|
{ intervals: [ [ -5, -2 ], [ 12, 14 ] ] },
|
|
{ intervals: [ [ -127, -111 ], [ -35, -14 ], [ 1256, 1270 ], [ 10000, 10020 ] ] }
|
|
]
|
|
}
|
|
|
|
function test_genRandomNumberBetweenIntervals (data) {
|
|
var intervals = data.intervals
|
|
|
|
Utils.times(10, function () {
|
|
var n = Utils.genRandomNumberBetweenIntervals(intervals)
|
|
|
|
var soFarSoGood = false
|
|
for (var i = 0; i < intervals.length; i++) {
|
|
if (n >= intervals[i][0] && n < intervals[i][1]) {
|
|
soFarSoGood = true
|
|
break
|
|
}
|
|
}
|
|
|
|
compare(
|
|
soFarSoGood,
|
|
true,
|
|
'The generated number cannot be found in a interval.'
|
|
)
|
|
})
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_getExtension_data () {
|
|
return [
|
|
{ input: 'foobar.baz', output: 'baz' },
|
|
{ input: 'classe.george.abitbol', output: 'abitbol' },
|
|
{ input: '', output: '' },
|
|
{ input: 'cotcotcot', output: '' }
|
|
]
|
|
}
|
|
|
|
function test_getExtension (data) {
|
|
compare(Utils.getExtension(data.input), data.output)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_includes_data () {
|
|
return [
|
|
// Test arrays.
|
|
{ input: [], value: 0, output: false },
|
|
{ input: [ 1, 2, 3 ], value: 4, output: false },
|
|
{ input: [ 6 ], value: 6, output: true },
|
|
{ input: [ 4, 8, 'foo' ], value: 8, output: true },
|
|
{ input: [ 12, NaN, 47 ], value: NaN, output: true },
|
|
{ input: Array(1), value: undefined, output: true },
|
|
{ input: [ 'a', 'b', 'c' ], startIndex: 1, value: 'a', output: false },
|
|
{ input: [ 6, 5, 4, 9 ], startIndex: 3, value: 9, output: true },
|
|
|
|
// Test objects.
|
|
{ input: {}, value: 0, output: false },
|
|
{ input: { a: 1, b: 2, c: 3 }, value: 4, output: false },
|
|
{ input: { a: 6 }, value: 6, output: true },
|
|
{ input: { a: 4, b: 8, c: 'foo' }, value: 8, output: true },
|
|
{ input: { a: 12, b: NaN, c: 47 }, value: NaN, output: true },
|
|
{ input: new Object(), value: undefined, output: false },
|
|
{ input: { a: 'a', b: 'b', c: 'c' }, startIndex: 1, value: 'a', output: false },
|
|
{ input: { a: 6, b: 5, c: 4, d: 9 }, startIndex: 3, value: 9, output: true },
|
|
]
|
|
}
|
|
|
|
function test_includes (data) {
|
|
compare(
|
|
Utils.includes(data.input, data.value, data.startIndex),
|
|
data.output
|
|
)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_isArray_data () {
|
|
return [
|
|
{ input: [], output: true },
|
|
{ input: {}, output: false },
|
|
{ input: [ 6 ], output: true },
|
|
{ input: /bar/, output: false },
|
|
{ input: new Error, output: false },
|
|
{ input: true, output: false },
|
|
{ input: 42, output: false },
|
|
{ input: new Array(), output: true },
|
|
{ input: [ 15, new Date(), 'ij' ], output: true }
|
|
]
|
|
}
|
|
|
|
function test_isArray (data) {
|
|
compare(Utils.isArray(data.input), data.output)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_isString_data () {
|
|
return [
|
|
{ input: 'foo', output: true },
|
|
{ input: Object('bar'), output: true },
|
|
{ input: [ 0 ], output: false },
|
|
{ input: /baz/, output: false },
|
|
{ input: new Error, output: false },
|
|
{ input: true, output: false },
|
|
{ input: 42, output: false }
|
|
]
|
|
}
|
|
|
|
function test_isString (data) {
|
|
compare(Utils.isString(data.input), data.output)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_snakeToCamel_data () {
|
|
return [
|
|
{ input: 'foo_bar', output: 'fooBar' },
|
|
{ input: 'george_abitbol', output: 'georgeAbitbol' },
|
|
{ input: 'billTremendousAndHubert', output: 'billTremendousAndHubert' },
|
|
{ input: 'foo_bAr_BAZ', output: 'fooBArBAZ' }
|
|
]
|
|
}
|
|
|
|
function test_snakeToCamel (data) {
|
|
compare(Utils.snakeToCamel(data.input), data.output)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_startsWith_data () {
|
|
return [
|
|
{ string: 'foo', searchStr: undefined, result: true },
|
|
{ string: 'bar', searchStr: null, result: true },
|
|
{ string: 'abitbol', searchStr: 'abitboll', result: false },
|
|
{ string: '', searchStr: NaN, result: false },
|
|
{ string: '', searchStr: '', result: true },
|
|
{ string: '', searchStr: Infinity, result: false },
|
|
{ string: '', searchStr: 0, result: false },
|
|
{ string: 'george', searchStr: 'geo', result: true },
|
|
{ string: 'george', searchStr: 'george', result: true },
|
|
{ string: 'george', searchStr: 'georg', result: true },
|
|
{ string: 'ruby', searchStr: '', result: true }
|
|
]
|
|
}
|
|
|
|
function test_startsWith (data) {
|
|
compare(
|
|
Utils.startsWith(data.string, data.searchStr),
|
|
data.result
|
|
)
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
function test_times1_data () {
|
|
return [
|
|
{
|
|
cb: function (n) { return n * 2 },
|
|
n: 10,
|
|
output: [ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18 ]
|
|
},
|
|
{
|
|
cb: function (n) { return n % 2 },
|
|
n: 6,
|
|
output: [ 0, 1, 0, 1, 0, 1 ]
|
|
}
|
|
]
|
|
}
|
|
|
|
function test_times1 (data) {
|
|
compare(Utils.times(data.n, data.cb), data.output)
|
|
}
|
|
|
|
function test_times2 () {
|
|
var sum = 0
|
|
Utils.times(5, function (i) { sum += (i + 1) })
|
|
compare(sum, 15)
|
|
}
|
|
}
|