Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
The Meson Build System http://mesonbuild.com/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6956 Commits
76 Branches
171 Tags
74 MiB
Tag: Branch: Tree: 3fc8a0dc41
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3fc8a0dc41'
${ noResults }
meson/test cases/linuxlike/5 dependency versions/meson.build

110 lines
5.1 KiB
Raw Normal View History Unescape

Detect Boost libraries primarily with the C++ compiler's find_library.
8 years ago
project('dep versions', 'c', 'cpp')
Add various tests for versioned dependency checking Both pkg-config and subproject-based dependencies Linux-like because we need zlib for the tests to work
9 years ago
# Find external dependency without version
zlib = dependency('zlib')
# Find external dependency with version
zlibver = dependency('zlib', version : '>1.0')
assert(zlib.version() == zlibver.version(), 'zlib versions did not match!')
# Find external dependency with conflicting version
interpreter: Add a type_name method to DependencyHolder And remove the InternalDependencyHolder class. In some cases we need to know the type of dependency we are dealing with. For example in GStreamer if the dependency is not an internal one, then we need to get some env var from pkg-config to know where to find some plugins necessary to run some tests.
8 years ago
assert(zlib.type_name() == 'pkgconfig', 'zlib should be of type "pkgconfig" not ' + zlib.type_name())
Add various tests for versioned dependency checking Both pkg-config and subproject-based dependencies Linux-like because we need zlib for the tests to work
9 years ago
zlibver = dependency('zlib', version : '<1.0', required : false)
assert(zlibver.found() == false, 'zlib <1.0 should not be found!')
Allow many version conditions for pkg-config deps Sometimes we want to restrict the acceptable versions to a list of versions, or a smallest-version + largest-version, or both. For instance, GStreamer's opencv plugin is only compatible with 3.1.0 >= opencv >= 2.3.0
8 years ago
# Find external dependencies with various version restrictions
dependency('zlib', version : '>=1.0')
dependency('zlib', version : '<=9999')
dependency('zlib', version : '=' + zlib.version())
# Find external dependencies with multiple version restrictions
dependency('zlib', version : ['>=1.0', '<=9999'])
if dependency('zlib', version : ['<=1.0', '>=9999', '=' + zlib.version()], required : false).found()
error('zlib <=1.0 >=9999 should not have been found')
endif
Completely overhaul caching of external dependencies The old caching was a mess of spaghetti code layered over pasta code. The new code is well-commented, is clear about what it's trying to do, and uses a blacklist of keyword arguments instead of a whitelist while generating identifiers for dep caching which makes it much more robust for future changes. The only side-effect of forgetting about a new keyword argument would be that the dependency would not be cached unless the values of that keyword arguments were the same in the cached and new dependency. There are also more tests which identify scenarios that were broken earlier.
8 years ago
# Test that a versionless zlib is found after not finding an optional zlib dep with version reqs
zlibopt = dependency('zlib', required : false)
assert(zlibopt.found() == true, 'zlib not found')
Add a test for the broken cached version compare https://github.com/mesonbuild/meson/pull/610
9 years ago
# Test https://github.com/mesonbuild/meson/pull/610
dependency('somebrokenlib', version : '>=2.0', required : false)
dependency('somebrokenlib', version : '>=1.0', required : false)
Completely overhaul caching of external dependencies The old caching was a mess of spaghetti code layered over pasta code. The new code is well-commented, is clear about what it's trying to do, and uses a blacklist of keyword arguments instead of a whitelist while generating identifiers for dep caching which makes it much more robust for future changes. The only side-effect of forgetting about a new keyword argument would be that the dependency would not be cached unless the values of that keyword arguments were the same in the cached and new dependency. There are also more tests which identify scenarios that were broken earlier.
8 years ago
# Search for an external dependency that won't be found, but must later be
# found via fallbacks
somelibnotfound = dependency('somelib', required : false)
assert(somelibnotfound.found() == false, 'somelibnotfound was found?')
Add various tests for versioned dependency checking Both pkg-config and subproject-based dependencies Linux-like because we need zlib for the tests to work
9 years ago
# Find internal dependency without version
somelibver = dependency('somelib',
fallback : ['somelibnover', 'some_dep'])
interpreter: Add a type_name method to DependencyHolder And remove the InternalDependencyHolder class. In some cases we need to know the type of dependency we are dealing with. For example in GStreamer if the dependency is not an internal one, then we need to get some env var from pkg-config to know where to find some plugins necessary to run some tests.
8 years ago
assert(somelibver.type_name() == 'internal', 'somelibver should be of type "internal", not ' + somelibver.type_name())
Add various tests for versioned dependency checking Both pkg-config and subproject-based dependencies Linux-like because we need zlib for the tests to work
9 years ago
# Find an internal dependency again with the same name and a specific version
somelib = dependency('somelib',
version : '== 0.1',
fallback : ['somelib', 'some_dep'])
subproject handling: add two tests
7 years ago
# Find an internal dependency again even if required = false
somelib_reqfalse = dependency('somelib',
required: false,
fallback : ['somelib', 'some_dep'])
assert(somelib_reqfalse.found(), 'somelib should have been found')
Add various tests for versioned dependency checking Both pkg-config and subproject-based dependencies Linux-like because we need zlib for the tests to work
9 years ago
# Find an internal dependency again with the same name and incompatible version
somelibver = dependency('somelib',
version : '>= 0.3',
fallback : ['somelibver', 'some_dep'])
Completely overhaul caching of external dependencies The old caching was a mess of spaghetti code layered over pasta code. The new code is well-commented, is clear about what it's trying to do, and uses a blacklist of keyword arguments instead of a whitelist while generating identifiers for dep caching which makes it much more robust for future changes. The only side-effect of forgetting about a new keyword argument would be that the dependency would not be cached unless the values of that keyword arguments were the same in the cached and new dependency. There are also more tests which identify scenarios that were broken earlier.
8 years ago
# Find somelib again, but with a fallback that will fail because subproject does not exist
Add various tests for versioned dependency checking Both pkg-config and subproject-based dependencies Linux-like because we need zlib for the tests to work
9 years ago
somelibfail = dependency('somelib',
version : '>= 0.2',
required : false,
fallback : ['somelibfail', 'some_dep'])
assert(somelibfail.found() == false, 'somelibfail found via wrong fallback')
Completely overhaul caching of external dependencies The old caching was a mess of spaghetti code layered over pasta code. The new code is well-commented, is clear about what it's trying to do, and uses a blacklist of keyword arguments instead of a whitelist while generating identifiers for dep caching which makes it much more robust for future changes. The only side-effect of forgetting about a new keyword argument would be that the dependency would not be cached unless the values of that keyword arguments were the same in the cached and new dependency. There are also more tests which identify scenarios that were broken earlier.
8 years ago
# Find somelib again, but with a fallback that will fail because dependency does not exist
somefail_dep = dependency('somelib',
version : '>= 0.2',
required : false,
fallback : ['somelib', 'somefail_dep'])
assert(somefail_dep.found() == false, 'somefail_dep found via wrong fallback')
Try using already setup fallback subprojects before using native dependency In the case the main project set a subproject for a dependency another subprojects uses, that other subproject should rather use the first subproject rather that using native dependency. For example in gst-all we set all GStreamer modules as subprojects and, gst-plugins-base is set after gstreamer core, and we want gst-plugins-base to always use GStreamer core from the subproject and not the possibly avalaible native one.
8 years ago
Completely overhaul caching of external dependencies The old caching was a mess of spaghetti code layered over pasta code. The new code is well-commented, is clear about what it's trying to do, and uses a blacklist of keyword arguments instead of a whitelist while generating identifiers for dep caching which makes it much more robust for future changes. The only side-effect of forgetting about a new keyword argument would be that the dependency would not be cached unless the values of that keyword arguments were the same in the cached and new dependency. There are also more tests which identify scenarios that were broken earlier.
8 years ago
# Fallback should only be used if the primary was not found
fallbackzlib_dep = dependency('zlib',
fallback : ['somelib', 'fakezlib_dep'])
assert(fallbackzlib_dep.type_name() == 'pkgconfig', 'fallbackzlib_dep should be of type "pkgconfig", not ' + fallbackzlib_dep.type_name())
dependencies: Fix two more edge-cases in dependency searching Includes tests for both of them.
8 years ago
# Check that the above dependency was pkgconfig because the fallback wasn't
# checked, not because the fallback didn't work
Completely overhaul caching of external dependencies The old caching was a mess of spaghetti code layered over pasta code. The new code is well-commented, is clear about what it's trying to do, and uses a blacklist of keyword arguments instead of a whitelist while generating identifiers for dep caching which makes it much more robust for future changes. The only side-effect of forgetting about a new keyword argument would be that the dependency would not be cached unless the values of that keyword arguments were the same in the cached and new dependency. There are also more tests which identify scenarios that were broken earlier.
8 years ago
fakezlib_dep = dependency('fakezlib',
Try using already setup fallback subprojects before using native dependency In the case the main project set a subproject for a dependency another subprojects uses, that other subproject should rather use the first subproject rather that using native dependency. For example in gst-all we set all GStreamer modules as subprojects and, gst-plugins-base is set after gstreamer core, and we want gst-plugins-base to always use GStreamer core from the subproject and not the possibly avalaible native one.
8 years ago
fallback : ['somelib', 'fakezlib_dep'])
assert(fakezlib_dep.type_name() == 'internal', 'fakezlib_dep should be of type "internal", not ' + fakezlib_dep.type_name())
Add get_version() method to all dependencies We unconditionally check the version of all dependencies, so without this regen will fail if you use that dependency.
8 years ago
dependencies: Fix two more edge-cases in dependency searching Includes tests for both of them.
8 years ago
# Check that you can find a dependency by not specifying a version after not
# finding it by specifying a version. We add `static: true` here so that the
# previously cached zlib dependencies don't get checked.
dependency('zlib', static : true, version : '>=8000', required : false)
dependency('zlib', static : true)
# Check that you can find a dependency by specifying a correct version after
# not finding it by specifying a wrong one. We add `method: pkg-config` here so that
# the previously cached zlib dependencies don't get checked.
bzip2 = dependency('zlib', method : 'pkg-config', version : '>=9000', required : false)
bzip2 = dependency('zlib', method : 'pkg-config', version : '>=1.0')
dependencies: Fix caching of native/cross dependencies All our cached_dep magic was totally useless since we ended up using the same identifier for native and cross deps. Just nuke all this cached_dep code since it is very error-prone and improve the identifier generation instead. For instance, this is broken *right now* with the `type_name` kwarg. Add a bunch of tests to ensure that all this actually works... Closes https://github.com/mesonbuild/meson/issues/1736
8 years ago
if meson.is_cross_build()
# Test caching of native and cross dependencies
# https://github.com/mesonbuild/meson/issues/1736
cross_prefix = dependency('zlib').get_pkgconfig_variable('prefix')
native_prefix = dependency('zlib', native : true).get_pkgconfig_variable('prefix')
assert(cross_prefix != '', 'cross zlib prefix is not defined')
assert(native_prefix != '', 'native zlib prefix is not defined')
assert(native_prefix != cross_prefix, 'native prefix == cross_prefix == ' + native_prefix)
endif
dependencies: Add a new class ExternalDependency This class now consolidates a lot of the logic that each external dependency was duplicating in its class definition. All external dependencies now set: * self.version * self.compile_args and self.link_args * self.is_found (if found) * self.sources * etc And the abstract ExternalDependency class defines the methods that will fetch those properties. Some classes still override that for various reasons, but those should also be migrated to properties as far as possible. Next step is to consolidate and standardize the way in which we call 'configuration binaries' such as sdl2-config, llvm-config, pkg-config, etc. Currently each class has to duplicate code involved with that even though the format is very similar. Currently only pkg-config supports multiple version requirements, and some classes don't even properly check the version requirement. That will also become easier now.
8 years ago
objc_found = add_languages('objc', required : false)
valgrind: Fix __init__ call Adds a test so that this is catched later. Closes https://github.com/mesonbuild/meson/issues/1937
8 years ago
foreach d : ['sdl2', 'gnustep', 'wxwidgets', 'gl', 'python3', 'boost', 'gtest', 'gmock', 'valgrind']
dependencies: Add a new class ExternalDependency This class now consolidates a lot of the logic that each external dependency was duplicating in its class definition. All external dependencies now set: * self.version * self.compile_args and self.link_args * self.is_found (if found) * self.sources * etc And the abstract ExternalDependency class defines the methods that will fetch those properties. Some classes still override that for various reasons, but those should also be migrated to properties as far as possible. Next step is to consolidate and standardize the way in which we call 'configuration binaries' such as sdl2-config, llvm-config, pkg-config, etc. Currently each class has to duplicate code involved with that even though the format is very similar. Currently only pkg-config supports multiple version requirements, and some classes don't even properly check the version requirement. That will also become easier now.
8 years ago
if d == 'gnustep' and not objc_found
message('Skipping gnustep because no ObjC compiler found')
else
dep = dependency(d, required : false)
if dep.found()
dep.version()
endif
Add get_version() method to all dependencies We unconditionally check the version of all dependencies, so without this regen will fail if you use that dependency.
8 years ago
endif
endforeach