Skip to content

Commit

Permalink
Merge branch 'feature/github-actions' into develop
Browse files Browse the repository at this point in the history
  • Loading branch information
rikyoz committed Oct 15, 2023
2 parents 5160f3e + 8706776 commit 4958285
Show file tree
Hide file tree
Showing 11 changed files with 213 additions and 70 deletions.
143 changes: 143 additions & 0 deletions .github/workflows/ctest.yml
Original file line number Diff line number Diff line change
@@ -0,0 +1,143 @@
# This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform.
# See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml
name: Test bit7z on multiple configurations
on: [pull_request, push]

jobs:
build:
runs-on: ${{ matrix.os }}
if: |
github.event_name == 'pull_request'
|| contains(github.event.head_commit.message, '[test]')
|| startsWith(github.ref, 'refs/tags/v')
strategy:
# Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable.
fail-fast: false

matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
build_type: [Debug, Release]
c_compiler: [gcc, clang, cl]
bit7z_auto_format: [OFF, ON]
bit7z_regex_matching: [OFF, ON]
bit7z_link_libcpp: [OFF, ON]
bit7z_use_native_string: [OFF, ON]
bit7z_auto_prefix_long_paths: [OFF, ON]
bit7z_use_system_codepage: [OFF, ON]
bit7z_path_sanitization: [OFF, ON]
include:
- os: windows-latest
c_compiler: cl
cpp_compiler: cl
use_system_7zip: ON
- os: ubuntu-latest
c_compiler: gcc
cpp_compiler: g++
use_system_7zip: OFF
- os: ubuntu-latest
c_compiler: clang
cpp_compiler: clang++
use_system_7zip: OFF
- os: macos-latest
c_compiler: gcc
cpp_compiler: g++
use_system_7zip: OFF
- os: macos-latest
c_compiler: clang
cpp_compiler: clang++
use_system_7zip: OFF
exclude:
- os: windows-latest
c_compiler: gcc
- os: windows-latest
c_compiler: clang
- os: windows-latest
bit7z_link_libcpp: ON
- os: ubuntu-latest
c_compiler: cl
- os: ubuntu-latest
c_compiler: gcc
bit7z_link_libcpp: ON
- os: ubuntu-latest
bit7z_use_native_string: ON
- os: ubuntu-latest
bit7z_auto_prefix_long_paths: ON
- os: ubuntu-latest
bit7z_use_system_codepage: ON
- os: ubuntu-latest
bit7z_path_sanitization: ON
- os: macos-latest
c_compiler: cl
- os: macos-latest
c_compiler: gcc
bit7z_link_libcpp: ON
- os: macos-latest
bit7z_use_native_string: ON
- os: macos-latest
bit7z_auto_prefix_long_paths: ON
- os: macos-latest
bit7z_use_system_codepage: ON
- os: macos-latest
bit7z_path_sanitization: ON

steps:
- uses: actions/checkout@v3

- name: Set reusable strings
# Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file.
id: strings
shell: bash
run: |
echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
- name: Configure CMake
# Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
# See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
run: >
cmake -B ${{ steps.strings.outputs.build-output-dir }}
-DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
-DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
-DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-DBIT7Z_BUILD_TESTS=ON
-DBIT7Z_ENABLE_SANITIZERS=ON
-DBIT7Z_TESTS_USE_SYSTEM_7ZIP=${{ matrix.use_system_7zip }}
-DBIT7Z_AUTO_FORMAT=${{ matrix.bit7z_auto_format }}
-DBIT7Z_REGEX_MATCHING=${{ matrix.bit7z_regex_matching }}
-DBIT7Z_USE_NATIVE_STRING=${{ matrix.bit7z_use_native_string }}
-DBIT7Z_LINK_LIBCPP=${{ matrix.bit7z_link_libcpp }}
-DBIT7Z_AUTO_PREFIX_LONG_PATHS=${{ matrix.bit7z_auto_prefix_long_paths }}
-DBIT7Z_USE_SYSTEM_CODEPAGE=${{ matrix.bit7z_use_system_codepage }}
-DBIT7Z_PATH_SANITIZATION=${{ matrix.bit7z_path_sanitization }}
-S ${{ github.workspace }}
- name: Build bit7z
# Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}

