libwz 0.1.0

package/deps/zlib/contrib/puff/puff.h

@@ -0,0 +1,35 @@
+/* puff.h
+  Copyright (C) 2002-2013 Mark Adler, all rights reserved
+  version 2.3, 21 Jan 2013
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Mark Adler    madler@alumni.caltech.edu
+ */
+
+
+/*
+ * See puff.c for purpose and usage.
+ */
+#ifndef NIL
+#  define NIL ((unsigned char *)0)      /* for no output option */
+#endif
+
+int puff(unsigned char *dest,           /* pointer to destination pointer */
+         unsigned long *destlen,        /* amount of output space */
+         const unsigned char *source,   /* pointer to source data pointer */
+         unsigned long *sourcelen);     /* amount of input available */

package/deps/zlib/contrib/puff/puffConfig.cmake.in

@@ -0,0 +1,18 @@
+@PACKAGE_INIT@
+
+set(_puff_supported_components "shared" "static")
+
+if(puff_FIND_COMPONENTS)
+    foreach(_comp ${puff_FIND_COMPONENTS})
+        if(NOT _comp IN_LIST _puff_supported_components)
+            set(puff_FOUND False)
+            set(puff_NOT_FOUND_MESSAGE "Unsupported component: ${_comp}")
+        endif(NOT _comp IN_LIST _puff_supported_components)
+
+        include("${CMAKE_CURRENT_LIST_DIR}/puff-${_comp}.cmake")
+    endforeach(_comp ${puff_FIND_COMPONENTS})
+else(puff_FIND_COMPONENTS)
+    foreach(_component_config IN LISTS _puff_supported_components)
+        include("${CMAKE_CURRENT_LIST_DIR}/puff-${_component_config}.cmake")
+    endforeach(_component_config IN LISTS _puff_supported_components)
+endif(puff_FIND_COMPONENTS)

package/deps/zlib/contrib/puff/pufftest.c

