def test_custom_bad_hours(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2016, month=5, day=26, hour=19, minute=00)
# default error handling is to exclude the resource
with mock_datetime_now(t, datetime):
# This isn't considered a bad value, its basically omitted.
i = instance(Tags=[{'Key': 'maid_offhours',
'Value': 'off=();tz=et'}])
self.assertEqual(OffHour({})(i), True)
i = instance(Tags=[{'Key': 'maid_offhours',
'Value': 'off=(m-f,90);on=(m-f,7);tz=et'}])
#malformed value
self.assertEqual(OffHour({})(i), False)
t = t.replace(year=2016, month=5, day=26, hour=13, minute=00)
with mock_datetime_now(t, datetime):
i = instance(Tags=[{'Key': 'maid_offhours',
'Value': 'off=();tz=et'}])
#will go to default values, but not work due to default time
self.assertEqual(OffHour({})(i), False)
i = instance(Tags=[{'Key': 'maid_offhours',
'Value': 'off=(m-f,90);on=(m-f,7);tz=et'}])
self.assertEqual(OffHour({})(i), False)
def test_jmespath(self):
self.assertFilter(
{'Placement.AvailabilityZone': 'us-west-2c'},
instance(),
True)
self.assertFilter(
{'Placement.AvailabilityZone': 'us-east-1c'},
instance(),
False)
def test_less_than(self):
f = filters.factory({
'type': 'value',
'key': 'Number',
'value': 10,
'op': 'less-than'
})
self.assertEqual(f(instance(Number=9)), True)
self.assertEqual(f(instance(Number=11)), False)
self.assertEqual(f(instance(Number=10)), False)
def test_or(self):
f = filters.factory(
{'or': [{
'Architecture': 'x86_64'
}, {
'Architecture': 'armv8'
}]})
results = [instance(Architecture='x86_64')]
self.assertEqual(f.process(results), results)
self.assertEqual(f.process([instance(Architecture='amd64')]), [])
def test_filter_tag_count(self):
tags = []
for i in range(10):
tags.append({'Key': str(i), 'Value': str(i)})
i = instance(Tags=tags)
self.assertFilter(
{'type': 'tag-count', 'op': 'lt'}, i, False)
tags.pop(0)
i = instance(Tags=tags)
self.assertFilter(
{'type': 'tag-count', 'op': 'gte', 'count': 9}, i, True)
def test_custom_bad_tz(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2016, month=5, day=26, hour=7, minute=00)
with mock_datetime_now(t, datetime):
i = instance(Tags=[{'Key': 'maid_offhours',
'Value': 'off=(m-f,19);on=(m-f,7);tz=et'}])
self.assertEqual(OnHour({})(i), True)
i = instance(Tags=[{'Key': 'maid_offhours',
'Value': 'off=(m-f,20);on=(m-f,7);tz=abc'}])
self.assertEqual(OnHour({})(i), False)
def test_regex_match(self):
f = filters.factory({
'type': 'value',
'key': 'Color',
'value': '*green*',
'op': 'glob'
})
self.assertEqual(
f(instance(Architecture='x86_64', Color='mighty green papaya')),
True)
self.assertEqual(f(instance(Architecture='x86_64', Color='blue')),
False)
def test_and(self):
f = filters.factory(
{'and': [{
'Architecture': 'x86_64'
}, {
'Color': 'green'
}]})
results = [instance(Architecture='x86_64', Color='green')]
self.assertEqual(f.process(results), results)
self.assertEqual(
f.process([instance(Architecture='x86_64', Color='blue')]), [])
self.assertEqual(f.process([instance(Architecture='x86_64')]), [])
def test_or(self):
f = filters.factory({
'or': [
{'Architecture': 'x86_64'},
{'Architecture': 'armv8'}]})
results = [instance(Architecture='x86_64')]
self.assertEqual(
f.process(results),
results)
self.assertEqual(
f.process([instance(Architecture='amd64')]),
[])
def test_custom_onhours(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2016, month=5, day=26, hour=7, minute=00)
results = []
with mock_datetime_now(t, datetime):
for i in [instance(Tags=[{'Key': 'maid_offhours',
'Value': 'off=(m-f,19);on=(m-f,7);tz=et'}]),
instance(Tags=[{'Key': 'maid_offhours',
'Value': 'off=(m-f,20);on=(m-f,9);tz=et'}])]:
results.append(OnHour({})(i))
self.assertEqual(results, [True, False])
def test_not_in(self):
f = filters.factory(
{'type': 'value',
'key': 'Thing',
'value': ['Foo', 'Bar', 'Quux'],
'op': 'not-in'})
self.assertEqual(
f(instance(Thing='Baz')),
True)
self.assertEqual(
f(instance(Thing='Foo')),
False)
def test_not_equal(self):
f = filters.factory(
{'type': 'value',
'key': 'Color',
'value': 'green',
'op': 'not-equal'})
self.assertEqual(
f(instance(Color='green')),
False)
self.assertEqual(
f(instance(Color='blue')),
True)
def test_filter_tag_count(self):
tags = []
for i in range(10):
tags.append({'Key': str(i), 'Value': str(i)})
i = instance(Tags=tags)
self.assertFilter({'type': 'tag-count', 'op': 'lt'}, i, False)
tags.pop(0)
i = instance(Tags=tags)
self.assertFilter({
'type': 'tag-count',
'op': 'gte',
'count': 9
}, i, True)
def test_offhours_real_world_values(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2015, month=12, day=1, hour=19, minute=5)
with mock_datetime_now(t, datetime):
results = [OffHour({})(i) for i in [
instance(Tags=[
{'Key': 'maid_offhours', 'Value': ''}]),
instance(Tags=[
{'Key': 'maid_offhours', 'Value': '"Offhours tz=ET"'}]),
instance(Tags=[
{'Key': 'maid_offhours', 'Value': 'Offhours tz=PT'}])]]
# unclear what this is really checking
self.assertEqual(results, [True, True, True])
def test_filter_tag(self):
i = instance(Tags=[
{'Key': 'ASV', 'Value': 'abcd'}])
self.assertFilter(
{'tag:ASV': 'def'}, i, False)
self.assertEqual(
annotation(i, base_filters.ANNOTATION_KEY), ())
i = instance(Tags=[
{'Key': 'CMDB', 'Value': 'abcd'}])
self.assertFilter(
{'tag:ASV': 'absent'}, i, True)
self.assertEqual(
annotation(i, base_filters.ANNOTATION_KEY), ['tag:ASV'])
def test_filters(self):
ec2 = self.get_manager({
'filters': [
{'tag:CMDBEnvironment': 'absent'}]})
self.assertEqual(
len(ec2.filter_resources([
instance(Tags=[{"Key": "ASV", "Value": "xyz"}])])),
1)
self.assertEqual(
len(ec2.filter_resources([
instance(Tags=[{"Key": "CMDBEnvironment", "Value": "xyz"}])])),
0)
def test_custom_bad_tz(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2016, month=5, day=26, hour=7, minute=00)
with mock_datetime_now(t, datetime):
i = instance(Tags=[{
'Key': 'maid_offhours',
'Value': 'off=(m-f,19);on=(m-f,7);tz=et'
}])
self.assertEqual(OnHour({})(i), True)
i = instance(Tags=[{
'Key': 'maid_offhours',
'Value': 'off=(m-f,20);on=(m-f,7);tz=abc'
}])
self.assertEqual(OnHour({})(i), False)
def test_opt_out_behavior(self):
# Some users want to match based on policy filters to
# a resource subset with default opt out behavior
t = datetime.datetime(
year=2015, month=12, day=1, hour=19, minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
f = OffHour({'opt-out': True})
with mock_datetime_now(t, datetime):
i = instance(Tags=[])
self.assertEqual(f(i), True)
i = instance(
Tags=[{'Key': 'maid_offhours', 'Value': 'off'}])
self.assertEqual(f(i), False)
self.assertEqual(f.opted_out, [i])
def test_process(self):
f = OffHour({'opt-out': True})
instances = [
instance(Tags=[]),
instance(
Tags=[{'Key': 'maid_offhours', 'Value': 'off'}]),
instance(
Tags=[
{'Key': 'maid_offhours',
'Value': "off=(m-f,5);zebrablue,on=(t-w,5)"}])]
t = datetime.datetime(
year=2015, month=12, day=1, hour=19, minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
with mock_datetime_now(t, datetime):
self.assertEqual(f.process(instances), [instances[0]])
def test_not(self):
results = [
instance(Architecture='x86_64', Color='green'),
instance(Architecture='x86_64', Color='blue'),
instance(Architecture='x86_64', Color='yellow'),
]
f = filters.factory({
'not': [
{'Architecture': 'x86_64'},
{'Color': 'green'}]})
self.assertEqual(len(f.process(results)), 2)
"""
def test_less_than(self):
f = filters.factory(
{'type': 'value',
'key': 'Number',
'value': 10,
'op': 'less-than'})
self.assertEqual(
f(instance(Number=9)),
True)
self.assertEqual(
f(instance(Number=11)),
False)
self.assertEqual(
f(instance(Number=10)),
False)
def test_not_null_filter(self):
self.assertFilter(
{"key": "Hypervisor",
"value": "not-null",
"type": "value"},
instance(),
True)
def test_regex_match(self):
f = filters.factory(
{'type': 'value',
'key': 'Color',
'value': '*green*',
'op': 'glob'})
self.assertEqual(
f(instance(
Architecture='x86_64',
Color='mighty green papaya')),
True)
self.assertEqual(
f(instance(
Architecture='x86_64',
Color='blue')),
False)
def i(d, action='stop'):
return instance(Tags=[{
"Key":
"maid_status",
"Value":
"not compliant: %s@%s" % (action, d.strftime("%Y/%m/%d"))
}])
def test_offhours(self):
t = datetime.datetime(year=2015, month=12, day=1, hour=19, minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
with mock_datetime_now(t, datetime):
i = instance(Tags=[
{'Key': 'maid_offhours', 'Value': 'tz=est'}])
self.assertEqual(OffHour({})(i), True)
def test_tz_only(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2016, month=5, day=26, hour=7, minute=00)
with mock_datetime_now(t, datetime):
i = instance(Tags=[{'Key': 'maid_offhours',
'Value': 'tz=est'}])
self.assertEqual(OnHour({})(i), True)
def test_not_null_filter(self):
self.assertFilter(
{
"key": "Hypervisor",
"value": "not-null",
"type": "value"
}, instance(), True)
def test_not(self):
results = [
instance(Architecture='x86_64', Color='green'),
instance(Architecture='x86_64', Color='blue'),
instance(Architecture='x86_64', Color='yellow'),
]
f = filters.factory(
{'not': [{
'Architecture': 'x86_64'
}, {
'Color': 'green'
}]})
self.assertEqual(len(f.process(results)), 2)
"""
def test_normalize(self):
fdata = {
'type': 'value',
'key': 'tag:Name',
'value_type': 'normalize',
'value': 'compilelambda'
}
self.assertFilter(fdata, instance(), True)
def test_resource_count_filter(self):
fdata = {
'type': 'value',
'value_type': 'resource_count',
'op': 'lt',
'value': 2
}
self.assertFilter(fdata, instance(file='ec2-instances.json'), [])
f = filters.factory({
'type': 'value',
'value_type': 'resource_count',
'op': 'eq',
'value': 2
})
i = instance(file='ec2-instances.json')
self.assertEqual(i, f(i))
def test_present(self):
i = instance(Tags=[{'Key': 'ASV', 'Value': ''}])
self.assertFilter(
{
'type': 'value',
'key': 'tag:ASV',
'value': 'present'
}, i, True)
def test_size(self):
fdata = {
'type': 'value',
'key': 'SecurityGroups[].GroupId',
'value_type': 'size',
'value': 2
}
self.assertFilter(fdata, instance(), True)
def test_resource_schedule_error(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2015, month=12, day=1, hour=19, minute=5)
f = OffHour({})
f.process_resource_schedule = lambda: False
with mock_datetime_now(t, datetime):
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
self.assertEqual(f(i), False)
def test_size(self):
fdata = {
'type': 'value',
'key': 'SecurityGroups[].GroupId',
'value_type': 'size',
'value': 2
}
self.assertFilter(fdata, instance(), True)
def test_normalize(self):
fdata = {
'type': 'value',
'key': 'tag:Name',
'value_type': 'normalize',
'value': 'compilelambda'
}
self.assertFilter(fdata, instance(), True)
def test_opt_out_behavior(self):
# Some users want to match based on policy filters to
# a resource subset with default opt out behavior
t = datetime.datetime(year=2015,
month=12,
day=1,
hour=19,
minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
f = OffHour({'opt-out': True})
with mock_datetime_now(t, datetime):
i = instance(Tags=[])
self.assertEqual(f(i), True)
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'off'}])
self.assertEqual(f(i), False)
self.assertEqual(f.opted_out, [i])
def test_resource_count_filter(self):
fdata = {
'type': 'value',
'value_type': 'resource_count',
'op': 'lt',
'value': 2
}
self.assertFilter(fdata, instance(file='ec2-instances.json'), [])
f = filters.factory({
'type': 'value',
'value_type': 'resource_count',
'op': 'eq',
'value': 2
})
i = instance(file='ec2-instances.json')
self.assertEqual(i, f(i))
def test_present(self):
i = instance(Tags=[
{'Key': 'ASV', 'Value': ''}])
self.assertFilter(
{'type': 'value',
'key': 'tag:ASV',
'value': 'present'},
i, True)
def test_custom_onhours(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2016, month=5, day=26, hour=7, minute=00)
results = []
with mock_datetime_now(t, datetime):
for i in [
instance(Tags=[{
'Key': 'maid_offhours',
'Value': 'off=(m-f,19);on=(m-f,7);tz=et'
}]),
instance(Tags=[{
'Key': 'maid_offhours',
'Value': 'off=(m-f,20);on=(m-f,9);tz=et'
}])
]:
results.append(OnHour({})(i))
self.assertEqual(results, [True, False])
def test_swap(self):
fdata = {
'type': 'value',
'key': 'SecurityGroups[].GroupId',
'value_type': 'swap',
'op': 'in',
'value': 'sg-47b76f22'
}
self.assertFilter(fdata, instance(), True)
def test_resource_schedule_error(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2015, month=12, day=1, hour=19, minute=5)
f = OffHour({})
f.process_resource_schedule = lambda: False
with mock_datetime_now(t, datetime):
i = instance(Tags=[
{'Key': 'maid_offhours', 'Value': 'tz=est'}])
self.assertEqual(f(i), False)
def test_swap(self):
fdata = {
'type': 'value',
'key': 'SecurityGroups[].GroupId',
'value_type': 'swap',
'op': 'in',
'value': 'sg-47b76f22'
}
self.assertFilter(fdata, instance(), True)
def test_offhours(self):
t = datetime.datetime(year=2015,
month=12,
day=1,
hour=19,
minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
with mock_datetime_now(t, datetime):
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
self.assertEqual(OffHour({})(i), True)
def test_event_filter(self):
b = Bag(data={'mode': []})
event = event_data('event-instance-state.json')
f = {'type': 'event', 'key': 'detail.state', 'value': 'pending'}
ef = filters.factory(f, b)
self.assertTrue(ef.process([instance()], event))
# event is None
self.assertEqual(ef.process('resources'), 'resources')
# event is not None, but is not "true" either
self.assertEqual(ef.process('resources', []), [])
def test_and(self):
f = filters.factory({
'and': [
{'Architecture': 'x86_64'},
{'Color': 'green'}]})
results = [instance(Architecture='x86_64', Color='green')]
self.assertEqual(
f.process(results),
results)
self.assertEqual(
f.process([
instance(
Architecture='x86_64',
Color='blue')]),
[])
self.assertEqual(
f.process([
instance(
Architecture='x86_64')]),
[])
def test_complex_value_filter(self):
self.assertFilter(
{"key": (
"length(BlockDeviceMappings"
"[?Ebs.DeleteOnTermination == `true`]"
".Ebs.DeleteOnTermination)"),
"value": 0,
"type": "value",
"op": "gt"},
instance(),
True)
def test_offhours_get_value(self):
off = OffHour({'default_tz': 'ct'})
i = instance(Tags=[
{'Key': 'maid_offhours', 'Value': 'Offhours tz=PT'}])
self.assertEqual(off.get_tag_value(i), "offhours tz=pt")
self.assertFalse(off.parser.has_resource_schedule(
off.get_tag_value(i)))
self.assertTrue(off.parser.keys_are_valid(
off.get_tag_value(i)))
self.assertEqual(off.parser.raw_data(
off.get_tag_value(i)), {'tz': 'pt'})
def test_offhour_weekend_support(self):
start_day = 26
t = datetime.datetime(
year=2016, day=start_day, month=2, hour=19, minute=20)
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
f = OffHour({})
results = []
with mock_datetime_now(t, datetime) as dt:
for n in range(0, 4):
dt.target = t.replace(day=start_day+n)
results.append(f(i))
self.assertEqual(results, [True, False, False, True])
def test_offhours_get_value(self):
off = OffHour({'default_tz': 'ct'})
i = instance(Tags=[{
'Key': 'maid_offhours',
'Value': 'Offhours tz=PT'
}])
self.assertEqual(off.get_tag_value(i), "offhours tz=pt")
self.assertFalse(
off.parser.has_resource_schedule(off.get_tag_value(i), 'off'))
self.assertTrue(off.parser.keys_are_valid(off.get_tag_value(i)))
self.assertEqual(off.parser.raw_data(off.get_tag_value(i)),
{'tz': 'pt'})
def test_process(self):
f = OffHour({'opt-out': True})
instances = [
instance(Tags=[]),
instance(Tags=[{
'Key': 'maid_offhours',
'Value': 'off'
}]),
instance(Tags=[{
'Key': 'maid_offhours',
'Value': "off=(m-f,5);zebrablue,on=(t-w,5)"
}])
]
t = datetime.datetime(year=2015,
month=12,
day=1,
hour=19,
minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
with mock_datetime_now(t, datetime):
self.assertEqual(f.process(instances), [instances[0]])
def test_filters(self):
ec2 = self.get_manager(
{'filters': [{
'tag:CMDBEnvironment': 'absent'
}]})
self.assertEqual(
len(
ec2.filter_resources(
[instance(Tags=[{
"Key": "ASV",
"Value": "xyz"
}])])), 1)
self.assertEqual(
len(
ec2.filter_resources([
instance(Tags=[{
"Key": "CMDBEnvironment",
"Value": "xyz"
}])
])), 0)
def test_everyday_offhour(self):
# weekends on means we match times on the weekend
start_day = 14 # sunday
t = datetime.datetime(
year=2016, day=start_day, month=8, hour=19, minute=20)
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
f = OffHour({'weekends': False})
results = []
with mock_datetime_now(t, datetime) as dt:
for n in range(7):
dt.target = t.replace(day=start_day+n)
results.append(f(i))
self.assertEqual(results, [True] * 7)
def test_offhours_real_world_values(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2015, month=12, day=1, hour=19, minute=5)
with mock_datetime_now(t, datetime):
results = [
OffHour({})(i) for i in [
instance(Tags=[{
'Key': 'maid_offhours',
'Value': ''
}]),
instance(Tags=[{
'Key': 'maid_offhours',
'Value': '"Offhours tz=ET"'
}]),
instance(Tags=[{
'Key': 'maid_offhours',
'Value': 'Offhours tz=PT'
}])
]
]
# unclear what this is really checking
self.assertEqual(results, [True, True, True])
def test_complex_value_filter(self):
self.assertFilter(
{
"key": ("length(BlockDeviceMappings"
"[?Ebs.DeleteOnTermination == `true`]"
".Ebs.DeleteOnTermination)"),
"value":
0,
"type":
"value",
"op":
"gt"
}, instance(), True)
def test_current_time_test(self):
t = datetime.datetime.now(zoneinfo.gettz('America/New_York'))
t = t.replace(year=2015, month=12, day=1, hour=19, minute=5)
with mock_datetime_now(t, datetime):
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
f = OffHour({})
p = f.get_tag_value(i)
self.assertEqual(p, 'tz=est')
tz = f.get_tz('est')
self.assertTrue(
str(tz) in ("tzfile('US/Eastern')",
"tzfile('America/New_York')"))
self.assertEqual(datetime.datetime.now(tz), t)
self.assertEqual(t.hour, 19)
def test_offhour_weekend_support(self):
start_day = 26
t = datetime.datetime(year=2016,
day=start_day,
month=2,
hour=19,
minute=20)
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
f = OffHour({})
results = []
with mock_datetime_now(t, datetime) as dt:
for n in range(0, 4):
dt.target = t.replace(day=start_day + n)
results.append(f(i))
self.assertEqual(results, [True, False, False, True])
def test_everyday_offhour(self):
# weekends on means we match times on the weekend
start_day = 14 # sunday
t = datetime.datetime(year=2016,
day=start_day,
month=8,
hour=19,
minute=20)
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
f = OffHour({'weekends': False})
results = []
with mock_datetime_now(t, datetime) as dt:
for n in range(7):
dt.target = t.replace(day=start_day + n)
results.append(f(i))
self.assertEqual(results, [True] * 7)
def xtest_time_match_stops_after_skew(self):
hour = 7
t = datetime.datetime(year=2015,
month=12,
day=1,
hour=hour,
minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
f = OnHour({'skew': 1})
results = []
with mock_datetime_now(t, datetime) as dt:
for n in range(0, 4):
dt.target = t.replace(hour=hour + n)
results.append(f(i))
self.assertEqual(results, [True, True, False, False])
def test_weekends_only_offhour_support(self):
# start day is a sunday, weekend only means we only stop
# on friday evening.
start_day = 14
t = datetime.datetime(year=2016,
day=start_day,
month=8,
hour=7,
minute=20)
i = instance(Tags=[{'Key': 'maid_offhours', 'Value': 'tz=est'}])
f = OnHour({'weekends-only': True})
results = []
with mock_datetime_now(t, datetime) as dt:
for n in range(7):
dt.target = t.replace(day=start_day + n)
results.append(f(i))
self.assertEqual(results,
[False, True, False, False, False, False, False])
def test_opt_in_behavior(self):
# Given the addition of opt out behavior, verify if its
# not configured that we don't touch an instance that
# has no downtime tag
t = datetime.datetime(year=2015,
month=12,
day=1,
hour=19,
minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
i = instance(Tags=[])
f = OffHour({})
with mock_datetime_now(t, datetime):
self.assertEqual(f(i), False)
t = datetime.datetime(year=2015,
month=12,
day=1,
hour=7,
minute=5,
tzinfo=zoneinfo.gettz('America/New_York'))
f = OnHour({})
self.assertEqual(f(i), False)
