bestflags/task_test.py

# 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()