@@ -0,0 +1,168 @@
+/*
+ * pufftest.c
+ * Copyright (C) 2002-2026 Mark Adler
+ * For conditions of distribution and use, see copyright notice in puff.h
+ */
+
+/* Example of how to use puff().
+
+   Usage: puff [-w] [-f] [-nnn] file
+          ... | puff [-w] [-f] [-nnn]
+
+   where file is the input file with deflate data, nnn is the number of bytes
+   of input to skip before inflating (e.g. to skip a zlib or gzip header), and
+   -w is used to write the decompressed data to stdout.  -f is for coverage
+   testing, and causes pufftest to fail with not enough output space (-f does
+   a write like -w, so -w is not required). */
+
+#if defined(_WIN32) && !defined(_CRT_NONSTDC_NO_DEPRECATE)
+#  define _CRT_NONSTDC_NO_DEPRECATE
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "puff.h"
+
+#if defined(MSDOS) || defined(OS2) || defined(_WIN32) || defined(__CYGWIN__)
+#  include <fcntl.h>
+#  include <io.h>
+#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+#  define SET_BINARY_MODE(file)
+#endif
+
+#define local static
+
+/* Return size times approximately the cube root of 2, keeping the result as 1,
+   3, or 5 times a power of 2 -- the result is always > size, until the result
+   is the maximum value of an unsigned long, where it remains.  This is useful
+   to keep reallocations less than ~33% over the actual data. */
+local size_t bythirds(size_t size)
+{
+    int n;
+    size_t m;
+
+    m = size;
+    for (n = 0; m; n++)
+        m >>= 1;
+    if (n < 3)
+        return size + 1;
+    n -= 3;
+    m = size >> n;
+    m += m == 6 ? 2 : 1;
+    m <<= n;
+    return m > size ? m : (size_t)(-1);
+}
+
+/* Read the input file *name, or stdin if name is NULL, into allocated memory.
+   Reallocate to larger buffers until the entire file is read in.  Return a
+   pointer to the allocated data, or NULL if there was a memory allocation
+   failure.  *len is the number of bytes of data read from the input file (even
+   if load() returns NULL).  If the input file was empty or could not be opened
+   or read, *len is zero. */
+local void *load(const char *name, size_t *len)
+{
+    size_t size;
+    void *buf, *swap;
+    FILE *in;
+
+    *len = 0;
+    buf = malloc(size = 4096);
+    if (buf == NULL)
+        return NULL;
+    in = name == NULL ? stdin : fopen(name, "rb");
+    if (in != NULL) {
+        for (;;) {
+            *len += fread((char *)buf + *len, 1, size - *len, in);
+            if (*len < size) break;
+            size = bythirds(size);
+            if (size == *len || (swap = realloc(buf, size)) == NULL) {
+                free(buf);
+                buf = NULL;
+                break;
+            }
+            buf = swap;
+        }
+        fclose(in);
+    }
+    return buf;
+}
+
+int main(int argc, char **argv)
+{
+    int ret, put = 0, fail = 0;
+    unsigned skip = 0;
+    char *arg, *name = NULL;
+    unsigned char *source = NULL, *dest;
+    size_t len = 0;
+    unsigned long sourcelen, destlen;
+
+    /* process arguments */
+    while (arg = *++argv, --argc)
+        if (arg[0] == '-') {
+            if (arg[1] == 'w' && arg[2] == 0)
+                put = 1;
+            else if (arg[1] == 'f' && arg[2] == 0)
+                fail = 1, put = 1;
+            else if (arg[1] >= '0' && arg[1] <= '9')
+                skip = (unsigned)atoi(arg + 1);
+            else {
+                fprintf(stderr, "invalid option %s\n", arg);
+                return 3;
+            }
+        }
+        else if (name != NULL) {
+            fprintf(stderr, "only one file name allowed\n");
+            return 3;
+        }
+        else
+            name = arg;
+    source = load(name, &len);
+    if (source == NULL) {
+        fprintf(stderr, "memory allocation failure\n");
+        return 4;
+    }
+    if (len == 0) {
+        fprintf(stderr, "could not read %s, or it was empty\n",
+                name == NULL ? "<stdin>" : name);
+        free(source);
+        return 3;
+    }
+    if (skip >= len) {
+        fprintf(stderr, "skip request of %d leaves no input\n", skip);
+        free(source);
+        return 3;
+    }
+
+    /* test inflate data with offset skip */
+    len -= skip;
+    sourcelen = (unsigned long)len;
+    ret = puff(NIL, &destlen, source + skip, &sourcelen);
+    if (ret)
+        fprintf(stderr, "puff() failed with return code %d\n", ret);
+    else {
+        fprintf(stderr, "puff() succeeded uncompressing %lu bytes\n", destlen);
+        if (sourcelen < len) fprintf(stderr, "%lu compressed bytes unused\n",
+                                     len - sourcelen);
+    }
+
+    /* if requested, inflate again and write decompressed data to stdout */
+    if (put && ret == 0) {
+        if (fail)
+            destlen >>= 1;
+        dest = malloc(destlen);
+        if (dest == NULL) {
+            fprintf(stderr, "memory allocation failure\n");
+            free(source);
+            return 4;
+        }
+        puff(dest, &destlen, source + skip, &sourcelen);
+        SET_BINARY_MODE(stdout);
+        fwrite(dest, 1, destlen, stdout);
+        free(dest);
+    }
+
+    /* clean up */
+    free(source);
+    return ret;
+}

package/deps/zlib/contrib/puff/test/CMakeLists.txt

