175 lines
5.5 KiB
Python
175 lines
5.5 KiB
Python
# Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
|
|
# Use of this source code is governed by a BSD-style license that can be
|
|
# found in the LICENSE file.
|
|
"""Task unittest.
|
|
|
|
Part of the Chrome build flags optimization.
|
|
"""
|
|
|
|
__author__ = 'yuhenglong@google.com (Yuheng Long)'
|
|
|
|
import random
|
|
import sys
|
|
import unittest
|
|
|
|
import task
|
|
from task import Task
|
|
|
|
# The number of flags be tested.
|
|
NUM_FLAGS = 20
|
|
|
|
# The random build result values used to test get set result method.
|
|
RANDOM_BUILD_RESULT = 100
|
|
|
|
# The random test result values used to test get set result method.
|
|
RANDOM_TESTRESULT = 100
|
|
|
|
|
|
class MockFlagSet(object):
|
|
"""This class emulates a set of flags.
|
|
|
|
It returns the flags and hash value, when the FormattedForUse method and the
|
|
__hash__ method is called, respectively. These values are initialized when the
|
|
MockFlagSet instance is constructed.
|
|
"""
|
|
|
|
def __init__(self, flags=0, hash_value=-1):
|
|
self._flags = flags
|
|
self._hash_value = hash_value
|
|
|
|
def __eq__(self, other):
|
|
assert isinstance(other, MockFlagSet)
|
|
return self._flags == other.FormattedForUse()
|
|
|
|
def FormattedForUse(self):
|
|
return self._flags
|
|
|
|
def __hash__(self):
|
|
return self._hash_value
|
|
|
|
def GetHash(self):
|
|
return self._hash_value
|
|
|
|
|
|
class TaskTest(unittest.TestCase):
|
|
"""This class test the Task class."""
|
|
|
|
def testEqual(self):
|
|
"""Test the equal method of the task.
|
|
|
|
Two tasks are equal if and only if their encapsulated flag_sets are equal.
|
|
"""
|
|
|
|
flags = range(NUM_FLAGS)
|
|
|
|
# Two tasks having the same flag set should be equivalent.
|
|
flag_sets = [MockFlagSet(flag) for flag in flags]
|
|
for flag_set in flag_sets:
|
|
assert Task(flag_set) == Task(flag_set)
|
|
|
|
# Two tasks having different flag set should be different.
|
|
for flag_set in flag_sets:
|
|
test_task = Task(flag_set)
|
|
other_flag_sets = [flags for flags in flag_sets if flags != flag_set]
|
|
for flag_set1 in other_flag_sets:
|
|
assert test_task != Task(flag_set1)
|
|
|
|
def testHash(self):
|
|
"""Test the hash method of the task.
|
|
|
|
Two tasks are equal if and only if their encapsulated flag_sets are equal.
|
|
"""
|
|
|
|
# Random identifier that is not relevant in this test.
|
|
identifier = random.randint(-sys.maxint - 1, -1)
|
|
|
|
flag_sets = [MockFlagSet(identifier, value) for value in range(NUM_FLAGS)]
|
|
for flag_set in flag_sets:
|
|
# The hash of a task is the same as the hash of its flag set.
|
|
hash_task = Task(flag_set)
|
|
hash_value = hash(hash_task)
|
|
assert hash_value == flag_set.GetHash()
|
|
|
|
# The hash of a task does not change.
|
|
assert hash_value == hash(hash_task)
|
|
|
|
def testGetIdentifier(self):
|
|
"""Test the get identifier method of the task.
|
|
|
|
The get identifier method should returns the flag set in the build stage.
|
|
"""
|
|
|
|
flag_sets = [MockFlagSet(flag) for flag in range(NUM_FLAGS)]
|
|
for flag_set in flag_sets:
|
|
identifier_task = Task(flag_set)
|
|
|
|
identifier = identifier_task.GetIdentifier(task.BUILD_STAGE)
|
|
|
|
# The task formats the flag set into a string.
|
|
assert identifier == str(flag_set.FormattedForUse())
|
|
|
|
def testGetSetResult(self):
|
|
"""Test the get and set result methods of the task.
|
|
|
|
The get result method should return the same results as were set.
|
|
"""
|
|
|
|
flag_sets = [MockFlagSet(flag) for flag in range(NUM_FLAGS)]
|
|
for flag_set in flag_sets:
|
|
result_task = Task(flag_set)
|
|
|
|
# The get result method should return the same results as were set, in
|
|
# build stage. Currently, the build result is a 5-element tuple containing
|
|
# the checksum of the result image, the performance cost of the build, the
|
|
# compilation image, the length of the build, and the length of the text
|
|
# section of the build.
|
|
result = tuple([random.randint(0, RANDOM_BUILD_RESULT) for _ in range(5)])
|
|
result_task.SetResult(task.BUILD_STAGE, result)
|
|
assert result == result_task.GetResult(task.BUILD_STAGE)
|
|
|
|
# The checksum is the identifier of the test stage.
|
|
identifier = result_task.GetIdentifier(task.TEST_STAGE)
|
|
# The first element of the result tuple is the checksum.
|
|
assert identifier == result[0]
|
|
|
|
# The get result method should return the same results as were set, in
|
|
# test stage.
|
|
random_test_result = random.randint(0, RANDOM_TESTRESULT)
|
|
result_task.SetResult(task.TEST_STAGE, random_test_result)
|
|
test_result = result_task.GetResult(task.TEST_STAGE)
|
|
assert test_result == random_test_result
|
|
|
|
def testDone(self):
|
|
"""Test the done methods of the task.
|
|
|
|
The done method should return false is the task has not perform and return
|
|
true after the task is finished.
|
|
"""
|
|
|
|
flags = range(NUM_FLAGS)
|
|
|
|
flag_sets = [MockFlagSet(flag) for flag in flags]
|
|
for flag_set in flag_sets:
|
|
work_task = Task(flag_set)
|
|
|
|
# The task has not been compiled nor tested.
|
|
assert not work_task.Done(task.TEST_STAGE)
|
|
assert not work_task.Done(task.BUILD_STAGE)
|
|
|
|
# After the task has been compiled, it should indicate finished in BUILD
|
|
# stage.
|
|
result = tuple([random.randint(0, RANDOM_BUILD_RESULT) for _ in range(5)])
|
|
work_task.SetResult(task.BUILD_STAGE, result)
|
|
assert not work_task.Done(task.TEST_STAGE)
|
|
assert work_task.Done(task.BUILD_STAGE)
|
|
|
|
# After the task has been tested, it should indicate finished in TEST
|
|
# stage.
|
|
work_task.SetResult(task.TEST_STAGE, random.randint(0, RANDOM_TESTRESULT))
|
|
assert work_task.Done(task.TEST_STAGE)
|
|
assert work_task.Done(task.BUILD_STAGE)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|