- name: Build 7z.so for tests (Ubuntu)
shell: bash
if: matrix.os == 'ubuntu-latest'
run: |
git clone --depth 1 https://github.com/rikyoz/7-Zip ${{ github.workspace }}/../7-zip
cd ${{ github.workspace }}/../7-zip/CPP/7zip/Bundles/Format7zF/
make -j -f ../../cmpl_gcc.mak
cp b/g/7z.so ${{ github.workspace }}/bin/x64/7z.so
- name: Build 7z.so for tests (macOS)
shell: bash
if: matrix.os == 'macos-latest'
run: |
git clone --depth 1 https://github.com/rikyoz/7-Zip ${{ github.workspace }}/../7-zip
cd ${{ github.workspace }}/../7-zip/CPP/7zip/Bundles/Format7zF/
make -j -f ../../cmpl_mac_x64.mak
cp b/m_x64/7z.so ${{ github.workspace }}/bin/x64/7z.so
- name: Test bit7z
working-directory: ${{ steps.strings.outputs.build-output-dir }}
# Disabling alloc_dealloc_mismatch for address sanitizer until https://github.com/llvm/llvm-project/issues/52771 is fixed
env:
ASAN_OPTIONS: alloc_dealloc_mismatch=0
# Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
# See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
run: ctest --build-config ${{ matrix.build_type }} --output-on-failure
3 changes: 3 additions & 0 deletions CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -228,6 +228,9 @@ if( UNIX )
target_link_libraries( ${LIB_TARGET} PUBLIC ${CMAKE_DL_LIBS} )
endif()

# sanitizers
include( cmake/Sanitizers.cmake )

# tests
if( BIT7Z_BUILD_TESTS )
enable_testing()
Expand Down
2 changes: 1 addition & 1 deletion cmake/CompilerOptions.cmake
Original file line number Diff line number Diff line change
Expand Up @@ -122,6 +122,6 @@ if( CMAKE_CXX_COMPILER_ID MATCHES "GNU" )
endif()
if( CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 7.0 )
# Extra warning flags for GCC 7.0+
target_compile_options( ${LIB_TARGET} PRIVATE -Wduplicated-branches )
target_compile_options( ${LIB_TARGET} PRIVATE -Wduplicated-branches -Wrestrict )
endif()
endif()
7 changes: 5 additions & 2 deletions cmake/Dependencies.cmake
Original file line number Diff line number Diff line change
@@ -1,11 +1,14 @@
# Downloading the CPM.cmake package manager
set( CPM_DOWNLOAD_VERSION 0.38.5 )
set( CPM_DOWNLOAD_VERSION 0.38.6 )
set( CPM_DOWNLOAD_HASH 11c3fa5f1ba14f15d31c2fb63dbc8628ee133d81c8d764caad9a8db9e0bacb07 )
set( CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake" )
if( NOT ( EXISTS ${CPM_DOWNLOAD_LOCATION} ))
if( NOT ( EXISTS ${CPM_DOWNLOAD_LOCATION} ) )
message( STATUS "Downloading CPM.cmake to ${CPM_DOWNLOAD_LOCATION}" )
file( DOWNLOAD
https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
${CPM_DOWNLOAD_LOCATION}
SHOW_PROGRESS
EXPECTED_HASH SHA256=${CPM_DOWNLOAD_HASH}
)
endif()
include( ${CPM_DOWNLOAD_LOCATION} )
Expand Down
54 changes: 54 additions & 0 deletions cmake/Sanitizers.cmake
Original file line number Diff line number Diff line change
@@ -0,0 +1,54 @@
macro( add_sanitizer name )
set( CMAKE_REQUIRED_FLAGS "-fsanitize=${name}" )
check_cxx_compiler_flag( -fsanitize=${name} COMPILER_SUPPORTS_SANITIZE_${name} )
if( COMPILER_SUPPORTS_SANITIZE_${name} )
message( STATUS "Supported sanitizer: ${name}" )
set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=${name}" )
else()
message( STATUS "Unsupported sanitizer: ${name}" )
endif()
unset( CMAKE_REQUIRED_FLAGS )
endmacro()

option( BIT7Z_ENABLE_SANITIZERS "Enable or disable compiling with sanitizers" )
message( STATUS "Enable sanitizers: ${BIT7Z_ENABLE_SANITIZERS}" )
if ( BIT7Z_ENABLE_SANITIZERS )
if( MSVC )
set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /RTCsu /analyze /guard:cf" )
elseif( NOT WIN32 ) # GCC/Clang on Linux/macOS (i.e., not MinGW)
set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer" )

if( CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "6.0.0" )
set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -static-libsan" )
endif()

# Use the highest stack protection level supported by the target toolchain.
include( CheckCXXCompilerFlag )
check_cxx_compiler_flag( -fstack-protector-strong COMPILER_SUPPORT_STRONG_STACK_PROTECTOR )
check_cxx_compiler_flag( -fstack-protector COMPILER_SUPPORT_STACK_PROTECTOR )
if( COMPILER_SUPPORT_STRONG_STACK_PROTECTOR )
set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_DEBUG} -fstack-protector-strong" )
elseif( COMPILER_SUPPORT_STACK_PROTECTOR )
set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_DEBUG} -fstack-protector" )
endif()