@@ -0,0 +1,262 @@
+# if we are built from with zlib, use this path's)
+if(DEFINED ZLIB_BUILD_PUFF)
+    set(WORK_DIR ${zlib_BINARY_DIR})
+    set(inst_setup zlib_install)
+else(DEFINED ZLIB_BUILD_PUFF)
+    set(WORK_DIR ${puff_BINARY_DIR})
+    set(inst_setup zlib_puff_install)
+    set(ZLIB_ARG "-DZLIB_DIR=${ZLIB_DIR}")
+
+    add_test(
+        NAME zlib_puff_install
+        COMMAND ${CMAKE_COMMAND} --install ${puff_BINARY_DIR} --prefix
+                ${CMAKE_CURRENT_BINARY_DIR}/test_install --config $<CONFIG>
+        WORKING_DIRECTORY ${puff_BINARY_DIR})
+
+    set_tests_properties(zlib_puff_install
+        PROPERTIES
+            FIXTURES_SETUP zlib_puff_install)
+endif(DEFINED ZLIB_BUILD_PUFF)
+
+if(ZLIB_PUFF_BUILD_SHARED AND NOT WIN32)
+    add_executable(zlib_puff_test
+        ${puff_SOURCE_DIR}/pufftest.c
+        ${puff_SOURCE_DIR}/puff.h)
+
+    target_link_libraries(zlib_puff_test
+        PRIVATE zlib_puff_puff)
+
+    add_test(NAME zlib_puff_test
+        COMMAND ${CMAKE_COMMAND} -P
+                ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake
+                "$<TARGET_FILE:zlib_puff_test>"
+                "${puff_SOURCE_DIR}")
+
+    if(GCOV_EXECUTABLE)
+        add_executable(zlib_puff_test-coverage
+            ${puff_SOURCE_DIR}/pufftest.c
+            ${puff_SOURCE_DIR}/puff.c
+            ${puff_SOURCE_DIR}/puff.h)
+
+        target_compile_options(zlib_puff_test-coverage PRIVATE -coverage)
+
+        target_link_options(zlib_puff_test-coverage PRIVATE -coverage)
+
+        add_test(NAME zlib_puff_test-coverage
+            COMMAND ${CMAKE_COMMAND} -P
+                    ${CMAKE_CURRENT_SOURCE_DIR}/tester-cov.cmake
+                    "$<TARGET_FILE:zlib_puff_test-coverage>"
+                    "${puff_SOURCE_DIR}"
+                    "$<TARGET_FILE:zlib_puff_bin-writer>"
+                    ${GCOV_EXECUTABLE}
+                    ${llvm_option})
+    endif(GCOV_EXECUTABLE)
+endif(ZLIB_PUFF_BUILD_SHARED AND NOT WIN32)
+
+if(ZLIB_PUFF_BUILD_STATIC AND NOT WIN32)
+    add_executable(zlib_puff_testStatic
+        ${puff_SOURCE_DIR}/pufftest.c
+        ${puff_SOURCE_DIR}/puff.h)
+
+    target_link_libraries(zlib_puff_testStatic
+        PRIVATE zlib_puff_puffStatic)
+    add_test(NAME zlib_puff_testStatic
+        COMMAND ${CMAKE_COMMAND} -P
+                ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake
+                "$<TARGET_FILE:zlib_puff_testStatic>"
+                "${puff_SOURCE_DIR}")
+
+    if(GCOV_EXECUTABLE)
+        add_executable(zlib_puff_testStatic-coverage
+            ${puff_SOURCE_DIR}/pufftest.c
+            ${puff_SOURCE_DIR}/puff.c
+            ${puff_SOURCE_DIR}/puff.h)
+
+        target_compile_options(zlib_puff_testStatic-coverage
+            PRIVATE -coverage)
+
+        target_link_options(zlib_puff_testStatic-coverage
+            PRIVATE -coverage)
+
+        add_test(NAME zlib_puff_testStatic-coverage
+            COMMAND ${CMAKE_COMMAND} -P
+                ${CMAKE_CURRENT_SOURCE_DIR}/tester-cov.cmake
+                "$<TARGET_FILE:zlib_puff_testStatic-coverage>"
+                "${puff_SOURCE_DIR}"
+                "$<TARGET_FILE:zlib_puff_bin-writer>"
+                ${GCOV_EXECUTABLE}
+                ${llvm_option})
+    endif(GCOV_EXECUTABLE)
+endif(ZLIB_PUFF_BUILD_STATIC AND NOT WIN32)
+
+file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test)
+file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test)
+file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test)
+
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/find_package_test.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test/CMakeLists.txt @ONLY)
+
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/add_subdirectory_test.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test/CMakeLists.txt @ONLY)
+
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/add_subdirectory_exclude_test.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test/CMakeLists.txt
+    @ONLY)
+
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/find_package_no_components_test.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test/CMakeLists.txt
+    @ONLY)
+
+configure_file(
+    ${CMAKE_CURRENT_SOURCE_DIR}/find_package_wrong_components_test.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test/CMakeLists.txt
+    @ONLY)
+
+# CMAKE_GENERATOR_PLATFORM doesn't work in the if
+set(GENERATOR ${CMAKE_GENERATOR_PLATFORM})
+
+if(GENERATOR)
+    set(PLATFORM "-A ${GENERATOR}")
+endif(GENERATOR)
+
+#
+# findpackage_test
+#
+add_test(
+    NAME zlib_puff_find_package_configure
+    COMMAND
+        ${CMAKE_COMMAND}
+        ${PLATFORM}
+        -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_test_build
+        -DCMAKE_BUILD_TYPE=$<CONFIG>
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install
+        ${ZLIB_ARG}
+        --fresh
+        -G "${CMAKE_GENERATOR}"
+        -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_test)
+
+add_test(
+    NAME zlib_puff_find_package_build
+    COMMAND ${CMAKE_COMMAND} --build . --config $<CONFIG>
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test_build)
+
+set_tests_properties(zlib_puff_find_package_configure
+    PROPERTIES
+        FIXTURES_REQUIRED ${inst_setup}
+        FIXTURES_SETUP puff_fp_config)
+
+set_tests_properties(zlib_puff_find_package_build
+    PROPERTIES
+        FIXTURES_REQUIRED puff_fp_config)
+
+#
+# add_subdirectory_test
+#
+add_test(
+    NAME zlib_puff_add_subdirectory_configure
+    COMMAND
+        ${CMAKE_COMMAND} ${PLATFORM}
+        -B${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test_build
+        -DCMAKE_BUILD_TYPE=$<CONFIG>
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG}
+        --fresh
+        -G "${CMAKE_GENERATOR}"
+        -S${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test)
+
+add_test(
+    NAME zlib_puff_add_subdirectory_build
+    COMMAND ${CMAKE_COMMAND} --build . --config $<CONFIG>
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test_build)
+
+set_tests_properties(zlib_puff_add_subdirectory_configure
+    PROPERTIES
+        FIXTURES_REQUIRED ${inst_setup}
+        FIXTURES_SETUP puiff_as_config)
+
+set_tests_properties(zlib_puff_add_subdirectory_build
+    PROPERTIES
+        FIXTURES_REQUIRED puff_as_config)
+
+#
+# add_subdirectory_exclude_test
+#
+add_test(
+    NAME zlib_puff_add_subdirectory_exclude_configure
+    COMMAND
+        ${CMAKE_COMMAND} ${PLATFORM}
+        -B${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test_build
+        -DCMAKE_BUILD_TYPE=$<CONFIG> -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG}
+        --fresh
+        -G "${CMAKE_GENERATOR}"
+        -S${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test)
+
+add_test(
+    NAME zlib_puff_add_subdirectory_exclude_build
+    COMMAND ${CMAKE_COMMAND} --build . --config $<CONFIG>
+    WORKING_DIRECTORY
+        ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test_build)
+
+set_tests_properties(zlib_puff_add_subdirectory_exclude_configure
+    PROPERTIES
+        FIXTURES_REQUIRED ${inst_setup}
+        FIXTURES_SETUP puff_asx_config)
+
+set_tests_properties(zlib_puff_add_subdirectory_exclude_build
+    PROPERTIES
+        FIXTURES_REQUIRED puff_asx_config)
+
+#
+# findpackage_no_components_test
+#
+add_test(
+    NAME zlib_puff_find_package_no_components_configure
+    COMMAND
+        ${CMAKE_COMMAND} ${PLATFORM}
+        -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test_build
+        -DCMAKE_BUILD_TYPE=$<CONFIG> -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG}
+        --fresh
+        -G "${CMAKE_GENERATOR}"
+        -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test)
+
+set_tests_properties(
+    zlib_puff_find_package_no_components_configure
+        PROPERTIES
+            FIXTURES_REQUIRED ${inst_setup})
+
+if(NOT ZLIB_PUFF_BUILD_SHARED OR NOT ZLIB_PUFF_BUILD_STATIC)
+    set_tests_properties(zlib_puff_find_package_no_components_configure
+        PROPERTIES
+            WILL_FAIL TRUE)
+endif(NOT ZLIB_PUFF_BUILD_SHARED OR NOT ZLIB_PUFF_BUILD_STATIC)
+
+#
+# findpackage_no_components_test
+#
+add_test(
+    NAME zlib_puff_find_package_wrong_components_configure
+    COMMAND
+        ${CMAKE_COMMAND} ${PLATFORM}
+        -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test_build
+        -DCMAKE_BUILD_TYPE=$<CONFIG> -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG}
+        --fresh
+        -G "${CMAKE_GENERATOR}"
+        -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test)
+
+set_tests_properties(zlib_puff_find_package_wrong_components_configure
+    PROPERTIES
+        FIXTURES_REQUIRED ${inst_setup}
+        WILL_FAIL TRUE)

