From 679147eead574d186ebf3069647b4c23e8ccace6 Mon Sep 17 00:00:00 2001 From: Zeno Albisser Date: Thu, 15 Aug 2013 21:46:11 +0200 Subject: Initial import. --- chromium/ppapi/generate_ppapi_include_tests.py | 171 +++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100755 chromium/ppapi/generate_ppapi_include_tests.py (limited to 'chromium/ppapi/generate_ppapi_include_tests.py') diff --git a/chromium/ppapi/generate_ppapi_include_tests.py b/chromium/ppapi/generate_ppapi_include_tests.py new file mode 100755 index 00000000000..97daf246c5e --- /dev/null +++ b/chromium/ppapi/generate_ppapi_include_tests.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python +# Copyright (c) 2012 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +"""This script should be run manually on occasion to make sure the gyp file and +the includes tests are up to date. + +It does the following: + - Verifies that all source code is in ppapi.gyp + - Verifies that all sources in ppapi.gyp really do exist + - Generates tests/test_c_includes.c + - Generates tests/test_cpp_includes.cc +These tests are checked in to SVN. +""" +# TODO(dmichael): Make this script execute as a gyp action, move the include +# tests to some 'generated' area, and remove them from version +# control. + +import re +import os +import sys +import posixpath + +# A simple regular expression that should match source files for C++ and C. +SOURCE_FILE_RE = re.compile('.+\.(cc|c|h)$') + +# IGNORE_RE is a regular expression that matches directories which contain +# source that we don't (currently) expect to be in ppapi.gyp. This script will +# not check whether source files under these directories are in the gyp file. +# TODO(dmichael): Put examples back in the build. +# TODO(brettw): Put proxy in the build when it's ready. +IGNORE_RE = re.compile('^(examples|GLES2|proxy|tests\/clang).*') + +GYP_TARGETS_KEY = 'targets' +GYP_SOURCES_KEY = 'sources' +GYP_TARGET_NAME_KEY = 'target_name' + + +# Return a set containing all source files found given an object read from a gyp +# file. +def GetAllGypSources(gyp_file_data): + sources = set([]) + for target in gyp_file_data[GYP_TARGETS_KEY]: + # Get a list of sources in the target that are not ignored, and 'normalize' + # them. The main reason for this is to turn the forward slashes in the gyp + # file in to backslashes when the script is run on Windows. + source_list = [posixpath.normpath(src) for src in target[GYP_SOURCES_KEY] + if not IGNORE_RE.match(src)] + sources |= set(source_list) + return sources + + +# Search the directory named start_root and all its subdirectories for source +# files. +# Return a set containing the string names of all the source files found, +# relative to start_root. +def GetFileSources(start_root): + file_set = set([]) + for root, dirs, files in os.walk(start_root): + relative_root = os.path.relpath(root, start_root) + if not IGNORE_RE.match(relative_root): + for source in files: + if SOURCE_FILE_RE.match(source): + file_set |= set([os.path.join(relative_root, source)]) + return file_set + + +# Make sure all source files are in the given gyp object (evaluated from a gyp +# file), and that all source files listed in the gyp object exist in the +# directory. +def VerifyGypFile(gyp_file_data): + gyp_sources = GetAllGypSources(gyp_file_data) + file_sources = GetFileSources('.') + in_gyp_not_file = gyp_sources - file_sources + in_file_not_gyp = file_sources - gyp_sources + if len(in_gyp_not_file): + print 'Found source file(s) in ppapi.gyp but not in the directory:', \ + in_gyp_not_file + if len(in_file_not_gyp): + print 'Found source file(s) in the directory but not in ppapi.gyp:', \ + in_file_not_gyp + error_count = len(in_gyp_not_file) + len(in_file_not_gyp) + if error_count: + sys.exit(error_count) + + +def WriteLines(filename, lines): + outfile = open(filename, 'w') + for line in lines: + outfile.write(line) + outfile.write('\n') + + +COPYRIGHT_STRING_C = \ +"""/* Copyright (c) 2010 The Chromium Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + * + * This test simply includes all the C headers to ensure they compile with a C + * compiler. If it compiles, it passes. + */ +""" + +COPYRIGHT_STRING_CC = \ +"""// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// This test simply includes all the C++ headers to ensure they compile with a +// C++ compiler. If it compiles, it passes. +// +""" + + +# Get the source file names out of the given gyp file data object (as evaluated +# from a gyp file) for the given target name. Return the string names in +# sorted order. +def GetSourcesForTarget(target_name, gyp_file_data): + for target in gyp_file_data[GYP_TARGETS_KEY]: + if target[GYP_TARGET_NAME_KEY] == target_name: + sources = target[GYP_SOURCES_KEY] + sources.sort() + return sources + print 'Warning: no target named ', target, ' found.' + return [] + + +# Generate all_c_includes.h, which includes all C headers. This is part of +# tests/test_c_sizes.c, which includes all C API files to ensure that all +# the headers in ppapi/c can be compiled with a C compiler, and also asserts +# (with compile-time assertions) that all structs and enums are a particular +# size. +def GenerateCIncludeTest(gyp_file_data): + c_sources = GetSourcesForTarget('ppapi_c', gyp_file_data) + lines = [COPYRIGHT_STRING_C] + lines.append('#ifndef PPAPI_TESTS_ALL_C_INCLUDES_H_\n') + lines.append('#define PPAPI_TESTS_ALL_C_INCLUDES_H_\n\n') + for source in c_sources: + lines.append('#include "ppapi/' + source + '"\n') + lines.append('\n#endif /* PPAPI_TESTS_ALL_C_INCLUDES_H_ */\n') + WriteLines('tests/all_c_includes.h', lines) + + +# Generate all_cpp_includes.h, which is used by test_cpp_includes.cc to ensure +# that all the headers in ppapi/cpp can be compiled with a C++ compiler. +def GenerateCCIncludeTest(gyp_file_data): + cc_sources = GetSourcesForTarget('ppapi_cpp_objects', gyp_file_data) + header_re = re.compile('.+\.h$') + lines = [COPYRIGHT_STRING_CC] + lines.append('#ifndef PPAPI_TESTS_ALL_CPP_INCLUDES_H_\n') + lines.append('#define PPAPI_TESTS_ALL_CPP_INCLUDES_H_\n\n') + for source in cc_sources: + if header_re.match(source): + lines.append('#include "ppapi/' + source + '"\n') + lines.append('\n#endif // PPAPI_TESTS_ALL_CPP_INCLUDES_H_\n') + WriteLines('tests/all_cpp_includes.h', lines) + + +def main(): + ppapi_gyp_file_name = 'ppapi.gyp' + gyp_file_contents = open(ppapi_gyp_file_name).read() + gyp_file_data = eval(gyp_file_contents) + VerifyGypFile(gyp_file_data) + GenerateCIncludeTest(gyp_file_data) + GenerateCCIncludeTest(gyp_file_data) + return 0 + + +if __name__ == '__main__': + sys.exit(main()) -- cgit v1.2.1