# For some reasons, the address sanitizer gives a CHECK failed error on versions of Clang before the 3.9
# Also, on old versions of GCC the sanitizer give some false positives.
if( ( NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "5.0" ) OR
( CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "3.9.0" ) )
add_sanitizer( address )
check_cxx_compiler_flag( -fsanitize-address-use-after-scope COMPILER_SUPPORT_SANITIZE_USE_AFTER_SCOPE )
if( COMPILER_SUPPORT_SANITIZE_USE_AFTER_SCOPE )
set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize-address-use-after-scope" )
endif()
endif()

add_sanitizer( float-divide-by-zero )
add_sanitizer( implicit-conversion )
add_sanitizer( integer )
add_sanitizer( leak )
add_sanitizer( local-bounds )
add_sanitizer( nullability )
add_sanitizer( undefined )
endif()
endif()
6 changes: 3 additions & 3 deletions src/internal/formatdetect.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -340,7 +340,7 @@ struct OffsetSignature {
#define bswap64 _byteswap_uint64
#elif defined(__GNUC__) || defined(__clang__)
//Note: the versions of gcc and clang that can compile bit7z should also have this builtin, hence there is no need
// for checking the compiler version or using _has_builtin macro!
// for checking the compiler version or using the _has_builtin macro.
#define bswap64 __builtin_bswap64
#else
static inline uint64_t bswap64( uint64_t x ) {
Expand Down Expand Up @@ -375,7 +375,7 @@ auto detect_format_from_signature( IInStream* stream ) -> const BitInFormat& {
return *format;
}
signatureMask <<= kByteShift; // left shifting the mask of one byte, so that
fileSignature &= signatureMask; // the least significant i bytes are masked (set to 0)
fileSignature &= signatureMask; // the least significant i bytes are masked (set to 0)
}

static const OffsetSignature commonSignaturesWithOffset[] = { // NOLINT(*-avoid-c-arrays)
Expand All @@ -385,7 +385,7 @@ auto detect_format_from_signature( IInStream* stream ) -> const BitInFormat& {
{ 0x436F6D7072657373, 0x10, 8, BitFormat::CramFS }, // Compress
{ 0x7F10DABE00000000, 0x40, 4, BitFormat::VDI }, // 0x7F 0x10 0xDA 0xBE
{ 0x7573746172000000, 0x101, 5, BitFormat::Tar }, // ustar
// Note: since GPT files contain also the FAT signature, GPT must be checked before!
/* Note: since GPT files contain also the FAT signature, we must check the GPT signature before the FAT one. */
{ 0x4546492050415254, 0x200, 8, BitFormat::GPT }, // EFI 0x20 PART
{ 0x55AA000000000000, 0x1FE, 2, BitFormat::Fat }, // U 0xAA
{ 0x4244000000000000, 0x400, 2, BitFormat::Hfs }, // BD
Expand Down
2 changes: 0 additions & 2 deletions tests/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -148,8 +148,6 @@ if( WIN32 )
target_sources( ${TESTS_TARGET_PUBLIC} PRIVATE res/encodingLegacy.${RES_EXTENSION} )
endif()

include( cmake/Sanitizers.cmake )

# Catch2
include( cmake/Catch2.cmake )
target_link_libraries( ${TESTS_TARGET} PRIVATE Catch2::Catch2 )
Expand Down
58 changes: 0 additions & 58 deletions tests/cmake/Sanitizers.cmake

This file was deleted.

2 changes: 1 addition & 1 deletion tests/src/test_bitarchivereader.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -159,7 +159,7 @@ void getInputArchive( const fs::path& path, stream_t& archive ) {
}

template< typename T >
using is_filesystem_archive = std::is_same< bit7z::tstring, std::decay_t< T > >;
using is_filesystem_archive = std::is_same< bit7z::tstring, typename std::decay< T >::type >;

TEMPLATE_TEST_CASE( "BitArchiveReader: Reading archives containing only a single file",
"[bitarchivereader]", tstring, buffer_t, stream_t ) {
Expand Down
2 changes: 1 addition & 1 deletion tests/src/test_bititemsvector.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -1973,7 +1973,7 @@ TEST_CASE( "BitItemsVector: Indexing a single buffer", "[bititemsvector]" ) {
BIT7Z_STRING( "folder/subfolder2/frequency.xlsx" ),
BIT7Z_STRING( "dot.folder/hello.json" ) );

DYNAMIC_SECTION ( "Indexing file " << testInput.u8string() << " as a buffer" ) {
DYNAMIC_SECTION( "Indexing file " << testInput.u8string() << " as a buffer" ) {
REQUIRE_LOAD_FILE( input_buffer, testInput );
REQUIRE_NOTHROW( itemsVector.indexBuffer( input_buffer, BIT7Z_STRING( "custom_name.ext" ) ) );
REQUIRE( itemsVector.size() == 1 );
Expand Down
4 changes: 2 additions & 2 deletions tests/src/test_windows.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -112,7 +112,7 @@ TEST_CASE( "winapi: Allocating from wide strings", "[winapi][string allocation]"

SECTION( "SysAllocStringLen with half-length parameter" ) {
// Note: flawfinder warns about potentially using non-null terminating strings,
// but, in our case, the test string is guaranteed to be null-terminated!
// but, in our case, the test string is guaranteed to be null-terminated.
expectedString = std::wstring{ testStr, std::wcslen( testStr ) / 2 }; // flawfinder: ignore
resultString = SysAllocStringLen( testStr, expectedString.size() );
}
Expand Down Expand Up @@ -152,7 +152,7 @@ TEST_CASE( "winapi: Allocating from narrow strings", "[winapi][string allocation

SECTION( "SysAllocStringByteLen with half-length parameter" ) {
// Note: flawfinder warns about potentially using non-null terminating strings,
// but, in our case, the test string is guaranteed to be null-terminated!
// but, in our case, the test string is guaranteed to be null-terminated.
expectedString = std::string{ testStr, std::strlen( testStr ) / 2 }; // flawfinder: ignore
resultString = SysAllocStringByteLen( testStr, expectedString.size() );
}
Expand Down

0 comments on commit 4958285

Please sign in to comment.