package/deps/zlib/contrib/puff/test/add_subdirectory_exclude_test.cmake.in

@@ -0,0 +1,26 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+project(
+    zlib_puff_add_subdirectory_exclude_from_all
+    LANGUAGES C
+    VERSION @puff_VERSION@)
+
+option(ZLIB_PUFF_BUILD_TESTING "" OFF)
+option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@)
+option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@)
+
+add_subdirectory(@puff_SOURCE_DIR@ ${CMAKE_CURRENT_BINARY_DIR}/puff
+                 EXCLUDE_FROM_ALL)
+
+set(PUFF_SRCS
+    @puff_SOURCE_DIR@/pufftest.c)
+
+if(ZLIB_PUFF_BUILD_SHARED)
+    add_executable(test_example ${PUFF_SRCS})
+    target_link_libraries(test_example PUFF::PUFF)
+endif(ZLIB_PUFF_BUILD_SHARED)
+
+if(ZLIB_PUFF_BUILD_STATIC)
+    add_executable(test_example_static ${PUFF_SRCS})
+    target_link_libraries(test_example_static PUFF::PUFFSTATIC)
+endif(ZLIB_PUFF_BUILD_STATIC)

package/deps/zlib/contrib/puff/test/add_subdirectory_test.cmake.in

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+project(
+    zlib_puff_add_subdirectory
+    LANGUAGES C
+    VERSION @puff_VERSION@)
+
+option(ZLIB_PUFF_BUILD_TESTING "" OFF)
+option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@)
+option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@)
+
+add_subdirectory(@puff_SOURCE_DIR@ ${CMAKE_CURRENT_BINARY_DIR}/puff)
+
+set(PUFF_SRCS
+    @puff_SOURCE_DIR@/pufftest.c)
+
+if(ZLIB_PUFF_BUILD_SHARED)
+    add_executable(test_example ${PUFF_SRCS})
+    target_link_libraries(test_example PUFF::PUFF)
+endif(ZLIB_PUFF_BUILD_SHARED)
+
+if(ZLIB_PUFF_BUILD_STATIC)
+    add_executable(test_example_static ${PUFF_SRCS})
+    target_link_libraries(test_example_static PUFF::PUFFSTATIC)
+endif(ZLIB_PUFF_BUILD_STATIC)

