aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--docs/markdown/snippets/more_meson_sample_templates.md6
-rw-r--r--mesonbuild/cmake/traceparser.py18
-rw-r--r--mesonbuild/dependencies/base.py8
-rw-r--r--mesonbuild/minit.py136
-rw-r--r--mesonbuild/templates/cstemplates.py126
-rw-r--r--mesonbuild/templates/cudatemplates.py177
-rw-r--r--mesonbuild/templates/javatemplates.py129
-rw-r--r--mesonbuild/templates/mesontemplates.py51
-rw-r--r--mesonbuild/templates/objcpptemplates.py156
-rwxr-xr-xrun_project_tests.py106
-rwxr-xr-xrun_unittests.py24
-rw-r--r--test cases/cmake/16 threads/meson.build12
-rw-r--r--test cases/cmake/16 threads/meson_options.txt1
-rw-r--r--test cases/cmake/16 threads/subprojects/cmMod/CMakeLists.txt6
-rw-r--r--test cases/cmake/16 threads/subprojects/cmMod/cmMod.hpp13
-rw-r--r--test cases/cmake/16 threads/test_matrix.json9
16 files changed, 887 insertions, 91 deletions
diff --git a/docs/markdown/snippets/more_meson_sample_templates.md b/docs/markdown/snippets/more_meson_sample_templates.md
new file mode 100644
index 0000000..e10da9c
--- /dev/null
+++ b/docs/markdown/snippets/more_meson_sample_templates.md
@@ -0,0 +1,6 @@
+## More new sample Meson templates for (`Java`, `Cuda`, and more)
+
+Meson now ships with predefined project templates for `Java`,
+`Cuda`, `Objective-C++`, and `C#`, we provided with associated
+values for corresponding languages, avalable for both library,
+and executable.
diff --git a/mesonbuild/cmake/traceparser.py b/mesonbuild/cmake/traceparser.py
index 5bf9547..4aa34f1 100644
--- a/mesonbuild/cmake/traceparser.py
+++ b/mesonbuild/cmake/traceparser.py
@@ -54,6 +54,13 @@ class CMakeTarget:
propSTR += " '{}': {}\n".format(i, self.properties[i])
return s.format(self.name, self.type, self.imported, propSTR, self.tline)
+ def strip_properties(self) -> None:
+ # Strip the strings in the properties
+ if not self.properties:
+ return
+ for key, val in self.properties.items():
+ self.properties[key] = [x.strip() for x in val]
+
class CMakeGeneratorTarget(CMakeTarget):
def __init__(self, name):
super().__init__(name, 'CUSTOM', {})
@@ -63,11 +70,8 @@ class CMakeGeneratorTarget(CMakeTarget):
class CMakeTraceParser:
def __init__(self, cmake_version: str, build_dir: str, permissive: bool = False):
- # Dict of CMake variables: '<var_name>': ['list', 'of', 'values']
- self.vars = {}
-
- # Dict of CMakeTarget
- self.targets = {}
+ self.vars = {} # type: T.Dict[str, T.List[str]]
+ self.targets = {} # type: T.Dict[str, CMakeTarget]
# T.List of targes that were added with add_custom_command to generate files
self.custom_targets = [] # type: T.List[CMakeGeneratorTarget]
@@ -133,6 +137,10 @@ class CMakeTraceParser:
if(fn):
fn(l)
+ # Postprocess
+ for tgt in self.targets.values():
+ tgt.strip_properties()
+
def get_first_cmake_var_of(self, var_list: T.List[str]) -> T.List[str]:
# Return the first found CMake variable in list var_list
for i in var_list:
diff --git a/mesonbuild/dependencies/base.py b/mesonbuild/dependencies/base.py
index d014415..a83e3d6 100644
--- a/mesonbuild/dependencies/base.py
+++ b/mesonbuild/dependencies/base.py
@@ -1661,6 +1661,14 @@ class DubDependency(ExternalDependency):
lib_file_name = os.path.basename(default_path)
module_build_path = os.path.join(module_path, '.dub', 'build')
+ # If default_path is a path to lib file and
+ # directory of lib don't have subdir '.dub/build'
+ if not os.path.isdir(module_build_path) and os.path.isfile(default_path):
+ if folder_only:
+ return module_path
+ else:
+ return default_path
+
# Get D version implemented in the compiler
# gdc doesn't support this
ret, res = self._call_dubbin(['--version'])
diff --git a/mesonbuild/minit.py b/mesonbuild/minit.py
index 79741e5..5f28f58 100644
--- a/mesonbuild/minit.py
+++ b/mesonbuild/minit.py
@@ -22,13 +22,24 @@ from mesonbuild.environment import detect_ninja
from mesonbuild.templates.ctemplates import (create_exe_c_sample, create_lib_c_sample)
from mesonbuild.templates.cpptemplates import (create_exe_cpp_sample, create_lib_cpp_sample)
+from mesonbuild.templates.cstemplates import (create_exe_cs_sample, create_lib_cs_sample)
+from mesonbuild.templates.cudatemplates import (create_exe_cuda_sample, create_lib_cuda_sample)
from mesonbuild.templates.objctemplates import (create_exe_objc_sample, create_lib_objc_sample)
+from mesonbuild.templates.objcpptemplates import (create_exe_objcpp_sample, create_lib_objcpp_sample)
from mesonbuild.templates.dlangtemplates import (create_exe_d_sample, create_lib_d_sample)
+from mesonbuild.templates.javatemplates import (create_exe_java_sample, create_lib_java_sample)
from mesonbuild.templates.fortrantemplates import (create_exe_fortran_sample, create_lib_fortran_sample)
from mesonbuild.templates.rusttemplates import (create_exe_rust_sample, create_lib_rust_sample)
+'''
+there is currently only one meson template at this time.
+'''
+from mesonbuild.templates.mesontemplates import create_meson_build
+
FORTRAN_SUFFIXES = ['.f', '.for', '.F', '.f90', '.F90']
+UNREACHABLE_CODE = 'Unreachable code'
+
info_message = '''Sample project created. To build it run the
following commands:
@@ -37,53 +48,89 @@ ninja -C builddir
'''
def create_sample(options):
+ '''
+ Based on what arguments are passed we check for a match in language
+ then check for project type and create new Meson samples project.
+ '''
if options.language == 'c':
if options.type == 'executable':
create_exe_c_sample(options.name, options.version)
elif options.type == 'library':
create_lib_c_sample(options.name, options.version)
else:
- raise RuntimeError('Unreachable code')
+ raise RuntimeError(UNREACHABLE_CODE)
elif options.language == 'cpp':
if options.type == 'executable':
create_exe_cpp_sample(options.name, options.version)
elif options.type == 'library':
create_lib_cpp_sample(options.name, options.version)
else:
- raise RuntimeError('Unreachable code')
+ raise RuntimeError(UNREACHABLE_CODE)
+ elif options.language == 'cs':
+ if options.type == 'executable':
+ create_exe_cs_sample(options.name, options.version)
+ elif options.type == 'library':
+ create_lib_cs_sample(options.name, options.version)
+ else:
+ raise RuntimeError(UNREACHABLE_CODE)
+ elif options.language == 'cuda':
+ if options.type == 'executable':
+ create_exe_cuda_sample(options.name, options.version)
+ elif options.type == 'library':
+ create_lib_cuda_sample(options.name, options.version)
+ else:
+ raise RuntimeError(UNREACHABLE_CODE)
elif options.language == 'd':
if options.type == 'executable':
create_exe_d_sample(options.name, options.version)
elif options.type == 'library':
create_lib_d_sample(options.name, options.version)
else:
- raise RuntimeError('Unreachable code')
+ raise RuntimeError(UNREACHABLE_CODE)
elif options.language == 'fortran':
if options.type == 'executable':
create_exe_fortran_sample(options.name, options.version)
elif options.type == 'library':
create_lib_fortran_sample(options.name, options.version)
else:
- raise RuntimeError('Unreachable code')
+ raise RuntimeError(UNREACHABLE_CODE)
elif options.language == 'rust':
if options.type == 'executable':
create_exe_rust_sample(options.name, options.version)
elif options.type == 'library':
create_lib_rust_sample(options.name, options.version)
else:
- raise RuntimeError('Unreachable code')
+ raise RuntimeError(UNREACHABLE_CODE)
elif options.language == 'objc':
if options.type == 'executable':
create_exe_objc_sample(options.name, options.version)
elif options.type == 'library':
create_lib_objc_sample(options.name, options.version)
else:
- raise RuntimeError('Unreachable code')
+ raise RuntimeError(UNREACHABLE_CODE)
+ elif options.language == 'objcpp':
+ if options.type == 'executable':
+ create_exe_objcpp_sample(options.name, options.version)
+ elif options.type == 'library':
+ create_lib_objcpp_sample(options.name, options.version)
+ else:
+ raise RuntimeError(UNREACHABLE_CODE)
+ elif options.language == 'java':
+ if options.type == 'executable':
+ create_exe_java_sample(options.name, options.version)
+ elif options.type == 'library':
+ create_lib_java_sample(options.name, options.version)
+ else:
+ raise RuntimeError(UNREACHABLE_CODE)
else:
- raise RuntimeError('Unreachable code')
+ raise RuntimeError(UNREACHABLE_CODE)
print(info_message)
def autodetect_options(options, sample: bool = False):
+ '''
+ Here we autodetect options for args not passed in so don't have to
+ think about it.
+ '''
if not options.name:
options.name = Path().resolve().stem
if not re.match('[a-zA-Z_][a-zA-Z0-9]*', options.name) and sample:
@@ -101,7 +148,7 @@ def autodetect_options(options, sample: bool = False):
if not options.srcfiles:
srcfiles = []
for f in (f for f in Path().iterdir() if f.is_file()):
- if f.suffix in (['.cc', '.cpp', '.c', '.d', '.m', '.rs'] + FORTRAN_SUFFIXES):
+ if f.suffix in (['.c', '.cc', '.cpp', '.cs', '.cu', '.d', '.m', '.mm', '.rs', '.java'] + FORTRAN_SUFFIXES):
srcfiles.append(f)
if not srcfiles:
raise SystemExit('No recognizable source files found.\n'
@@ -111,11 +158,17 @@ def autodetect_options(options, sample: bool = False):
options.srcfiles = [Path(f) for f in options.srcfiles]
if not options.language:
for f in options.srcfiles:
+ if f.suffix == '.c':
+ options.language = 'c'
+ break
if f.suffix in ('.cc', '.cpp'):
options.language = 'cpp'
break
- if f.suffix == '.c':
- options.language = 'c'
+ if f.suffix in '.cs':
+ options.language = 'cs'
+ break
+ if f.suffix == '.cu':
+ options.language = 'cuda'
break
if f.suffix == '.d':
options.language = 'd'
@@ -129,66 +182,37 @@ def autodetect_options(options, sample: bool = False):
if f.suffix == '.m':
options.language = 'objc'
break
+ if f.suffix == '.mm':
+ options.language = 'objcpp'
+ break
+ if f.suffix == '.java':
+ options.language = 'java'
+ break
if not options.language:
raise SystemExit("Can't autodetect language, please specify it with -l.")
print("Detected language: " + options.language)
-
-meson_executable_template = '''project('{project_name}', '{language}',
- version : '{version}',
- default_options : [{default_options}])
-
-executable('{executable}',
- {sourcespec},{depspec}
- install : true)
-'''
-
-def create_meson_build(options):
- if options.type != 'executable':
- raise SystemExit('\nGenerating a meson.build file from existing sources is\n'
- 'supported only for project type "executable".\n'
- 'Run meson init in an empty directory to create a sample project.')
- default_options = ['warning_level=3']
- if options.language == 'cpp':
- # This shows how to set this very common option.
- default_options += ['cpp_std=c++14']
- # If we get a meson.build autoformatter one day, this code could
- # be simplified quite a bit.
- formatted_default_options = ', '.join("'{}'".format(x) for x in default_options)
- sourcespec = ',\n '.join("'{}'".format(x) for x in options.srcfiles)
- depspec = ''
- if options.deps:
- depspec = '\n dependencies : [\n '
- depspec += ',\n '.join("dependency('{}')".format(x)
- for x in options.deps.split(','))
- depspec += '],'
- content = meson_executable_template.format(project_name=options.name,
- language=options.language,
- version=options.version,
- executable=options.executable,
- sourcespec=sourcespec,
- depspec=depspec,
- default_options=formatted_default_options)
- open('meson.build', 'w').write(content)
- print('Generated meson.build file:\n\n' + content)
-
def add_arguments(parser):
- parser.add_argument("srcfiles", metavar="sourcefile", nargs="*",
- help="source files. default: all recognized files in current directory")
+ '''
+ Here we add args for that the user can passed when making a new
+ Meson project.
+ '''
+ parser.add_argument("srcfiles", metavar="sourcefile", nargs="*", help="source files. default: all recognized files in current directory")
parser.add_argument("-n", "--name", help="project name. default: name of current directory")
parser.add_argument("-e", "--executable", help="executable name. default: project name")
parser.add_argument("-d", "--deps", help="dependencies, comma-separated")
- parser.add_argument("-l", "--language", choices=['c', 'cpp', 'd', 'fortran', 'rust', 'objc'],
+ parser.add_argument("-l", "--language", choices=['c', 'cpp', 'cs', 'cuda', 'd', 'fortran', 'java', 'rust', 'objc', 'objcpp'],
help="project language. default: autodetected based on source files")
parser.add_argument("-b", "--build", help="build after generation", action='store_true')
parser.add_argument("--builddir", help="directory for build", default='build')
- parser.add_argument("-f", "--force", action="store_true",
- help="force overwrite of existing files and directories.")
- parser.add_argument('--type', default='executable',
- choices=['executable', 'library'])
+ parser.add_argument("-f", "--force", action="store_true", help="force overwrite of existing files and directories.")
+ parser.add_argument('--type', default='executable', choices=['executable', 'library'])
parser.add_argument('--version', default='0.1')
def run(options) -> int:
+ '''
+ Here we generate the new Meson sample project.
+ '''
if not glob('*'):
autodetect_options(options, sample=True)
if not options.language:
diff --git a/mesonbuild/templates/cstemplates.py b/mesonbuild/templates/cstemplates.py
new file mode 100644
index 0000000..baf2e8e
--- /dev/null
+++ b/mesonbuild/templates/cstemplates.py
@@ -0,0 +1,126 @@
+# Copyright 2019 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import re
+
+
+hello_cs_template = '''using System;
+
+public class {class_name} {{
+ const String PROJECT_NAME = "{project_name}";
+
+ static int Main(String[] args) {{
+ if (args.Length > 0) {{
+ System.Console.WriteLine(String.Format("{project_name} takes no arguments.."));
+ return 1;
+ }}
+ Console.WriteLine(String.Format("This is project {{0}}.", PROJECT_NAME));
+ return 0;
+ }}
+}}
+
+'''
+
+hello_cs_meson_template = '''project('{project_name}', 'cs',
+ version : '{version}',
+ default_options : ['warning_level=3'])
+
+exe = executable('{exe_name}', '{source_name}',
+ install : true)
+
+test('basic', exe)
+'''
+
+lib_cs_template = '''
+public class {class_name} {{
+ private const int number = 6;
+
+ public int get_number() {{
+ return number;
+ }}
+}}
+
+'''
+
+lib_cs_test_template = '''using System;
+
+public class {class_test} {{
+ static int Main(String[] args) {{
+ if (args.Length > 0) {{
+ System.Console.WriteLine("{project_name} takes no arguments..");
+ return 1;
+ }}
+ {class_name} c = new {class_name}();
+ Boolean result = true;
+ return result.CompareTo(c.get_number() != 6);
+ }}
+}}
+
+'''
+
+lib_cs_meson_template = '''project('{project_name}', 'cs',
+ version : '{version}',
+ default_options : ['warning_level=3'])
+
+stlib = shared_library('{lib_name}', '{source_file}',
+ install : true,
+)
+
+test_exe = executable('{test_exe_name}', '{test_source_file}',
+ link_with : stlib)
+test('{test_name}', test_exe)
+
+# Make this library usable as a Meson subproject.
+{ltoken}_dep = declare_dependency(
+ include_directories: include_directories('.'),
+ link_with : stlib)
+
+'''
+
+
+def create_exe_cs_sample(project_name, project_version):
+ lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower())
+ uppercase_token = lowercase_token.upper()
+ class_name = uppercase_token[0] + lowercase_token[1:]
+ source_name = uppercase_token[0] + lowercase_token[1:] + '.cs'
+ open(source_name, 'w').write(hello_cs_template.format(project_name=project_name,
+ class_name=class_name))
+ open('meson.build', 'w').write(hello_cs_meson_template.format(project_name=project_name,
+ exe_name=project_name,
+ source_name=source_name,
+ version=project_version))
+
+
+def create_lib_cs_sample(project_name, version):
+ lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower())
+ uppercase_token = lowercase_token.upper()
+ class_name = uppercase_token[0] + lowercase_token[1:]
+ class_test = uppercase_token[0] + lowercase_token[1:] + '_test'
+ project_test = lowercase_token + '_test'
+ lib_cs_name = uppercase_token[0] + lowercase_token[1:] + '.cs'
+ test_cs_name = uppercase_token[0] + lowercase_token[1:] + '_test.cs'
+ kwargs = {'utoken': uppercase_token,
+ 'ltoken': lowercase_token,
+ 'class_test': class_test,
+ 'class_name': class_name,
+ 'source_file': lib_cs_name,
+ 'test_source_file': test_cs_name,
+ 'test_exe_name': project_test,
+ 'project_name': project_name,
+ 'lib_name': lowercase_token,
+ 'test_name': lowercase_token,
+ 'version': version,
+ }
+ open(lib_cs_name, 'w').write(lib_cs_template.format(**kwargs))
+ open(test_cs_name, 'w').write(lib_cs_test_template.format(**kwargs))
+ open('meson.build', 'w').write(lib_cs_meson_template.format(**kwargs))
diff --git a/mesonbuild/templates/cudatemplates.py b/mesonbuild/templates/cudatemplates.py
new file mode 100644
index 0000000..d083fe8
--- /dev/null
+++ b/mesonbuild/templates/cudatemplates.py
@@ -0,0 +1,177 @@
+# Copyright 2019 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import re
+
+
+hello_cuda_template = '''#include <iostream>
+
+#define PROJECT_NAME "{project_name}"
+
+int main(int argc, char **argv) {{
+ if(argc != 1) {{
+ std::cout << argv[0] << "takes no arguments.\\n";
+ return 1;
+ }}
+ std::cout << "This is project " << PROJECT_NAME << ".\\n";
+ return 0;
+}}
+'''
+
+hello_cuda_meson_template = '''project('{project_name}', 'cpp',
+ version : '{version}',
+ default_options : ['warning_level=3',
+ 'cpp_std=c++14'])
+
+exe = executable('{exe_name}', '{source_name}',
+ install : true)
+
+test('basic', exe)
+'''
+
+lib_h_template = '''#pragma once
+#if defined _WIN32 || defined __CYGWIN__
+ #ifdef BUILDING_{utoken}
+ #define {utoken}_PUBLIC __declspec(dllexport)
+ #else
+ #define {utoken}_PUBLIC __declspec(dllimport)
+ #endif
+#else
+ #ifdef BUILDING_{utoken}
+ #define {utoken}_PUBLIC __attribute__ ((visibility ("default")))
+ #else
+ #define {utoken}_PUBLIC
+ #endif
+#endif
+
+namespace {namespace} {{
+
+class {utoken}_PUBLIC {class_name} {{
+
+public:
+ {class_name}();
+ int get_number() const;
+
+private:
+
+ int number;
+
+}};
+
+}}
+
+'''
+
+lib_cuda_template = '''#include <{header_file}>
+
+namespace {namespace} {{
+
+{class_name}::{class_name}() {{
+ number = 6;
+}}
+
+int {class_name}::get_number() const {{
+ return number;
+}}
+
+}}
+'''
+
+lib_cuda_test_template = '''#include <{header_file}>
+#include <iostream>
+
+int main(int argc, char **argv) {{
+ if(argc != 1) {{
+ std::cout << argv[0] << " takes no arguments.\\n";
+ return 1;
+ }}
+ {namespace}::{class_name} c;
+ return c.get_number() != 6;
+}}
+'''
+
+lib_cuda_meson_template = '''project('{project_name}', 'cuda',
+ version : '{version}',
+ default_options : ['warning_level=3'])
+
+# These arguments are only used to build the shared library
+# not the executables that use the library.
+lib_args = ['-DBUILDING_{utoken}']
+
+shlib = shared_library('{lib_name}', '{source_file}',
+ install : true,
+ cpp_args : lib_args,
+ gnu_symbol_visibility : 'hidden',
+)
+
+test_exe = executable('{test_exe_name}', '{test_source_file}',
+ link_with : shlib)
+test('{test_name}', test_exe)
+
+# Make this library usable as a Meson subproject.
+{ltoken}_dep = declare_dependency(
+ include_directories: include_directories('.'),
+ link_with : shlib)
+
+# Make this library usable from the system's
+# package manager.
+install_headers('{header_file}', subdir : '{header_dir}')
+
+pkg_mod = import('pkgconfig')
+pkg_mod.generate(
+ name : '{project_name}',
+ filebase : '{ltoken}',
+ description : 'Meson sample project.',
+ subdirs : '{header_dir}',
+ libraries : shlib,
+ version : '{version}',
+)
+'''
+
+
+def create_exe_cuda_sample(project_name, project_version):
+ lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower())
+ source_name = lowercase_token + '.cu'
+ open(source_name, 'w').write(hello_cuda_template.format(project_name=project_name))
+ open('meson.build', 'w').write(hello_cuda_meson_template.format(project_name=project_name,
+ exe_name=lowercase_token,
+ source_name=source_name,
+ version=project_version))
+
+
+def create_lib_cuda_sample(project_name, version):
+ lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower())
+ uppercase_token = lowercase_token.upper()
+ class_name = uppercase_token[0] + lowercase_token[1:]
+ namespace = lowercase_token
+ lib_h_name = lowercase_token + '.h'
+ lib_cuda_name = lowercase_token + '.cu'
+ test_cuda_name = lowercase_token + '_test.cu'
+ kwargs = {'utoken': uppercase_token,
+ 'ltoken': lowercase_token,
+ 'header_dir': lowercase_token,
+ 'class_name': class_name,
+ 'namespace': namespace,
+ 'header_file': lib_h_name,
+ 'source_file': lib_cuda_name,
+ 'test_source_file': test_cuda_name,
+ 'test_exe_name': lowercase_token,
+ 'project_name': project_name,
+ 'lib_name': lowercase_token,
+ 'test_name': lowercase_token,
+ 'version': version,
+ }
+ open(lib_h_name, 'w').write(lib_h_template.format(**kwargs))
+ open(lib_cuda_name, 'w').write(lib_cuda_template.format(**kwargs))
+ open(test_cuda_name, 'w').write(lib_cuda_test_template.format(**kwargs))
+ open('meson.build', 'w').write(lib_cuda_meson_template.format(**kwargs))
diff --git a/mesonbuild/templates/javatemplates.py b/mesonbuild/templates/javatemplates.py
new file mode 100644
index 0000000..e8a8c15
--- /dev/null
+++ b/mesonbuild/templates/javatemplates.py
@@ -0,0 +1,129 @@
+# Copyright 2019 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import re
+
+
+hello_java_template = '''
+
+public class {class_name} {{
+ final static String PROJECT_NAME = "{project_name}";
+
+ public static void main (String args[]) {{
+ if(args.length != 0) {{
+ System.out.println(args + " takes no arguments.");
+ System.exit(0);
+ }}
+ System.out.println("This is project " + PROJECT_NAME + ".");
+ System.exit(0);
+ }}
+}}
+
+'''
+
+hello_java_meson_template = '''project('{project_name}', 'java',
+ version : '{version}',
+ default_options : ['warning_level=3'])
+
+exe = jar('{exe_name}', '{source_name}',
+ main_class : '{exe_name}',
+ install : true)
+
+test('basic', exe)
+'''
+
+lib_java_template = '''
+
+public class {class_name} {{
+ final static int number = 6;
+
+ public final int get_number() {{
+ return number;
+ }}
+}}
+
+'''
+
+lib_java_test_template = '''
+
+public class {class_test} {{
+ public static void main (String args[]) {{
+ if(args.length != 0) {{
+ System.out.println(args + " takes no arguments.");
+ System.exit(1);
+ }}
+
+ {class_name} c = new {class_name}();
+ Boolean result = true;
+ System.exit(result.compareTo(c.get_number() != 6));
+ }}
+}}
+
+'''
+
+lib_java_meson_template = '''project('{project_name}', 'java',
+ version : '{version}',
+ default_options : ['warning_level=3'])
+
+jarlib = jar('{class_name}', '{source_file}',
+ main_class : '{class_name}',
+ install : true,
+)
+
+test_jar = jar('{class_test}', '{test_source_file}',
+ main_class : '{class_test}',
+ link_with : jarlib)
+test('{test_name}', test_jar)
+
+# Make this library usable as a Meson subproject.
+{ltoken}_dep = declare_dependency(
+ include_directories: include_directories('.'),
+ link_with : jarlib)
+'''
+
+
+def create_exe_java_sample(project_name, project_version):
+ lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower())
+ uppercase_token = lowercase_token.upper()
+ class_name = uppercase_token[0] + lowercase_token[1:]
+ source_name = uppercase_token[0] + lowercase_token[1:] + '.java'
+ open(source_name, 'w').write(hello_java_template.format(project_name=project_name,
+ class_name=class_name))
+ open('meson.build', 'w').write(hello_java_meson_template.format(project_name=project_name,
+ exe_name=class_name,
+ source_name=source_name,
+ version=project_version))
+
+
+def create_lib_java_sample(project_name, version):
+ lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower())
+ uppercase_token = lowercase_token.upper()
+ class_name = uppercase_token[0] + lowercase_token[1:]
+ class_test = uppercase_token[0] + lowercase_token[1:] + '_test'
+ lib_java_name = uppercase_token[0] + lowercase_token[1:] + '.java'
+ test_java_name = uppercase_token[0] + lowercase_token[1:] + '_test.java'
+ kwargs = {'utoken': uppercase_token,
+ 'ltoken': lowercase_token,
+ 'class_test': class_test,
+ 'class_name': class_name,
+ 'source_file': lib_java_name,
+ 'test_source_file': test_java_name,
+ 'test_exe_name': lowercase_token,
+ 'project_name': project_name,
+ 'lib_name': lowercase_token,
+ 'test_name': lowercase_token,
+ 'version': version,
+ }
+ open(lib_java_name, 'w').write(lib_java_template.format(**kwargs))
+ open(test_java_name, 'w').write(lib_java_test_template.format(**kwargs))
+ open('meson.build', 'w').write(lib_java_meson_template.format(**kwargs))
diff --git a/mesonbuild/templates/mesontemplates.py b/mesonbuild/templates/mesontemplates.py
new file mode 100644
index 0000000..f9dd442
--- /dev/null
+++ b/mesonbuild/templates/mesontemplates.py
@@ -0,0 +1,51 @@
+# Copyright 2019 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+meson_executable_template = '''project('{project_name}', '{language}',
+ version : '{version}',
+ default_options : [{default_options}])
+
+executable('{executable}',
+ {sourcespec},{depspec}
+ install : true)
+'''
+
+def create_meson_build(options):
+ if options.type != 'executable':
+ raise SystemExit('\nGenerating a meson.build file from existing sources is\n'
+ 'supported only for project type "executable".\n'
+ 'Run meson init in an empty directory to create a sample project.')
+ default_options = ['warning_level=3']
+ if options.language == 'cpp':
+ # This shows how to set this very common option.
+ default_options += ['cpp_std=c++14']
+ # If we get a meson.build autoformatter one day, this code could
+ # be simplified quite a bit.
+ formatted_default_options = ', '.join("'{}'".format(x) for x in default_options)
+ sourcespec = ',\n '.join("'{}'".format(x) for x in options.srcfiles)
+ depspec = ''
+ if options.deps:
+ depspec = '\n dependencies : [\n '
+ depspec += ',\n '.join("dependency('{}')".format(x)
+ for x in options.deps.split(','))
+ depspec += '],'
+ content = meson_executable_template.format(project_name=options.name,
+ language=options.language,
+ version=options.version,
+ executable=options.executable,
+ sourcespec=sourcespec,
+ depspec=depspec,
+ default_options=formatted_default_options)
+ open('meson.build', 'w').write(content)
+ print('Generated meson.build file:\n\n' + content)
diff --git a/mesonbuild/templates/objcpptemplates.py b/mesonbuild/templates/objcpptemplates.py
new file mode 100644
index 0000000..329a568
--- /dev/null
+++ b/mesonbuild/templates/objcpptemplates.py
@@ -0,0 +1,156 @@
+# Copyright 2019 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import re
+
+
+lib_h_template = '''#pragma once
+#if defined _WIN32 || defined __CYGWIN__
+ #ifdef BUILDING_{utoken}
+ #define {utoken}_PUBLIC __declspec(dllexport)
+ #else
+ #define {utoken}_PUBLIC __declspec(dllimport)
+ #endif
+#else
+ #ifdef BUILDING_{utoken}
+ #define {utoken}_PUBLIC __attribute__ ((visibility ("default")))
+ #else
+ #define {utoken}_PUBLIC
+ #endif
+#endif
+
+int {utoken}_PUBLIC {function_name}();
+
+'''
+
+lib_objcpp_template = '''#import <{header_file}>
+
+/* This function will not be exported and is not
+ * directly callable by users of this library.
+ */
+int internal_function() {{
+ return 0;
+}}
+
+int {function_name}() {{
+ return internal_function();
+}}
+'''
+
+lib_objcpp_test_template = '''#import <{header_file}>
+#import <iostream>
+
+int main(int argc, char **argv) {{
+ if(argc != 1) {{
+ std::cout << argv[0] << " takes no arguments." << std::endl;
+ return 1;
+ }}
+ return {function_name}();
+}}
+'''
+
+lib_objcpp_meson_template = '''project('{project_name}', 'objcpp',
+ version : '{version}',
+ default_options : ['warning_level=3'])
+
+# These arguments are only used to build the shared library
+# not the executables that use the library.
+lib_args = ['-DBUILDING_{utoken}']
+
+shlib = shared_library('{lib_name}', '{source_file}',
+ install : true,
+ objcpp_args : lib_args,
+ gnu_symbol_visibility : 'hidden',
+)
+
+test_exe = executable('{test_exe_name}', '{test_source_file}',
+ link_with : shlib)
+test('{test_name}', test_exe)
+
+# Make this library usable as a Meson subproject.
+{ltoken}_dep = declare_dependency(
+ include_directories: include_directories('.'),
+ link_with : shlib)
+
+# Make this library usable from the system's
+# package manager.
+install_headers('{header_file}', subdir : '{header_dir}')
+
+pkg_mod = import('pkgconfig')
+pkg_mod.generate(
+ name : '{project_name}',
+ filebase : '{ltoken}',
+ description : 'Meson sample project.',
+ subdirs : '{header_dir}',
+ libraries : shlib,
+ version : '{version}',
+)
+'''
+
+hello_objcpp_template = '''#import <iostream>
+
+#define PROJECT_NAME "{project_name}"
+
+int main(int argc, char **argv) {{
+ if(argc != 1) {{
+ std::cout << argv[0] << " takes no arguments." << std::endl;
+ return 1;
+ }}
+ std::cout << "This is project " << PROJECT_NAME << "." << std::endl;
+ return 0;
+}}
+'''
+
+hello_objcpp_meson_template = '''project('{project_name}', 'objcpp',
+ version : '{version}',
+ default_options : ['warning_level=3'])
+
+exe = executable('{exe_name}', '{source_name}',
+ install : true)
+
+test('basic', exe)
+'''
+
+def create_exe_objcpp_sample(project_name, project_version):
+ lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower())
+ source_name = lowercase_token + '.mm'
+ open(source_name, 'w').write(hello_objcpp_template.format(project_name=project_name))
+ open('meson.build', 'w').write(hello_objcpp_meson_template.format(project_name=project_name,
+ exe_name=lowercase_token,
+ source_name=source_name,
+ version=project_version))
+
+def create_lib_objcpp_sample(project_name, version):
+ lowercase_token = re.sub(r'[^a-z0-9]', '_', project_name.lower())
+ uppercase_token = lowercase_token.upper()
+ function_name = lowercase_token[0:3] + '_func'
+ lib_h_name = lowercase_token + '.h'
+ lib_objcpp_name = lowercase_token + '.mm'
+ test_objcpp_name = lowercase_token + '_test.mm'
+ kwargs = {'utoken': uppercase_token,
+ 'ltoken': lowercase_token,
+ 'header_dir': lowercase_token,
+ 'function_name': function_name,
+ 'header_file': lib_h_name,
+ 'source_file': lib_objcpp_name,
+ 'test_source_file': test_objcpp_name,
+ 'test_exe_name': lowercase_token,
+ 'project_name': project_name,
+ 'lib_name': lowercase_token,
+ 'test_name': lowercase_token,
+ 'version': version,
+ }
+ open(lib_h_name, 'w').write(lib_h_template.format(**kwargs))
+ open(lib_objcpp_name, 'w').write(lib_objcpp_template.format(**kwargs))
+ open(test_objcpp_name, 'w').write(lib_objcpp_test_template.format(**kwargs))
+ open('meson.build', 'w').write(lib_objcpp_meson_template.format(**kwargs))
diff --git a/run_project_tests.py b/run_project_tests.py
index 2288abf..2d18ee0 100755
--- a/run_project_tests.py
+++ b/run_project_tests.py
@@ -76,6 +76,21 @@ class TestResult:
self.testtime = testtime
+class TestDef:
+ def __init__(self, path: Path, name: T.Optional[str], args: T.List[str], skip: bool = False):
+ self.path = path
+ self.name = name
+ self.args = args
+ self.skip = skip
+
+ def __repr__(self) -> str:
+ return '<{}: {:<48} [{}: {}] -- {}>'.format(type(self).__name__, str(self.path), self.name, self.args, self.skip)
+
+ def display_name(self) -> str:
+ if self.name:
+ return '{} ({})'.format(self.path.as_posix(), self.name)
+ return self.path.as_posix()
+
class AutoDeletedDir:
def __init__(self, d):
self.dir = d
@@ -343,17 +358,19 @@ def parse_test_args(testdir):
# Build directory name must be the same so Ccache works over
# consecutive invocations.
-def create_deterministic_builddir(src_dir):
+def create_deterministic_builddir(src_dir, name):
import hashlib
+ if name:
+ src_dir += name
rel_dirname = 'b ' + hashlib.sha256(src_dir.encode(errors='ignore')).hexdigest()[0:10]
os.mkdir(rel_dirname)
abs_pathname = os.path.join(os.getcwd(), rel_dirname)
return abs_pathname
-def run_test(skipped, testdir, extra_args, compiler, backend, flags, commands, should_fail):
+def run_test(skipped, testdir, name, extra_args, compiler, backend, flags, commands, should_fail):
if skipped:
return None
- with AutoDeletedDir(create_deterministic_builddir(testdir)) as build_dir:
+ with AutoDeletedDir(create_deterministic_builddir(testdir, name)) as build_dir:
with AutoDeletedDir(tempfile.mkdtemp(prefix='i ', dir=os.getcwd())) as install_dir:
try:
return _run_test(testdir, build_dir, install_dir, extra_args, compiler, backend, flags, commands, should_fail)
@@ -475,13 +492,56 @@ def _run_test(testdir, test_build_dir, install_dir, extra_args, compiler, backen
return TestResult(validate_install(testdir, install_dir, compiler, builddata.environment),
BuildStep.validate, stdo, stde, mesonlog, cicmds, gen_time, build_time, test_time)
-def gather_tests(testdir: Path) -> T.List[Path]:
- test_names = [t.name for t in testdir.glob('*') if t.is_dir()]
- test_names = [t for t in test_names if not t.startswith('.')] # Filter non-tests files (dot files, etc)
- test_nums = [(int(t.split()[0]), t) for t in test_names]
- test_nums.sort()
- tests = [testdir / t[1] for t in test_nums]
- return tests
+def gather_tests(testdir: Path) -> T.List[TestDef]:
+ tests = [t.name for t in testdir.glob('*') if t.is_dir()]
+ tests = [t for t in tests if not t.startswith('.')] # Filter non-tests files (dot files, etc)
+ tests = [TestDef(testdir / t, None, []) for t in tests]
+ all_tests = []
+ for t in tests:
+ matrix_file = t.path / 'test_matrix.json'
+ if not matrix_file.is_file():
+ all_tests += [t]
+ continue
+
+ # Build multiple tests from matrix definition
+ opt_list = [] # type: T.List[T.List[T.Tuple[str, bool]]]
+ matrix = json.loads(matrix_file.read_text())
+ assert "options" in matrix
+ for key, val in matrix["options"].items():
+ assert isinstance(val, list)
+ tmp_opts = [] # type: T.List[T.Tuple[str, bool]]
+ for i in val:
+ assert isinstance(i, dict)
+ assert "val" in i
+ skip = False
+
+ # Skip the matrix entry if environment variable is present
+ if 'skip_on_env' in i:
+ for env in i['skip_on_env']:
+ if env in os.environ:
+ skip = True
+
+ tmp_opts += [('{}={}'.format(key, i['val']), skip)]
+
+ if opt_list:
+ new_opt_list = [] # type: T.List[T.List[T.Tuple[str, bool]]]
+ for i in opt_list:
+ for j in tmp_opts:
+ new_opt_list += [[*i, j]]
+ opt_list = new_opt_list
+ else:
+ opt_list = [[x] for x in tmp_opts]
+
+ for i in opt_list:
+ name = ' '.join([x[0] for x in i])
+ opts = ['-D' + x[0] for x in i]
+ skip = any([x[1] for x in i])
+ all_tests += [TestDef(t.path, name, opts, skip)]
+
+ all_tests = [(int(t.path.name.split()[0]), t.name or '', t) for t in all_tests]
+ all_tests.sort()
+ all_tests = [t[2] for t in all_tests]
+ return all_tests
def have_d_compiler():
if shutil.which("ldc2"):
@@ -636,7 +696,7 @@ def should_skip_rust(backend: Backend) -> bool:
return True
return False
-def detect_tests_to_run(only: T.List[str]) -> T.List[T.Tuple[str, T.List[Path], bool]]:
+def detect_tests_to_run(only: T.List[str]) -> T.List[T.Tuple[str, T.List[TestDef], bool]]:
"""
Parameters
----------
@@ -645,7 +705,7 @@ def detect_tests_to_run(only: T.List[str]) -> T.List[T.Tuple[str, T.List[Path],
Returns
-------
- gathered_tests: list of tuple of str, list of pathlib.Path, bool
+ gathered_tests: list of tuple of str, list of TestDef, bool
tests to run
"""
@@ -695,7 +755,7 @@ def detect_tests_to_run(only: T.List[str]) -> T.List[T.Tuple[str, T.List[Path],
gathered_tests = [(name, gather_tests(Path('test cases', subdir)), skip) for name, subdir, skip in all_tests]
return gathered_tests
-def run_tests(all_tests: T.List[T.Tuple[str, T.List[Path], bool]],
+def run_tests(all_tests: T.List[T.Tuple[str, T.List[TestDef], bool]],
log_name_base: str, failfast: bool,
extra_args: T.List[str]) -> T.Tuple[int, int, int]:
global logfile
@@ -704,7 +764,7 @@ def run_tests(all_tests: T.List[T.Tuple[str, T.List[Path], bool]],
logfile = lf
return _run_tests(all_tests, log_name_base, failfast, extra_args)
-def _run_tests(all_tests: T.List[T.Tuple[str, T.List[Path], bool]],
+def _run_tests(all_tests: T.List[T.Tuple[str, T.List[TestDef], bool]],
log_name_base: str, failfast: bool,
extra_args: T.List[str]) -> T.Tuple[int, int, int]:
global stop, executor, futures, system_compiler
@@ -746,8 +806,10 @@ def _run_tests(all_tests: T.List[T.Tuple[str, T.List[Path], bool]],
for t in test_cases:
# Jenkins screws us over by automatically sorting test cases by name
# and getting it wrong by not doing logical number sorting.
- (testnum, testbase) = t.name.split(' ', 1)
+ (testnum, testbase) = t.path.name.split(' ', 1)
testname = '%.3d %s' % (int(testnum), testbase)
+ if t.name:
+ testname += ' ({})'.format(t.name)
should_fail = False
suite_args = []
if name.startswith('failing'):
@@ -756,7 +818,7 @@ def _run_tests(all_tests: T.List[T.Tuple[str, T.List[Path], bool]],
suite_args = ['--fatal-meson-warnings']
should_fail = name.split('warning-')[1]
- result = executor.submit(run_test, skipped, t.as_posix(), extra_args + suite_args,
+ result = executor.submit(run_test, skipped or t.skip, t.path.as_posix(), t.name, extra_args + suite_args + t.args,
system_compiler, backend, backend_flags, commands, should_fail)
futures.append((testname, t, result))
for (testname, t, result) in futures:
@@ -765,8 +827,8 @@ def _run_tests(all_tests: T.List[T.Tuple[str, T.List[Path], bool]],
result = result.result()
except CancelledError:
continue
- if (result is None) or (('MESON_SKIP_TEST' in result.stdo) and (skippable(name, t.as_posix()))):
- print(yellow('Skipping:'), t.as_posix())
+ if (result is None) or (('MESON_SKIP_TEST' in result.stdo) and (skippable(name, t.path.as_posix()))):
+ print(yellow('Skipping:'), t.display_name())
current_test = ET.SubElement(current_suite, 'testcase', {'name': testname,
'classname': name})
ET.SubElement(current_test, 'skipped', {})
@@ -774,7 +836,7 @@ def _run_tests(all_tests: T.List[T.Tuple[str, T.List[Path], bool]],
else:
without_install = "" if len(install_commands) > 0 else " (without install)"
if result.msg != '':
- print(red('Failed test{} during {}: {!r}'.format(without_install, result.step.name, t.as_posix())))
+ print(red('Failed test{} during {}: {!r}'.format(without_install, result.step.name, t.display_name())))
print('Reason:', result.msg)
failing_tests += 1
if result.step == BuildStep.configure and result.mlog != no_meson_log_msg:
@@ -798,13 +860,13 @@ def _run_tests(all_tests: T.List[T.Tuple[str, T.List[Path], bool]],
for (_, _, res) in futures:
res.cancel()
else:
- print('Succeeded test%s: %s' % (without_install, t.as_posix()))
+ print('Succeeded test%s: %s' % (without_install, t.display_name()))
passing_tests += 1
conf_time += result.conftime
build_time += result.buildtime
test_time += result.testtime
total_time = conf_time + build_time + test_time
- log_text_file(logfile, t, result.stdo, result.stde)
+ log_text_file(logfile, t.path, result.stdo, result.stde)
current_test = ET.SubElement(current_suite, 'testcase', {'name': testname,
'classname': name,
'time': '%.3f' % total_time})
@@ -994,7 +1056,7 @@ if __name__ == '__main__':
except UnicodeError:
print(l.encode('ascii', errors='replace').decode(), '\n')
for name, dirs, _ in all_tests:
- dir_names = (x.name for x in dirs)
+ dir_names = list(set(x.path.name for x in dirs))
for k, g in itertools.groupby(dir_names, key=lambda x: x.split()[0]):
tests = list(g)
if len(tests) != 1:
diff --git a/run_unittests.py b/run_unittests.py
index 9acdca9..642a05f 100755
--- a/run_unittests.py
+++ b/run_unittests.py
@@ -3125,15 +3125,28 @@ int main(int argc, char **argv) {
except EnvironmentException:
pass
try:
+ env.detect_cs_compiler(MachineChoice.HOST)
+ langs.append('cs')
+ except EnvironmentException:
+ pass
+ try:
env.detect_d_compiler(MachineChoice.HOST)
langs.append('d')
except EnvironmentException:
pass
try:
+ env.detect_java_compiler(MachineChoice.HOST)
+ langs.append('java')
+ except EnvironmentException:
+ pass
+ try:
+ env.detect_cuda_compiler(MachineChoice.HOST)
+ langs.append('cuda')
+ except EnvironmentException:
+ pass
+ try:
env.detect_fortran_compiler(MachineChoice.HOST)
- if is_windows() or platform.machine().lower() != 'e2k':
- # Elbrus Fortran compiler can't generate debug information
- langs.append('fortran')
+ langs.append('fortran')
except EnvironmentException:
pass
try:
@@ -3141,6 +3154,11 @@ int main(int argc, char **argv) {
langs.append('objc')
except EnvironmentException:
pass
+ try:
+ env.detect_objcpp_compiler(MachineChoice.HOST)
+ langs.append('objcpp')
+ except EnvironmentException:
+ pass
# FIXME: omitting rust as Windows AppVeyor CI finds Rust but doesn't link correctly
for lang in langs:
diff --git a/test cases/cmake/16 threads/meson.build b/test cases/cmake/16 threads/meson.build
index d7ade1c..5efd73e 100644
--- a/test cases/cmake/16 threads/meson.build
+++ b/test cases/cmake/16 threads/meson.build
@@ -1,8 +1,12 @@
project('cmMod', ['c', 'cpp'])
-cm = import('cmake')
-cmMod = cm.subproject('cmMod')
-cmModDep = cmMod.dependency('cmModLib')
+cm = import('cmake')
+cmOpts = ['-DUSE_PTHREAD=@0@'.format(get_option('use_pthread'))]
+cmMod = cm.subproject('cmMod', cmake_options: cmOpts)
+cmModDep1 = cmMod.dependency('cmModLib')
+cmModDep2 = cmMod.dependency('cmModLib_shared')
-exe1 = executable('exe1', ['main.cpp'], dependencies: [cmModDep])
+exe1 = executable('exe1', ['main.cpp'], dependencies: [cmModDep1])
+exe2 = executable('exe2', ['main.cpp'], dependencies: [cmModDep2])
test('exe1_OK', exe1)
+test('exe2_OK', exe2)
diff --git a/test cases/cmake/16 threads/meson_options.txt b/test cases/cmake/16 threads/meson_options.txt
new file mode 100644
index 0000000..1fd9068
--- /dev/null
+++ b/test cases/cmake/16 threads/meson_options.txt
@@ -0,0 +1 @@
+option('use_pthread', type: 'combo', choices: ['ON', 'OFF', 'NOT_SET'], value: 'ON')
diff --git a/test cases/cmake/16 threads/subprojects/cmMod/CMakeLists.txt b/test cases/cmake/16 threads/subprojects/cmMod/CMakeLists.txt
index 37d32c1..442a60e 100644
--- a/test cases/cmake/16 threads/subprojects/cmMod/CMakeLists.txt
+++ b/test cases/cmake/16 threads/subprojects/cmMod/CMakeLists.txt
@@ -3,7 +3,13 @@ cmake_minimum_required(VERSION 3.5)
project(cmMod CXX)
set (CMAKE_CXX_STANDARD 14)
+if(NOT USE_PTHREAD STREQUAL NOT_SET)
+ set(THREADS_PREFER_PTHREAD_FLAG ${USE_PTHREAD})
+endif()
find_package(Threads)
add_library(cmModLib STATIC cmMod.cpp)
target_link_libraries(cmModLib PRIVATE Threads::Threads)
+
+add_library(cmModLib_shared SHARED cmMod.cpp)
+target_link_libraries(cmModLib_shared PUBLIC Threads::Threads)
diff --git a/test cases/cmake/16 threads/subprojects/cmMod/cmMod.hpp b/test cases/cmake/16 threads/subprojects/cmMod/cmMod.hpp
index 1c85a8b..81c5ec8 100644
--- a/test cases/cmake/16 threads/subprojects/cmMod/cmMod.hpp
+++ b/test cases/cmake/16 threads/subprojects/cmMod/cmMod.hpp
@@ -1,6 +1,17 @@
#pragma once
-class CmMod {
+#if defined _WIN32 || defined __CYGWIN__
+#define DLL_PUBLIC __declspec(dllexport)
+#else
+#if defined __GNUC__
+#define DLL_PUBLIC __attribute__((visibility("default")))
+#else
+#pragma message("Compiler does not support symbol visibility.")
+#define DLL_PUBLIC
+#endif
+#endif
+
+class DLL_PUBLIC CmMod {
private:
int num = 0;
diff --git a/test cases/cmake/16 threads/test_matrix.json b/test cases/cmake/16 threads/test_matrix.json
new file mode 100644
index 0000000..1c2c545
--- /dev/null
+++ b/test cases/cmake/16 threads/test_matrix.json
@@ -0,0 +1,9 @@
+{
+ "options": {
+ "use_pthread": [
+ { "val": "ON" },
+ { "val": "OFF" },
+ { "val": "NOT_SET" }
+ ]
+ }
+}
generated by cgit v1.1 at 2025-07-10 20:45:58 +0000