cq/scripts/helpers/sanitizer_utils_test.py

"""Tests for sanitizer_utils."""

from __future__ import absolute_import
import os
import sys
import unittest

# Allow imports from cq/scripts folder
sys.path.insert(
    0, os.path.realpath(os.path.join(os.path.dirname(__file__), os.pardir)))
from helpers import sanitizer_utils
from helpers import sanitizer_utils_test_data as test_data


class SanitizerUtilsTest(unittest.TestCase):

  def testAsanToComments(self):
    """Tests converting ASAN errors to Gerrit comments."""
    comment_generator = sanitizer_utils.get_sanitizer_to_comments_for('asan')
    actual_review = comment_generator(0, test_data.ASAN_ERROR_MESSAGE, '')
    expected_review = {'review': {'message': test_data.ASAN_COMMENT}}
    self.assertDictEqual(expected_review, actual_review)

  def testAsanLsanToComments(self):
    """Tests converting ASAN/LSAN combined errors to Gerrit comments."""
    comment_generator = sanitizer_utils.get_sanitizer_to_comments_for('asan')
    actual_review = comment_generator(0, test_data.ASAN_LSAN_ERROR_MESSAGE, '')
    expected_review = {'review': {'message': test_data.ASAN_LSAN_COMMENT}}
    self.assertDictEqual(expected_review, actual_review)

  def testAsanValidator(self):
    """Tests that ASAN errors are correctly detected from ASAN output."""
    validator = sanitizer_utils.get_validator_for('asan')
    self.assertTrue(validator(0, '', ''))
    self.assertTrue(validator(0, 'Some stdout stuff', 'Some stderr'))
    self.assertFalse(validator(1, test_data.ASAN_ERROR_MESSAGE, ''))

  def testAsanLsanValidator(self):
    """Tests that LSAN errors are correctly detected from ASAN/LSAN output."""
    validator = sanitizer_utils.get_validator_for('asan')
    self.assertFalse(validator(1, test_data.ASAN_LSAN_ERROR_MESSAGE, ''))

  def testMsanToComments(self):
    """Tests converting MSAN errors to Gerrit comments."""
    comment_generator = sanitizer_utils.get_sanitizer_to_comments_for('msan')
    actual_review = comment_generator(0, test_data.MSAN_ERROR_MESSAGE, '')
    expected_review = {'review': {'message': test_data.MSAN_COMMENT}}
    self.assertDictEqual(expected_review, actual_review)

  def testMsanValidator(self):
    """Tests that MSAN errors are correctly detected from MSAN output."""
    validator = sanitizer_utils.get_validator_for('msan')
    self.assertTrue(validator(0, '', ''))
    self.assertTrue(validator(0, 'Some stdout stuff', 'Some stderr'))
    self.assertFalse(validator(1, test_data.MSAN_ERROR_MESSAGE, ''))

  def testTsanToComments(self):
    """Tests converting TSAN errors to Gerrit comments."""
    comment_generator = sanitizer_utils.get_sanitizer_to_comments_for('tsan')
    actual_review = comment_generator(0, test_data.TSAN_ERROR_MESSAGE, '')
    expected_review = {'review': {'message': test_data.TSAN_COMMENT}}
    self.maxDiff = None
    self.assertDictEqual(expected_review, actual_review)

  def testTsanValidator(self):
    """Tests that TSAN errors are correctly detected from TSAN output."""
    validator = sanitizer_utils.get_validator_for('tsan')
    self.assertTrue(validator(0, '', ''))
    self.assertTrue(validator(0, 'Some stdout stuff', 'Some stderr'))
    self.assertFalse(validator(1, test_data.TSAN_ERROR_MESSAGE, ''))

  def testUbsanToComments(self):
    """Tests converting UBSAN errors to Gerrit comments."""
    comment_generator = sanitizer_utils.get_sanitizer_to_comments_for('ubsan')
    actual_review = comment_generator(0, test_data.UBSAN_ERROR_MESSAGE, '')
    self.maxDiff = None
    expected_review = {
        'review': {
            'message':
                '\n\n'.join([
                    test_data.UBSAN_COMMENT,
                    '<Too many errors to print. Check logs for more.>'
                ])
        }
    }
    self.assertDictEqual(expected_review, actual_review)

  def testUbsanValidator(self):
    """Tests that UBSAN errors are correctly detected from UBSAN output."""
    validator = sanitizer_utils.get_validator_for('ubsan')
    self.assertTrue(validator(0, '', ''))
    self.assertTrue(validator(0, 'Some stdout stuff', 'Some stderr'))
    self.assertFalse(validator(1, test_data.UBSAN_ERROR_MESSAGE, ''))

  def testTruncateVeryLongErrorMessage(self):
    """Tests that very long error messages get truncated."""
    very_long_comment_builder = ['WARNING: AddressSanitizer']
    very_long_comment_builder += ['line with error info'] * 1000
    very_long_comment_builder += ['SUMMARY: AddressSanitizer']
    very_long_comment = '\n'.join(very_long_comment_builder)

    comment_generator = sanitizer_utils.get_sanitizer_to_comments_for('asan')
    actual_review = comment_generator(0, very_long_comment, '')
    actual_review_message = actual_review['review']['message']

    self.assertIn('<...snip (error too long; removed 972 lines)...>',
                  actual_review_message)

    expected_message_length = sanitizer_utils._MAX_LINES_PER_ERROR + 1
    actual_message_length = len(actual_review_message.splitlines())
    self.assertEqual(actual_message_length, expected_message_length)


if __name__ == '__main__':
  unittest.main()