package/deps/zlib/contrib/puff/test/find_package_no_components_test.cmake.in

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+project(
+    puff_find_package
+    LANGUAGES C
+    VERSION @puff_VERSION@)
+
+option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@)
+option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@)
+
+find_package(puff REQUIRED CONFIG)
+
+set(PUFF_SRCS
+    @puff_SOURCE_DIR@/pufftest.c)
+
+if(ZLIB_PUFF_BUILD_SHARED)
+    add_executable(test_example ${PUFF_SRCS})
+    target_link_libraries(test_example PUFF::PUFF)
+endif(ZLIB_PUFF_BUILD_SHARED)
+
+if(ZLIB_PUFF_BUILD_STATIC)
+    add_executable(test_example_static ${PUFF_SRCS})
+    target_link_libraries(test_example_static PUFF::PUFFSTATIC)
+endif(ZLIB_PUFF_BUILD_STATIC)

package/deps/zlib/contrib/puff/test/find_package_test.cmake.in

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+project(
+    puff_find_package
+    LANGUAGES C
+    VERSION @puff_VERSION@)
+
+option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@)
+option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@)
+
+set(PUFF_SRCS
+    @puff_SOURCE_DIR@/pufftest.c)
+
+if(ZLIB_PUFF_BUILD_SHARED)
+    find_package(puff REQUIRED COMPONENTS shared CONFIG)
+    add_executable(test_example ${PUFF_SRCS})
+    target_link_libraries(test_example PUFF::PUFF)
+endif(ZLIB_PUFF_BUILD_SHARED)
+
+if(ZLIB_PUFF_BUILD_STATIC)
+    find_package(puff REQUIRED COMPONENTS static CONFIG)
+    add_executable(test_example_static ${PUFF_SRCS})
+    target_link_libraries(test_example_static PUFF::PUFFSTATIC)
+endif(ZLIB_PUFF_BUILD_STATIC)

package/deps/zlib/contrib/puff/test/find_package_wrong_components_test.cmake.in

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+project(
+    puff_find_package
+    LANGUAGES C
+    VERSION @puff_VERSION@)
+
+option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@)
+option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@)
+
+find_package(puff REQUIRED COMPONENTS wrong CONFIG)
+
+set(PUFF_SRCS
+    @puff_SOURCE_DIR@/pufftest.c)
+
+if(ZLIB_PUFF_BUILD_SHARED)
+    add_executable(test_example ${PUFF_SRCS})
+    target_link_libraries(test_example PUFF::PUFF)
+endif(ZLIB_PUFF_BUILD_SHARED)
+
+if(ZLIB_PUFF_BUILD_STATIC)
+    add_executable(test_example_static ${PUFF_SRCS})
+    target_link_libraries(test_example_static PUFF::PUFFSTATIC)
+endif(ZLIB_PUFF_BUILD_STATIC)

