groovy/katalon: 验证列表序列
groovy/katalon: Validate sequence of list
我有两个列表:
def listA = ['2', '3', '4.5', '5', '6.5', '7', '7.5', '8']
def listB = ['10', '11', '13', '1', '2', '2.5']
我想验证两个列表的顺序。对于 listA,每个当前元素都小于下一个元素,因此我有以下循环。
double previous = 0.0
for (int i = 0; i < listA.size(); i++) {
double current = Double.parseDouble(listA.get(i))
if (previous >= current) {
KeywordUtil.markFailed("previous=${previous}, current=${current} not in order")
}
previous = current
}
以上代码适用于 listA。
但我对如何验证第二个列表感到困惑。要求是从 10 - 13.5 元素应该按顺序排列,但是在 13.5 之后,'1' 应该在那里。
listB 是动态的。有时是 ['11.5', '2', '3']
,有时是 ['12', '2']
或任何其他组合。无论列表是什么,它都应该遵循 10-13.5 and then 1-3
的顺序
更新
我会尝试更好地解释这个要求。所以基本上我是在测试图中所示产品的尺寸顺序。
所以我在测试不同的网站,测试不同的产品。每个产品都有不同的尺寸可用性。大多数产品的尺寸都是按数字顺序排列的,比如当前尺寸会比下一个尺寸小。对于他们来说,上面的 for 循环就可以了。
但对于 'Little Kids' 等某些类别,要求尺寸应按 --> 10, 10.5, 11, 11.5, 12, 12.5, 13, 13.5, 1, 1.5, 2, 2.5, 3
的顺序排列。现在这些产品中的一些可能缺少某些尺寸,但无论有什么尺寸,它们都应该遵循上述顺序。例如,如果有 12 号和 2 号可用,那么它应该按那个顺序,而不是 2 和 12。同样,如果有 13、1 和 3 号可用,它应该按那个顺序,而不是 1、3、13
不确定我是否正确理解了您的要求(尤其是关于 listB
),但我会像这样使用排序来执行这两项检查:
- 这里我使用
toSorted()
,它基于 Comparator
创建一个新列表,表示为闭包 {}
。比较器比较转换为双精度的值。排序后的列表与原始列表进行比较,如果发生重新排序 -> 列表不符合规则:
boolean checkA( list ){
list == list.toSorted{ it.toDouble() }
}
assert checkA( [ '2', '3', '4.5', '5', '6.5', '7', '7.5', '8' ] )
assert !checkA( [ '2', 1, '3', '4.5', '5', '6.5', '7', '7.5', '8' ] )
- 这里我使用相同的方法,但是比较器根据
WEIGHTS
列表中每个元素的索引工作,因此按 WEIGHTS
. 对原始列表进行排序
def WEIGHTS = [ 10, 10.5, 11, 11.5, 12, 12.5, 13, 13.5, 1, 1.5, 2, 2.5, 3 ]*.toDouble().asImmutable()
def checkB = { list ->
list == list.toSorted{ WEIGHTS.indexOf it.toDouble() }
}
assert checkB( ['10', '11', '13', '1', '2', '2.5'] )
assert checkB( ['11.5', '2', '3'] )
assert checkB( ['12', '2'] )
assert !checkB( ['11', '10', '1', '13', '2', '2.5'] )
assert !checkB( ['1', '12', '3'] )
我有两个列表:
def listA = ['2', '3', '4.5', '5', '6.5', '7', '7.5', '8']
def listB = ['10', '11', '13', '1', '2', '2.5']
我想验证两个列表的顺序。对于 listA,每个当前元素都小于下一个元素,因此我有以下循环。
double previous = 0.0
for (int i = 0; i < listA.size(); i++) {
double current = Double.parseDouble(listA.get(i))
if (previous >= current) {
KeywordUtil.markFailed("previous=${previous}, current=${current} not in order")
}
previous = current
}
以上代码适用于 listA。
但我对如何验证第二个列表感到困惑。要求是从 10 - 13.5 元素应该按顺序排列,但是在 13.5 之后,'1' 应该在那里。
listB 是动态的。有时是 ['11.5', '2', '3']
,有时是 ['12', '2']
或任何其他组合。无论列表是什么,它都应该遵循 10-13.5 and then 1-3
更新 我会尝试更好地解释这个要求。所以基本上我是在测试图中所示产品的尺寸顺序。
所以我在测试不同的网站,测试不同的产品。每个产品都有不同的尺寸可用性。大多数产品的尺寸都是按数字顺序排列的,比如当前尺寸会比下一个尺寸小。对于他们来说,上面的 for 循环就可以了。
但对于 'Little Kids' 等某些类别,要求尺寸应按 --> 10, 10.5, 11, 11.5, 12, 12.5, 13, 13.5, 1, 1.5, 2, 2.5, 3
的顺序排列。现在这些产品中的一些可能缺少某些尺寸,但无论有什么尺寸,它们都应该遵循上述顺序。例如,如果有 12 号和 2 号可用,那么它应该按那个顺序,而不是 2 和 12。同样,如果有 13、1 和 3 号可用,它应该按那个顺序,而不是 1、3、13
不确定我是否正确理解了您的要求(尤其是关于 listB
),但我会像这样使用排序来执行这两项检查:
- 这里我使用
toSorted()
,它基于Comparator
创建一个新列表,表示为闭包{}
。比较器比较转换为双精度的值。排序后的列表与原始列表进行比较,如果发生重新排序 -> 列表不符合规则:
boolean checkA( list ){
list == list.toSorted{ it.toDouble() }
}
assert checkA( [ '2', '3', '4.5', '5', '6.5', '7', '7.5', '8' ] )
assert !checkA( [ '2', 1, '3', '4.5', '5', '6.5', '7', '7.5', '8' ] )
- 这里我使用相同的方法,但是比较器根据
WEIGHTS
列表中每个元素的索引工作,因此按WEIGHTS
. 对原始列表进行排序
def WEIGHTS = [ 10, 10.5, 11, 11.5, 12, 12.5, 13, 13.5, 1, 1.5, 2, 2.5, 3 ]*.toDouble().asImmutable()
def checkB = { list ->
list == list.toSorted{ WEIGHTS.indexOf it.toDouble() }
}
assert checkB( ['10', '11', '13', '1', '2', '2.5'] )
assert checkB( ['11.5', '2', '3'] )
assert checkB( ['12', '2'] )
assert !checkB( ['11', '10', '1', '13', '2', '2.5'] )
assert !checkB( ['1', '12', '3'] )