package/deps/zlib/contrib/puff/test/tester-cov.cmake

@@ -0,0 +1,58 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+#CMAKE_ARGV0 = ${CMAKE_COMMAND}
+#CMAKE_ARGV1 = -P
+#CMAKE_ARGV2 = ${CMAKE_CURRENT_SOURCE_DIR}/tester-cov.cmake
+#CMAKE_ARGV3 = "$<TARGET_FILE:puff-test-cov>"
+#CMAKE_ARGV4 = "${CMAKE_CURRENT_SOURCE_DIR}"
+#CMAKE_ARGV5 = "${CMAKE_CURRENT_BINARY_DIR}"
+#CMAKE_ARGV6 = GCOV_EXECUTABLE
+#CMAKE_ARGV7 = GCOV_EXECUTABLE
+
+function(puff_cov_test test_string expected_result)
+    execute_process(COMMAND ${CMAKE_ARGV0} -E echo_append ${test_string}
+                    COMMAND ${CMAKE_ARGV5}
+                    COMMAND ${CMAKE_ARGV3}
+                    RESULT_VARIABLE RESULT)
+
+    if(NOT RESULT EQUAL expected_result)
+        message(FATAL_ERROR "Received Exit-Code: ${RESULT}\n"
+                            "Expected Exit-Code: ${expected_result}\n"
+                            "Test-String: ${test_string}")
+    endif(NOT RESULT EQUAL expected_result)
+endfunction(puff_cov_test test_string expected_result)
+
+execute_process(COMMAND ${CMAKE_ARGV3} -w ${CMAKE_ARGV4}/zeros.raw)
+
+puff_cov_test("04" "2")
+puff_cov_test("00" "2")
+puff_cov_test("00 00 00 00 00" "254")
+puff_cov_test("00 01 00 fe ff" "2")
+
+execute_process(COMMAND ${CMAKE_ARGV0} -E echo_append "01 01 00 fe ff 0a"
+                COMMAND ${CMAKE_ARGV5}
+                COMMAND ${CMAKE_ARGV3})
+
+puff_cov_test("02 7e ff ff" "246")
+puff_cov_test("02" "2")
+puff_cov_test("04 80 49 92 24 49 92 24 0f b4 ff ff c3 04" "2")
+puff_cov_test("04 80 49 92 24 49 92 24 71 ff ff 93 11 00" "249")
+puff_cov_test("04 c0 81 08 00 00 00 00 20 7f eb 0b 00 00" "246")
+
+execute_process(COMMAND ${CMAKE_ARGV0} -E echo_append "0b 00 00"
+                COMMAND ${CMAKE_ARGV5}
+                COMMAND ${CMAKE_ARGV3})
+
+puff_cov_test("1a 07" "246")
+puff_cov_test("0c c0 81 00 00 00 00 00 90 ff 6b 04" "245")
+
+execute_process(COMMAND ${CMAKE_ARGV3} -f ${CMAKE_ARGV4}/zeros.raw)
+
+puff_cov_test("fc 00 00" "253")
+puff_cov_test("04 00 fe ff" "252")
+puff_cov_test("04 00 24 49" "251")
+puff_cov_test("04 80 49 92 24 49 92 24 0f b4 ff ff c3 84" "248")
+puff_cov_test("04 00 24 e9 ff ff" "250")
+puff_cov_test("04 00 24 e9 ff 6d" "247")
+
+execute_process(COMMAND ${CMAKE_ARGV6} ${CMAKE_ARGV7} -n puff.c.gcno)

package/deps/zlib/contrib/puff/test/tester.cmake

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+#CMAKE_ARGV0 = ${CMAKE_COMMAND}
+#CMAKE_ARGV1 = -P
+#CMAKE_ARGV2 = ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake
+#CMAKE_ARGV3 = "$<TARGET_FILE:puff-test>"
+#CMAKE_ARGV4 = "${CMAKE_CURRENT_SOURCE_DIR}"
+
+execute_process(COMMAND ${CMAKE_ARGV3}
+                INPUT_FILE "${CMAKE_ARGV4}/zeros.raw"
+                RESULT_VARIABLE RESULT
+            COMMAND_ECHO STDERR)
+
+if(RESULT)
+    message(FATAL_ERROR "Command exitited with: ${RESULT}")
+endif(RESULT)