File _service:obs_scm:libglibutil-1680886706.91f2bff... of Package libglibutil

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:libglibutil-1680886706.91f2bff.obscpio of Package libglibutil

07070100000000000081A400000000000000000000000164304BB20000020A000000000000000000000000000000000000002A00000000libglibutil-1680886706.91f2bff/.gitignore*~
test/libglibutil_test.ncb
test/libglibutil_test.opt
test/coverage/full.gcov
test/coverage/libglibutil.gcov
test/coverage/results
debian/.debhelper
debian/files
debian/libglibutil-dev.debhelper.log
debian/libglibutil-dev.install
debian/libglibutil-dev.substvars
debian/libglibutil-dev
debian/libglibutil.debhelper.log
debian/libglibutil.install
debian/libglibutil.postinst.debhelper
debian/libglibutil.postrm.debhelper
debian/libglibutil.substvars
debian/libglibutil
debian/tmp
documentation.list
installroot
build
RPMS
07070100000001000081A400000000000000000000000164304BB20000064D000000000000000000000000000000000000002700000000libglibutil-1680886706.91f2bff/LICENSECopyright (C) 2014-2022 Jolla Ltd.
Copyright (C) 2023 Slava Monich <slava@monich.com>

You may use this file under the terms of BSD license as follows:

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
  3. Neither the names of the copyright holders nor the names of its
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.

.PHONY: clean all debug release coverage pkgconfig install install-dev test
.PHONY: print_debug_lib print_release_lib print_coverage_lib
#
# Required packages
#

PKGS = glib-2.0 gobject-2.0

#
# Default target
#

all: debug release pkgconfig

#
# Directories
#

SRC_DIR = src
INCLUDE_DIR = include
BUILD_DIR = build
DEBUG_BUILD_DIR = $(BUILD_DIR)/debug
RELEASE_BUILD_DIR = $(BUILD_DIR)/release
COVERAGE_BUILD_DIR = $(BUILD_DIR)/coverage

#
# Library version
#

VERSION_FILE = $(INCLUDE_DIR)/gutil_version.h
get_version = $(shell grep -E '^ *\#define +GUTIL_VERSION_$1 +[0-9]+$$' $(VERSION_FILE) | sed 's/  */ /g' | cut -d ' ' -f 3)

VERSION_MAJOR := $(call get_version,MAJOR)
VERSION_MINOR := $(call get_version,MINOR)
VERSION_MICRO := $(call get_version,MICRO)

# Version for pkg-config
PCVERSION := $(VERSION_MAJOR).$(VERSION_MINOR).$(VERSION_MICRO)

#
# Library name
#

NAME = glibutil
LIB_NAME = lib$(NAME)
LIB_DEV_SYMLINK = $(LIB_NAME).so
LIB_SYMLINK1 = $(LIB_DEV_SYMLINK).$(VERSION_MAJOR)
LIB_SYMLINK2 = $(LIB_SYMLINK1).$(VERSION_MINOR)
LIB_SONAME = $(LIB_SYMLINK1)
LIB = $(LIB_SONAME).$(VERSION_MINOR).$(VERSION_MICRO)
STATIC_LIB = $(LIB_NAME).a

#
# Sources
#

SRC = \
  gutil_datapack.c \
  gutil_history.c \
  gutil_idlepool.c \
  gutil_idlequeue.c \
  gutil_inotify.c \
  gutil_intarray.c \
  gutil_ints.c \
  gutil_log.c \
  gutil_misc.c \
  gutil_ring.c \
  gutil_strv.c \
  gutil_timenotify.c \
  gutil_version.c \
  gutil_weakref.c

#
# Tools and flags
#

CC ?= $(CROSS_COMPILE)gcc
STRIP ?= strip
LD = $(CC)
WARNINGS = -Wall
INCLUDES = -I$(INCLUDE_DIR)
BASE_FLAGS = -fPIC
FULL_CFLAGS = $(BASE_FLAGS) $(CFLAGS) $(DEFINES) $(WARNINGS) $(INCLUDES) \
  -DGLIB_VERSION_MAX_ALLOWED=GLIB_VERSION_2_32 \
  -DGLIB_VERSION_MIN_REQUIRED=GLIB_VERSION_MAX_ALLOWED \
  -MMD -MP $(shell pkg-config --cflags $(PKGS))
FULL_LDFLAGS = $(BASE_FLAGS) $(LDFLAGS) -shared -Wl,-soname,$(LIB_SONAME) \
  $(shell pkg-config --libs $(PKGS))
DEBUG_FLAGS = -g
RELEASE_FLAGS =
COVERAGE_FLAGS = -g

KEEP_SYMBOLS ?= 0
ifneq ($(KEEP_SYMBOLS),0)
RELEASE_FLAGS += -g
endif

DEBUG_LDFLAGS = $(FULL_LDFLAGS) $(DEBUG_FLAGS)
RELEASE_LDFLAGS = $(FULL_LDFLAGS) $(RELEASE_FLAGS)
DEBUG_CFLAGS = $(FULL_CFLAGS) $(DEBUG_FLAGS) -DDEBUG
RELEASE_CFLAGS = $(FULL_CFLAGS) $(RELEASE_FLAGS) -O2
COVERAGE_CFLAGS = $(FULL_CFLAGS) $(COVERAGE_FLAGS) -O0 --coverage

#
# Files
#

PKGCONFIG = $(BUILD_DIR)/$(LIB_NAME).pc
DEBUG_OBJS = $(SRC:%.c=$(DEBUG_BUILD_DIR)/%.o)
RELEASE_OBJS = $(SRC:%.c=$(RELEASE_BUILD_DIR)/%.o)
COVERAGE_OBJS = $(SRC:%.c=$(COVERAGE_BUILD_DIR)/%.o)

DEBUG_LIB = $(DEBUG_BUILD_DIR)/$(LIB)
RELEASE_LIB = $(RELEASE_BUILD_DIR)/$(LIB)
DEBUG_LINK = $(DEBUG_BUILD_DIR)/$(LIB_SYMLINK1)
RELEASE_LINK = $(RELEASE_BUILD_DIR)/$(LIB_SYMLINK1)
DEBUG_DEV_LINK = $(DEBUG_BUILD_DIR)/$(LIB_DEV_SYMLINK)
RELEASE_DEV_LINK = $(RELEASE_BUILD_DIR)/$(LIB_DEV_SYMLINK)
DEBUG_STATIC_LIB = $(DEBUG_BUILD_DIR)/$(STATIC_LIB)
RELEASE_STATIC_LIB = $(RELEASE_BUILD_DIR)/$(STATIC_LIB)
COVERAGE_STATIC_LIB = $(COVERAGE_BUILD_DIR)/$(STATIC_LIB)

#
# Dependencies
#

DEPS = $(DEBUG_OBJS:%.o=%.d) $(RELEASE_OBJS:%.o=%.d) $(COVERAGE_OBJS:%.o=%.d)
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(strip $(DEPS)),)
-include $(DEPS)
endif
endif

$(PKGCONFIG): | $(BUILD_DIR)
$(DEBUG_OBJS) $(DEBUG_LIB) $(DEBUG_STATIC_LIB): | $(DEBUG_BUILD_DIR)
$(RELEASE_OBJS) $(RELEASE_LIB) $(RELEASE_STATIC_LIB): | $(RELEASE_BUILD_DIR)
$(COVERAGE_OBJS) $(COVERAGE_STATIC_LIB): | $(COVERAGE_BUILD_DIR)

#
# Rules
#

debug: $(DEBUG_STATIC_LIB) $(DEBUG_DEV_LINK)

release: $(RELEASE_STATIC_LIB) $(RELEASE_DEV_LINK)

coverage: $(COVERAGE_STATIC_LIB)

pkgconfig: $(PKGCONFIG)

print_debug_lib:
	@echo $(DEBUG_STATIC_LIB)

print_release_lib:
	@echo $(RELEASE_STATIC_LIB)

print_coverage_lib:
	@echo $(COVERAGE_STATIC_LIB)

clean:
	make -C test clean
	rm -fr test/coverage/results test/coverage/*.gcov
	rm -f *~ $(SRC_DIR)/*~ $(INCLUDE_DIR)/*~
	rm -fr $(BUILD_DIR) RPMS installroot
	rm -fr debian/tmp debian/libglibutil debian/libglibutil-dev
	rm -f documentation.list debian/files debian/*.substvars
	rm -f debian/*.debhelper.log debian/*.debhelper debian/*~
	rm -fr debian/*.install

test:
	make -C test test

$(BUILD_DIR):
	mkdir -p $@

$(DEBUG_BUILD_DIR):
	mkdir -p $@

$(RELEASE_BUILD_DIR):
	mkdir -p $@

$(COVERAGE_BUILD_DIR):
	mkdir -p $@

$(DEBUG_BUILD_DIR)/%.o : $(SRC_DIR)/%.c
	$(CC) -c $(DEBUG_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(RELEASE_BUILD_DIR)/%.o : $(SRC_DIR)/%.c
	$(CC) -c $(RELEASE_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(COVERAGE_BUILD_DIR)/%.o : $(SRC_DIR)/%.c
	$(CC) -c $(COVERAGE_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(DEBUG_LIB): $(DEBUG_OBJS)
	$(LD) $(DEBUG_OBJS) $(DEBUG_LDFLAGS) -o $@

$(RELEASE_LIB): $(RELEASE_OBJS)
	$(LD) $(RELEASE_OBJS) $(RELEASE_LDFLAGS) -o $@
ifeq ($(KEEP_SYMBOLS),0)
	$(STRIP) $@
endif

$(DEBUG_LINK): $(DEBUG_LIB)
	ln -sf $(LIB) $@

$(RELEASE_LINK): $(RELEASE_LIB)
	ln -sf $(LIB) $@

$(DEBUG_DEV_LINK): $(DEBUG_LINK)
	ln -sf $(LIB_SYMLINK1) $@

$(RELEASE_DEV_LINK): $(RELEASE_LINK)
	ln -sf $(LIB_SYMLINK1) $@

$(DEBUG_STATIC_LIB): $(DEBUG_OBJS)
	$(AR) rc $@ $?

$(RELEASE_STATIC_LIB): $(RELEASE_OBJS)
	$(AR) rc $@ $?

$(COVERAGE_STATIC_LIB): $(COVERAGE_OBJS)
	$(AR) rc $@ $?

#
# LIBDIR usually gets substituted with arch specific dir.
# It's relative in deb build and can be whatever in rpm build.
#

LIBDIR ?= usr/lib
ABS_LIBDIR := $(shell echo /$(LIBDIR) | sed -r 's|/+|/|g')

debian/%.install: debian/%.install.in
	sed 's|@LIBDIR@|$(LIBDIR)|g' $< > $@

#
# Install
#

INSTALL_PERM  = 644

INSTALL = install
INSTALL_DIRS = $(INSTALL) -d
INSTALL_FILES = $(INSTALL) -m $(INSTALL_PERM)

INSTALL_LIB_DIR = $(DESTDIR)$(ABS_LIBDIR)
INSTALL_INCLUDE_DIR = $(DESTDIR)/usr/include/gutil
INSTALL_PKGCONFIG_DIR = $(DESTDIR)$(ABS_LIBDIR)/pkgconfig

#
# rpm based systems expect libraries to be 755
# deb based systems expect libraries to be 644
#
# 755 works for both because dh_fixperms removes execute permissions
# from any libraries and other files that don't need it.
#
install: $(INSTALL_LIB_DIR)
	$(INSTALL) -m 755 $(RELEASE_LIB) $(INSTALL_LIB_DIR)
	ln -sf $(LIB) $(INSTALL_LIB_DIR)/$(LIB_SYMLINK2)
	ln -sf $(LIB_SYMLINK2) $(INSTALL_LIB_DIR)/$(LIB_SYMLINK1)

install-dev: install $(INSTALL_INCLUDE_DIR) $(INSTALL_PKGCONFIG_DIR)
	$(INSTALL_FILES) $(INCLUDE_DIR)/*.h $(INSTALL_INCLUDE_DIR)
	$(INSTALL_FILES) $(PKGCONFIG) $(INSTALL_PKGCONFIG_DIR)
	ln -sf $(LIB_SYMLINK1) $(INSTALL_LIB_DIR)/$(LIB_DEV_SYMLINK)

$(INSTALL_LIB_DIR):
	$(INSTALL_DIRS) $@

$(INSTALL_INCLUDE_DIR):
	$(INSTALL_DIRS) $@

$(INSTALL_PKGCONFIG_DIR):
	$(INSTALL_DIRS) $@
07070100000003000081A400000000000000000000000164304BB20000001B000000000000000000000000000000000000002600000000libglibutil-1680886706.91f2bff/READMELibrary of glib utilities.
07070100000004000041ED00000000000000000000000364304BB200000000000000000000000000000000000000000000002600000000libglibutil-1680886706.91f2bff/debian07070100000005000081A400000000000000000000000164304BB2000031B1000000000000000000000000000000000000003000000000libglibutil-1680886706.91f2bff/debian/changeloglibglibutil (1.0.69) unstable; urgency=low

* Runtime and compile time version detection
  * Added gutil_datapack module
  * Require glib 2.32

-- Slava Monich <slava@monich.com>  Thu, 06 Apr 2023 02:13:48 +0300

libglibutil (1.0.68) unstable; urgency=low

* Added gutil_weakref module
  * Fixed a few compilation warnings
  * Packaging tweaks

-- Slava Monich <slava@monich.com>  Sat, 04 Feb 2023 04:26:45 +0200

libglibutil (1.0.67) unstable; urgency=low

* Added gutil_log_dump_bytes()

-- Slava Monich <slava.monich@jolla.com>  Fri, 15 Jul 2022 03:02:33 +0300

libglibutil (1.0.66) unstable; urgency=low

* Bumped debhelper compat level to 7

-- Slava Monich <slava.monich@jolla.com>  Fri, 15 Jul 2022 03:02:33 +0300

libglibutil (1.0.65) unstable; urgency=low

* Fixed a Musl compatibility issue

-- Slava Monich <slava.monich@jolla.com>  Thu, 16 Jun 2022 02:12:22 +0300

libglibutil (1.0.64) unstable; urgency=low

* Resolved a mysterious parallel build issue

-- Slava Monich <slava.monich@jolla.com>  Tue, 17 May 2022 03:56:50 +0300

libglibutil (1.0.63) unstable; urgency=low

* Added gutil_bytes_has_prefix()
  * Added gutil_bytes_has_suffix()

-- Slava Monich <slava.monich@jolla.com>  Sat, 23 Apr 2022 21:24:25 +0300

libglibutil (1.0.62) unstable; urgency=low

* Added gutil_strlen0()
  * Added gutil_strv_find_last()
  * Added gutil_strv_remove_dups()

-- Slava Monich <slava.monich@jolla.com>  Sun, 13 Mar 2022 21:59:26 +0200

libglibutil (1.0.61) unstable; urgency=low

* Added gutil_strv_remove()

-- Slava Monich <slava.monich@jolla.com>  Thu, 25 Nov 2021 18:31:18 +0200

libglibutil (1.0.60) unstable; urgency=low

* Housekeeping release

-- Slava Monich <slava.monich@jolla.com>  Mon, 22 Nov 2021 23:37:14 +0200

libglibutil (1.0.58) unstable; urgency=low

* Don't check upper bound when setting log level from the envvironment

-- Slava Monich <slava.monich@jolla.com>  Wed, 17 Nov 2021 13:17:45 +0200

libglibutil (1.0.57) unstable; urgency=low

* Fixed unit tests for older 32-bit systems

-- Slava Monich <slava.monich@jolla.com>  Mon, 08 Nov 2021 02:28:37 +0200

libglibutil (1.0.56) unstable; urgency=low

* Added gutil_parse_int64()
  * Added gutil_parse_uint64()

-- Slava Monich <slava.monich@jolla.com>  Sun, 03 Oct 2021 20:18:15 +0300

libglibutil (1.0.55) unstable; urgency=low

* Added gutil_log_dump()
  * Added gutil_range_init_with_bytes()
  * Added gutil_range_has_prefix()
  * Added gutil_range_skip_prefix()

-- Slava Monich <slava.monich@jolla.com>  Sun, 23 May 2021 03:33:58 +0300

libglibutil (1.0.54) unstable; urgency=low

* Added GUtilRange type
  * Tweaked interpretation of environment variables

-- Slava Monich <slava.monich@jolla.com>  Mon, 17 May 2021 16:06:25 +0300

libglibutil (1.0.53) unstable; urgency=low

* Optimized gutil_parse_int()
  * Added gutil_parse_uint()

-- Slava Monich <slava.monich@jolla.com>  Wed, 05 May 2021 15:30:57 +0300

libglibutil (1.0.52) unstable; urgency=low

* Added gutil_memdup()

-- Slava Monich <slava.monich@jolla.com>  Sun, 18 Apr 2021 17:40:41 +0300

libglibutil (1.0.51) unstable; urgency=low

* Initialize default log settings from the environment
  * Disable timestamps by default
  * Added gutil_log_tid option
  * Added gutil_ptrv_free()

-- Slava Monich <slava.monich@jolla.com>  Thu, 25 Feb 2021 19:36:05 +0200

libglibutil (1.0.50) unstable; urgency=low

* Added gutil_ptrv_length()

-- Slava Monich <slava.monich@jolla.com>  Wed, 28 Oct 2020 17:59:10 +0200

libglibutil (1.0.49) unstable; urgency=low

* Added gutil_slice_free() macro

-- Slava Monich <slava.monich@jolla.com>  Sat, 17 Oct 2020 01:01:25 +0300

libglibutil (1.0.48) unstable; urgency=low

* Make library executable on rpm based systems

-- Slava Monich <slava.monich@jolla.com>  Mon, 31 Aug 2020 00:07:18 +0300

libglibutil (1.0.47) unstable; urgency=low

* Added gutil_strv_addv()

-- Slava Monich <slava.monich@jolla.com>  Tue, 28 Jul 2020 13:56:08 +0300

libglibutil (1.0.46) unstable; urgency=low

* Allow STRIP to be defined by the environment

-- Slava Monich <slava.monich@jolla.com>  Sat, 30 May 2020 00:02:35 +0300

libglibutil (1.0.45) unstable; urgency=low

* Support for multiple archs

-- Slava Monich <slava.monich@jolla.com>  Fri, 22 May 2020 16:11:42 +0300

libglibutil (1.0.44) unstable; urgency=low

* Adapted to side-by-side linking
  * Allow overriding CC for unit tests

-- Slava Monich <slava.monich@jolla.com>  Tue, 17 Mar 2020 19:01:45 +0200

libglibutil (1.0.43) unstable; urgency=low

* Allow specifying per-module logging function
  * Added default GLogProc2 compatible callbacks

-- Slava Monich <slava.monich@jolla.com>  Fri, 20 Dec 2019 19:31:32 +0200

libglibutil (1.0.42) unstable; urgency=low

* Zero-initialize timespec::tv_nsec
  * Optimized gutil_strv_equal()

-- Slava Monich <slava.monich@jolla.com>  Fri, 22 Nov 2019 00:49:13 +0200

libglibutil (1.0.41) unstable; urgency=low

* Added gutil_bytes_equal() and gutil_bytes_equal_data()

-- Slava Monich <slava.monich@jolla.com>  Sun, 10 Nov 2019 17:14:19 +0300

libglibutil (1.0.40) unstable; urgency=low

* Added gutil_strv_bsearch()

-- Slava Monich <slava.monich@jolla.com>  Mon, 16 Sep 2019 02:22:51 +0300

libglibutil (1.0.39) unstable; urgency=low

* Allow use of CC defined by build system

-- Slava Monich <slava.monich@jolla.com>  Tue, 27 Aug 2019 13:19:56 +0300

libglibutil (1.0.38) unstable; urgency=low

* Added gutil_data_has_prefix() and gutil_data_has_suffix()

-- Slava Monich <slava.monich@jolla.com>  Thu, 01 Aug 2019 00:13:32 +0300

libglibutil (1.0.37) unstable; urgency=low

* Added gutil_bytes_concat() and gutil_bytes_xor()

-- Slava Monich <slava.monich@jolla.com>  Tue, 23 Jul 2019 21:17:18 +0300

libglibutil (1.0.36) unstable; urgency=low

* Handle empty log prefix as no prefix at all
  * Don't nullify default log name in gutil_log_set_type()

-- Slava Monich <slava.monich@jolla.com>  Thu, 13 Jun 2019 18:15:33 +0300

libglibutil (1.0.35) unstable; urgency=low

* Added gutil_strv_last() function

-- Slava Monich <slava.monich@jolla.com>  Wed, 13 Feb 2019 19:56:31 +0300

libglibutil (1.0.34) unstable; urgency=low

* Added a few more GUtilIdlePool functions:

gutil_idle_pool_destroy
    gutil_idle_pool_add_bytes
    gutil_idle_pool_add_bytes_ref

-- Slava Monich <slava.monich@jolla.com>  Wed, 07 Nov 2018 17:57:52 +0300

libglibutil (1.0.33) unstable; urgency=low

* Added GLOG_FLAG_DISABLE flag

-- Slava Monich <slava.monich@jolla.com>  Sat, 03 Nov 2018 11:47:25 +0300

libglibutil (1.0.32) unstable; urgency=low

* Added gutil_idle_pool_add_strv function

-- Slava Monich <slava.monich@jolla.com>  Sun, 14 Oct 2018 00:47:01 +0300

libglibutil (1.0.31) unstable; urgency=low

* Added GUtilData type and functions to work with it:

gutil_data_equal
    gutil_data_from_string
    gutil_data_from_bytes

-- Slava Monich <slava.monich@jolla.com>  Sat, 13 Oct 2018 13:17:45 +0300

libglibutil (1.0.30) unstable; urgency=low

* Added gutil_parse_int function

-- Slava Monich <slava.monich@jolla.com>  Fri, 20 Jul 2018 00:06:40 +0300

libglibutil (1.0.29) unstable; urgency=low

* Added gutil_hexdump function
  * Fixed dependencies for pkgconfig target

-- Slava Monich <slava.monich@jolla.com>  Tue, 13 Mar 2018 19:28:46 +0300

libglibutil (1.0.28) unstable; urgency=low

* Added gutil_idle_pool_get function

-- Slava Monich <slava.monich@jolla.com>  Sun, 25 Feb 2018 19:58:21 +0200

libglibutil (1.0.27) unstable; urgency=low

* GUtilIdlePool is not a GObject anymore
  * Took out glib-object.h from public headers

-- Slava Monich <slava.monich@jolla.com>  Sun, 25 Feb 2018 13:20:49 +0200

libglibutil (1.0.26) unstable; urgency=low

* Optimized GUtilIdleQueue

-- Slava Monich <slava.monich@jolla.com>  Sat, 25 Nov 2017 02:16:18 +0200

libglibutil (1.0.25) unstable; urgency=low

* Allow NULL module in gutil_log_enabled
  * Added test_log

-- Slava Monich <slava.monich@jolla.com>  Thu, 19 Oct 2017 19:51:05 +0300

libglibutil (1.0.24) unstable; urgency=low

* Added gutil_strv_strip function

-- Slava Monich <slava.monich@jolla.com>  Sun, 18 Jun 2017 00:27:35 +0300

libglibutil (1.0.23) unstable; urgency=low

* Added a few more GUtilIntArray functions

gutil_int_array_new_from_vals
    gutil_int_array_new_from_value
    gutil_int_array_find
    gutil_int_array_contains
    gutil_int_array_remove
    gutil_int_array_remove_fast
    gutil_int_array_remove_all
    gutil_int_array_remove_all_fast

-- Slava Monich <slava.monich@jolla.com>  Mon, 05 Jun 2017 19:01:12 +0300

libglibutil (1.0.22) unstable; urgency=low

* Added GUtilIdleQueue

-- Slava Monich <slava.monich@jolla.com>  Sun, 23 Apr 2017 18:07:46 +0300

libglibutil (1.0.21) unstable; urgency=low

* Added gutil_hex2bin and gutil_hex2bytes functions

-- Slava Monich <slava.monich@jolla.com>  Fri, 10 Mar 2017 23:36:04 +0200

libglibutil (1.0.20) unstable; urgency=low

* Added GUtilIntHistory

-- Slava Monich <slava.monich@jolla.com>  Thu, 02 Mar 2017 16:58:02 +0200

libglibutil (1.0.19) unstable; urgency=low

* Added GUtilIntArray and GUtilInts

-- Slava Monich <slava.monich@jolla.com>  Thu, 23 Feb 2017 18:37:01 +0200

libglibutil (1.0.18) unstable; urgency=low

* Allow strings longer than 512 bytes in gutil_log_syslog

-- Slava Monich <slava.monich@jolla.com>  Sat, 18 Feb 2017 20:30:23 +0200

libglibutil (1.0.17) unstable; urgency=low

* Made unit tests work with glib < 2.36

-- Slava Monich <slava.monich@jolla.com>  Fri, 06 Jan 2017 20:07:29 +0300

libglibutil (1.0.16) unstable; urgency=low

* Switched to glib test framework

-- Slava Monich <slava.monich@jolla.com>  Mon, 05 Dec 2016 18:07:41 +0200

libglibutil (1.0.15) unstable; urgency=low

* Added gutil_time_notify API

-- Slava Monich <slava.monich@jolla.com>  Mon, 28 Nov 2016 19:02:36 +0200

libglibutil (1.0.14) unstable; urgency=low

* Another check for NULL in gutil_inotify_watch_new
  * Removed unnecessary checks from gutil_inotify_ref/undef
  * Added test_inotify

-- Slava Monich <slava.monich@jolla.com>  Sat, 24 Sep 2016 17:30:39 +0300

libglibutil (1.0.13) unstable; urgency=low

* Added gutil_strv_remove_at
  * Moved common test code into a reusable module
  * Added test_misc

-- Slava Monich <slava.monich@jolla.com>  Fri, 23 Sep 2016 17:58:04 +0300

libglibutil (1.0.12) unstable; urgency=low

* Cleaned up debian build
  * Fixed test_idlepool against glib < 2.36
  * Added gutil_ring_max_size and gutil_ring_set_max_size
  * Fixed gutil_ring_flatten behavior with empty ring buffer

-- Slava Monich <slava.monich@jolla.com>  Wed, 07 Sep 2016 12:43:14 +0300

libglibutil (1.0.11) unstable; urgency=low

* Moved GLOG_MODULE_DECL from gutil_log.h to gutil_types.h

-- Slava Monich <slava.monich@jolla.com>  Sun, 10 Jul 2016 11:46:30 +0300

libglibutil (1.0.10) unstable; urgency=low

* Fixed test_idlepool
  * Added GLOG_FLAG_HIDE_NAME and gutil_log_func2

-- Slava Monich <slava.monich@jolla.com>  Fri, 13 May 2016 17:14:37 +0300

libglibutil (1.0.9) unstable; urgency=low

* Added gutil_ring_drop and gutil_ring_drop_last functions

-- Slava Monich <slava.monich@jolla.com>  Sun, 10 Apr 2016 15:20:40 +0300

libglibutil (1.0.8) unstable; urgency=low

* Added gutil_ring API

-- Slava Monich <slava.monich@jolla.com>  Fri, 08 Apr 2016 19:50:38 +0300

libglibutil (1.0.7) unstable; urgency=low

* Added gutil_idle_pool API

-- Slava Monich <slava.monich@jolla.com>  Tue, 29 Mar 2016 17:29:46 +0300

libglibutil (1.0.6) unstable; urgency=low

* Added gutil_strv_sort function
  * Added gutil_inotify_watch API

-- Slava Monich <slava.monich@jolla.com>  Sat, 05 Mar 2016 01:13:34 +0200

libglibutil (1.0.5) unstable; urgency=low

* Fixed a bug gutil_disconnect_handlers

-- Slava Monich <slava.monich@jolla.com>  Tue, 23 Feb 2016 15:00:19 +0300

libglibutil (1.0.4) unstable; urgency=low

* Added gutil_disconnect_handlers function
  * Compiled on Windows

-- Slava Monich <slava.monich@jolla.com>  Sat, 20 Feb 2016 22:58:23 +0300

libglibutil (1.0.3) unstable; urgency=low

* Added GStrV type

-- Slava Monich <slava.monich@jolla.com>  Sat, 09 Jan 2016 12:35:58 +0200

libglibutil (1.0.2) unstable; urgency=low

* Makefile cleanup
  * Removed unnecessary CR from the assert message

-- Slava Monich <slava.monich@jolla.com>  Thu, 24 Dec 2015 00:33:08 +0200

libglibutil (1.0.1) unstable; urgency=low

* Use three-digit version for pkg-config

-- Slava Monich <slava.monich@jolla.com>  Mon, 16 Nov 2015 14:01:15 +0200

libglibutil (1.0.0) unstable; urgency=low

* Initial release

-- Slava Monich <slava.monich@jolla.com>  Sat, 27 Dec 2014 22:36:32 +0200
07070100000006000081A400000000000000000000000164304BB200000002000000000000000000000000000000000000002D00000000libglibutil-1680886706.91f2bff/debian/compat7
07070100000007000081A400000000000000000000000164304BB2000001F0000000000000000000000000000000000000002E00000000libglibutil-1680886706.91f2bff/debian/controlSource: libglibutil
Section: libs
Priority: optional
Maintainer: Slava Monich <slava.monich@jolla.com>
Build-Depends: debhelper (>= 8.1.3), libglib2.0-dev (>= 2.32)
Standards-Version: 3.8.4

Package: libglibutil
Section: libs
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: Library of glib utilities

Package: libglibutil-dev
Section: libdevel
Architecture: any
Depends: libglibutil (= ${binary:Version}), ${misc:Depends}
Description: Development files for libglibutil
07070100000008000081A400000000000000000000000164304BB20000064D000000000000000000000000000000000000003000000000libglibutil-1680886706.91f2bff/debian/copyrightCopyright (C) 2014-2022 Jolla Ltd.
Copyright (C) 2023 Slava Monich <slava@monich.com>

You may use this file under the terms of BSD license as follows:

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
THE POSSIBILITY OF SUCH DAMAGE.
07070100000009000081A400000000000000000000000164304BB200000092000000000000000000000000000000000000004100000000libglibutil-1680886706.91f2bff/debian/libglibutil-dev.install.indebian/tmp/@LIBDIR@/libglibutil.so @LIBDIR@
debian/tmp/@LIBDIR@/pkgconfig/libglibutil.pc @LIBDIR@/pkgconfig
debian/tmp/usr/include/* usr/include/
0707010000000A000081A400000000000000000000000164304BB20000002E000000000000000000000000000000000000003D00000000libglibutil-1680886706.91f2bff/debian/libglibutil.install.indebian/tmp/@LIBDIR@/libglibutil.so.* @LIBDIR@
0707010000000B000081ED00000000000000000000000164304BB200000185000000000000000000000000000000000000002C00000000libglibutil-1680886706.91f2bff/debian/rules#!/usr/bin/make -f
# -*- makefile -*-

# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1

LIBDIR=usr/lib/$(shell dpkg-architecture -qDEB_HOST_MULTIARCH)

override_dh_auto_build:
	dh_auto_build -- LIBDIR=$(LIBDIR) release pkgconfig debian/libglibutil.install debian/libglibutil-dev.install

override_dh_auto_install:
	dh_auto_install -- LIBDIR=$(LIBDIR) install-dev

%:
	dh $@
0707010000000C000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002D00000000libglibutil-1680886706.91f2bff/debian/source0707010000000D000081A400000000000000000000000164304BB20000000D000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/debian/source/format3.0 (native)
0707010000000E000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002700000000libglibutil-1680886706.91f2bff/include0707010000000F000081A400000000000000000000000164304BB2000014D5000000000000000000000000000000000000003800000000libglibutil-1680886706.91f2bff/include/gutil_datapack.h/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_DATAPACK_H
#define GUTIL_DATAPACK_H

#include "gutil_types.h"

/*
 * Utilities for packing and unpacking simple data types and structures.
 *
 * Since 1.0.69
 */

G_BEGIN_DECLS

/*
 * Compact 7 bits per byte representation of a signed integer with
 * redundant sign bits removed. Most significant bit is the continuation
 * flag. Bit 0x40 in the first (most significant) byte is the sign bit.
 * Unused bits in the most significant chunk must be filled with the
 * sign bit.
 *
 * For positive numbers it's slightly less efficient than encoding unsigned
 * numbers because of one extra sign bit (e.g. unsigned number 65 can be
 * squeezed into a single byte but the signed one takes 2 bytes).
 *
 * Examples:
 *
 *  33  (0x0000000000000021) => 00100001 (0x21)
 * -33  (0xffffffffffffffdf) => 01011111 (0x5f)
 *  65  (0x0000000000000041) => 10000000 01000001 (0x80 0x41)
 * -65  (0xffffffffffffff3f) => 11111111 00111111 (0xff 0x3f)
 *  129 (0x0000000000000081) => 10000001 00000001 (0x81 0x01)
 * -129 (0xffffffffffffff7f) => 11111110 01111110 (0xfe 0x7f)
 */

guint
gutil_signed_mbn_size(
    gint64 value);

guint
gutil_signed_mbn_encode(
    gpointer buf,
    gint64 value);

guint
gutil_signed_mbn_encode2(
    gpointer buf,
    gint64 value,
    guint value_size);

gboolean
gutil_signed_mbn_decode(
    GUtilRange* in,
    gint64* out);

gboolean
gutil_signed_mbn_decode2(
    const GUtilData* in,
    gint64* out);

/*
 * Compact 7 bits per byte representation of an unsigned integer with
 * redundant zero bits removed. Most significant bit is the continuation
 * flag. Unused bits in the first byte (most significant chunk) must be
 * filled with zeros.
 *
 * Examples:
 *
 * 33  (0x0000000000000021) => 00100001 (0x21)
 * 65  (0x0000000000000041) => 01000001 (0x41)
 * 129 (0x0000000000000081) => 10000001 00000001 (0x81 0x01)
 */

guint
gutil_unsigned_mbn_size(
    guint64 value);

guint
gutil_unsigned_mbn_encode(
    gpointer buf,
    guint64 value);

guint
gutil_unsigned_mbn_encode2(
    gpointer buf,
    guint64 value,
    guint value_size);

gboolean
gutil_unsigned_mbn_decode(
    GUtilRange* in,
    guint64* out);

gboolean
gutil_unsigned_mbn_decode2(
    const GUtilData* in,
    guint64* out);

/*
 * TLV is a convenient and extendible way to pack various kinds of data
 * into a single memory block. Each entry gets encoded as follows:
 *
 * +---
 * |  T (unsigned MBN) : tag (non-zero)
 * +---
 * |  L (unsigned MBN) : length (zero if there's no data)
 * +---
 * |  V (L bytes) : tag specific data (optional)
 * +---
 *
 * To make API even more convenient, these utilities restrict the tag
 * value to INT_MAX which should be enough in most real life situations.
 * Also, these utilities assume that tags are non-zero. gutil_tlv_decode()
 * returns zero ifno TLV can be pulled out of the input data, and the
 * tags array passed to gutil_tlvs_decode() is zero terminated.
 */

typedef enum gutil_tlvs_decode_flags {
    GUTIL_TLVS_DECODE_NO_FLAGS = 0,
    GUTIL_TLVS_DECODE_FLAG_SKIP_UNKNOWN_TAGS = 0x1
} GUTIL_TLVS_DECODE_FLAGS;

guint
gutil_tlv_size(
    guint tag,
    gsize len);

gsize
gutil_tlv_encode(
    gpointer buf,
    guint tag,
    const GUtilData* val);

guint
gutil_tlv_decode(
    GUtilRange* in,
    GUtilData* val);

#define GUTIL_TLVS_DECODE_ERROR (-1)
#define GUTIL_TLVS_DECODE_DUPLICATE_TAG (-2)
#define GUTIL_TLVS_DECODE_UNKNOWN_TAG (-3)

int
gutil_tlvs_decode(
    const GUtilData* in,
    const guint* tags,
    GUtilData* vals,
    GUTIL_TLVS_DECODE_FLAGS flags);

G_END_DECLS

#endif /* GUTIL_DATAPACK_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000010000081A400000000000000000000000164304BB200000DD8000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/include/gutil_history.h/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_HISTORY_H
#define GUTIL_HISTORY_H

#include "gutil_types.h"

G_BEGIN_DECLS

/*
 * A history of values. Keeps track of no more than last X values submitted
 * within the last Y microseconds. Microsecond precision may sound like a bit
 * of an overkill but that's what glib functions like g_get_monotonic_time
 * return.
 *
 * Currently it's only useful for calculating the median but the API could
 * be extended to provide access to the individual samples, if anyone ever
 * needs that.
 *
 * Also, it's calculating median rather than the average taking into account
 * that samples are not necessarily added to the history at uniform intervals.
 * If someone needs the straight average, it's easy enough to add API for that
 * too.
 *
 * When you call gutil_int_history_add but the time hasn't changed since the
 * last gutil_int_history_add call, the last value is replaced (as opposed to
 * adding a new entry).
 */

#define GUTIL_HISTORY_SEC ((gint64)(G_USEC_PER_SEC))
typedef gint64 (*GUtilHistoryTimeFunc)(void);

GUtilIntHistory*
gutil_int_history_new(
    int max_size,
    gint64 max_interval);

GUtilIntHistory*
gutil_int_history_new_full(
    int max_size,
    gint64 max_interval,
    GUtilHistoryTimeFunc time_fn);

GUtilIntHistory*
gutil_int_history_ref(
    GUtilIntHistory* history);

void
gutil_int_history_unref(
    GUtilIntHistory* history);

guint
gutil_int_history_size(
    GUtilIntHistory* history);

gint64
gutil_int_history_interval(
    GUtilIntHistory* history);

void
gutil_int_history_clear(
    GUtilIntHistory* history);

int
gutil_int_history_add(
    GUtilIntHistory* history,
    int value);

int
gutil_int_history_median(
    GUtilIntHistory* history,
    int default_value);

G_END_DECLS

#endif /* GUTIL_HISTORY_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000011000081A400000000000000000000000164304BB200000F4F000000000000000000000000000000000000003800000000libglibutil-1680886706.91f2bff/include/gutil_idlepool.h/*
 * Copyright (C) 2016-2018 Jolla Ltd.
 * Copyright (C) 2016-2018 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_IDLEPOOL_H
#define GUTIL_IDLEPOOL_H

#include "gutil_types.h"

G_BEGIN_DECLS

/*
 * This is a glib equivalent of NSAutoreleasePool. Its purpose is to
 * temporarily hold a reference, until the next idle callback or until
 * the pool is drained manually with gutil_idle_pool_drain().
 *
 * Note that the following functions don't add references, they hold
 * the references which you have created:
 *
 * gutil_idle_pool_add_object()
 * gutil_idle_pool_add_variant()
 * gutil_idle_pool_add_ptr_array()
 * gutil_idle_pool_add_bytes()
 *
 * The following functions, however, do add the reference and hold it
 * until the pool is drained:
 *
 * gutil_idle_pool_add_object_ref()
 * gutil_idle_pool_add_variant_ref()
 * gutil_idle_pool_add_ptr_array_ref()
 * gutil_idle_pool_add_bytes_ref()
 */

GUtilIdlePool*
gutil_idle_pool_new(void);

GUtilIdlePool*
gutil_idle_pool_get(
    GUtilIdlePool** shared);

GUtilIdlePool*
gutil_idle_pool_ref(
    GUtilIdlePool* pool);

void
gutil_idle_pool_unref(
    GUtilIdlePool* pool);

void
gutil_idle_pool_destroy(
    GUtilIdlePool* pool); /* Since 1.0.34 */

void
gutil_idle_pool_drain(
    GUtilIdlePool* pool);

void
gutil_idle_pool_add(
    GUtilIdlePool* pool,
    gpointer pointer,
    GDestroyNotify destroy);

void
gutil_idle_pool_add_strv(
    GUtilIdlePool* pool,
    char** strv); /* Since 1.0.32 */

void
gutil_idle_pool_add_object(
    GUtilIdlePool* pool,
    gpointer object);

void
gutil_idle_pool_add_variant(
    GUtilIdlePool* pool,
    GVariant* variant);

void
gutil_idle_pool_add_ptr_array(
    GUtilIdlePool* pool,
    GPtrArray* array);

void
gutil_idle_pool_add_bytes(
    GUtilIdlePool* pool,
    GBytes* bytes); /* Since 1.0.34 */

void
gutil_idle_pool_add_object_ref(
    GUtilIdlePool* pool,
    gpointer object);

void
gutil_idle_pool_add_variant_ref(
    GUtilIdlePool* pool,
    GVariant* variant);

void
gutil_idle_pool_add_ptr_array_ref(
    GUtilIdlePool* pool,
    GPtrArray* array);

void
gutil_idle_pool_add_bytes_ref(
    GUtilIdlePool* pool,
    GBytes* bytes); /* Since 1.0.34 */

G_END_DECLS

#endif /* GUTIL_IDLEPOOL_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000012000081A400000000000000000000000164304BB200000C1A000000000000000000000000000000000000003900000000libglibutil-1680886706.91f2bff/include/gutil_idlequeue.h/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_IDLEQUEUE_H
#define GUTIL_IDLEQUEUE_H

#include "gutil_types.h"

G_BEGIN_DECLS

/*
 * GUtilIdleQueue allows to queue idle callbacks, tag them, cancel
 * individual callbacks or all of them.
 */

typedef gsize GUtilIdleQueueTag;

typedef
void
(*GUtilIdleFunc)(
    gpointer data);

GUtilIdleQueue*
gutil_idle_queue_new(void);

void
gutil_idle_queue_free(
    GUtilIdleQueue* queue);

GUtilIdleQueue*
gutil_idle_queue_ref(
    GUtilIdleQueue* queue);

void
gutil_idle_queue_unref(
    GUtilIdleQueue* queue);

void
gutil_idle_queue_add(
    GUtilIdleQueue* queue,
    GUtilIdleFunc run,
    gpointer data);

void
gutil_idle_queue_add_full(
    GUtilIdleQueue* queue,
    GUtilIdleFunc run,
    gpointer data,
    GFreeFunc free);

void
gutil_idle_queue_add_tag(
    GUtilIdleQueue* queue,
    GUtilIdleQueueTag tag,
    GUtilIdleFunc run,
    gpointer data);

void
gutil_idle_queue_add_tag_full(
    GUtilIdleQueue* queue,
    GUtilIdleQueueTag tag,
    GUtilIdleFunc run,
    gpointer data,
    GFreeFunc free);

gboolean
gutil_idle_queue_contains_tag(
    GUtilIdleQueue* queue,
    GUtilIdleQueueTag tag);

gboolean
gutil_idle_queue_cancel_tag(
    GUtilIdleQueue* queue,
    GUtilIdleQueueTag tag);

void
gutil_idle_queue_cancel_all(
    GUtilIdleQueue* queue);

G_END_DECLS

#endif /* GUTIL_IDLEQUEUE_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000013000081A400000000000000000000000164304BB200000B20000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/include/gutil_inotify.h/*
 * Copyright (C) 2014-2018 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_INOTIFY_H
#define GUTIL_INOTIFY_H

#include "gutil_types.h"

G_BEGIN_DECLS

typedef struct gutil_inotify_watch_callback GUtilInotifyWatchCallback;

typedef void
(*GUtilInotifyWatchFunc)(
    GUtilInotifyWatch* watch,
    guint mask,
    guint cookie,
    const char* name,
    void* arg);

GUtilInotifyWatch*
gutil_inotify_watch_new(
    const char* path,
    guint32 mask);

GUtilInotifyWatch*
gutil_inotify_watch_ref(
    GUtilInotifyWatch* watch);

void
gutil_inotify_watch_unref(
    GUtilInotifyWatch* watch);

void
gutil_inotify_watch_destroy(
    GUtilInotifyWatch* watch);

gulong
gutil_inotify_watch_add_handler(
    GUtilInotifyWatch* watch,
    GUtilInotifyWatchFunc fn,
    void* arg);

void
gutil_inotify_watch_remove_handler(
    GUtilInotifyWatch* watch,
    gulong id);

GUtilInotifyWatchCallback*
gutil_inotify_watch_callback_new(
    const char* path,
    guint32 mask,
    GUtilInotifyWatchFunc fn,
    void* arg);

void
gutil_inotify_watch_callback_free(
    GUtilInotifyWatchCallback* cb);

G_END_DECLS

#endif /* GUTIL_INOTIFY_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000014000081A400000000000000000000000164304BB20000103F000000000000000000000000000000000000003800000000libglibutil-1680886706.91f2bff/include/gutil_intarray.h/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_INTARRAY_H
#define GUTIL_INTARRAY_H

#include "gutil_types.h"

G_BEGIN_DECLS

/*
 * This is basically a GArray providing better type safety at compile time.
 */
struct gutil_int_array {
    int* data;
    guint count;
};

GUtilIntArray*
gutil_int_array_new(
    void);

GUtilIntArray*
gutil_int_array_sized_new(
    guint reserved_count);

GUtilIntArray*
gutil_int_array_new_from_vals(
    const int* vals,
    guint count);

GUtilIntArray*
gutil_int_array_new_from_value(
    int value);

int*
gutil_int_array_free(
    GUtilIntArray* array,
    gboolean free_data);

GUtilInts*
gutil_int_array_free_to_ints(
    GUtilIntArray* array);

GUtilIntArray*
gutil_int_array_ref(
    GUtilIntArray* array);

void
gutil_int_array_unref(
    GUtilIntArray* array);

GUtilIntArray*
gutil_int_array_append(
    GUtilIntArray* array,
    int val);

GUtilIntArray*
gutil_int_array_append_vals(
    GUtilIntArray* array,
    const int* vals,
    guint count);

GUtilIntArray*
gutil_int_array_prepend(
    GUtilIntArray* array,
    int val);

GUtilIntArray*
gutil_int_array_prepend_vals(
    GUtilIntArray* array,
    const int* vals,
    guint count);

GUtilIntArray*
gutil_int_array_insert(
    GUtilIntArray* array,
    guint pos,
    int val);

GUtilIntArray*
gutil_int_array_insert_vals(
    GUtilIntArray* array,
    guint pos,
    const int* vals,
    guint count);

GUtilIntArray*
gutil_int_array_set_count(
    GUtilIntArray* array,
    guint count);

int
gutil_int_array_find(
    GUtilIntArray* array,
    int value);

gboolean
gutil_int_array_contains(
    GUtilIntArray* array,
    int value);

gboolean
gutil_int_array_remove(
    GUtilIntArray* array,
    int value);

gboolean
gutil_int_array_remove_fast(
    GUtilIntArray* array,
    int value);

guint
gutil_int_array_remove_all(
    GUtilIntArray* array,
    int value);

guint
gutil_int_array_remove_all_fast(
    GUtilIntArray* array,
    int value);

GUtilIntArray*
gutil_int_array_remove_index(
    GUtilIntArray* array,
    guint pos);

GUtilIntArray*
gutil_int_array_remove_index_fast(
    GUtilIntArray* array,
    guint pos);

GUtilIntArray*
gutil_int_array_remove_range(
    GUtilIntArray* array,
    guint pos,
    guint count);

void
gutil_int_array_sort_ascending(
    GUtilIntArray* array);

void
gutil_int_array_sort_descending(
    GUtilIntArray* array);

G_END_DECLS

#endif /* GUTIL_INTARRAY_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000015000081A400000000000000000000000164304BB200000BF2000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/include/gutil_ints.h/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_INTS_H
#define GUTIL_INTS_H

#include "gutil_types.h"

G_BEGIN_DECLS

/*
 * A read-only non-empty array of ints. NULL is the empty array.
 * If it's not NULL then it's not empty.
 */

GUtilInts*
gutil_ints_new(
    const int* data,
    guint count);

GUtilInts*
gutil_ints_new_take(
    int* data,
    guint count);

GUtilInts*
gutil_ints_new_static(
    const int* data,
    guint count);

GUtilInts*
gutil_ints_new_with_free_func(
    const int* data,
    guint count,
    GDestroyNotify free_func,
    gpointer user_data);

GUtilInts*
gutil_ints_new_from_ints(
    GUtilInts* ints,
    guint offset,
    guint count);

GUtilInts*
gutil_ints_ref(
    GUtilInts* ints);

void
gutil_ints_unref(
    GUtilInts* ints);

int*
gutil_ints_unref_to_data(
    GUtilInts* ints,
    guint* count);

const int*
gutil_ints_get_data(
    GUtilInts* ints,
    guint* count);

guint
gutil_ints_get_count(
    GUtilInts* ints);

int
gutil_ints_find(
    GUtilInts* ints,
    int value);

gboolean
gutil_ints_contains(
    GUtilInts* ints,
    int value);

guint
gutil_ints_hash(
    gconstpointer ints);

gboolean
gutil_ints_equal(
    gconstpointer a,
    gconstpointer b);

gint
gutil_ints_compare(
    gconstpointer a,
    gconstpointer b);

G_END_DECLS

#endif /* GUTIL_INTS_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000016000081A400000000000000000000000164304BB2000034A6000000000000000000000000000000000000003300000000libglibutil-1680886706.91f2bff/include/gutil_log.h/*
 * Copyright (C) 2014-2022 Jolla Ltd.
 * Copyright (C) 2014-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_LOG_H
#define GUTIL_LOG_H

#include "gutil_types.h"
#include <stdarg.h>

G_BEGIN_DECLS

/* Log levels */
#define GLOG_LEVEL_ALWAYS         (-2)
#define GLOG_LEVEL_INHERIT        (-1)
#define GLOG_LEVEL_NONE           (0)
#define GLOG_LEVEL_ERR            (1)
#define GLOG_LEVEL_WARN           (2)
#define GLOG_LEVEL_INFO           (3)
#define GLOG_LEVEL_DEBUG          (4)
#define GLOG_LEVEL_VERBOSE        (5)

/* Allow these to be redefined */
#ifndef GLOG_LEVEL_MAX
#  ifdef DEBUG
#    define GLOG_LEVEL_MAX        GLOG_LEVEL_VERBOSE
#  else
#    define GLOG_LEVEL_MAX        GLOG_LEVEL_DEBUG
#  endif
#endif /* GLOG_LEVEL_MAX */

#ifndef GLOG_LEVEL_DEFAULT
#  ifdef DEBUG
#    define GLOG_LEVEL_DEFAULT    GLOG_LEVEL_DEBUG
#  else
#    define GLOG_LEVEL_DEFAULT    GLOG_LEVEL_INFO
#  endif
#endif /* GLOG_LEVEL_DEFAULT */

/* Do we need a separate log level for ASSERTs? */
#ifndef GLOG_LEVEL_ASSERT
#  ifdef DEBUG
#    define GLOG_LEVEL_ASSERT     GLOG_LEVEL_ERR
#  else
     /* No asserts in release build */
#    define GLOG_LEVEL_ASSERT     (GLOG_LEVEL_MAX+1)
#  endif
#endif

/* Logging function prototypes */
#define GUTIL_DEFINE_LOG_FN(fn)  void fn(const char* name, int level, \
    const char* format, va_list va)
#define GUTIL_DEFINE_LOG_FN2(fn)  void fn(const GLogModule* module, \
    int level, const char* format, va_list va)
typedef GUTIL_DEFINE_LOG_FN((*GLogProc));
typedef GUTIL_DEFINE_LOG_FN2((*GLogProc2));

/* Log module */
struct glog_module {
    const char* name;               /* Name (used as prefix) */
    const GLogModule* parent;       /* Parent log module (optional) */
    GLogProc2 log_proc;             /* Per-module logging function (1.0.43) */
    const int max_level;            /* Maximum level defined at compile time */
    int level;                      /* Current log level */
    int flags;                      /* Flags (see below) */
    int reserved2;                  /* Reserved for future expansion */
};

#define GLOG_FLAG_HIDE_NAME  (0x01) /* Don't print the module name */
#define GLOG_FLAG_DISABLE    (0x02) /* Don't print this log */

/* Command line parsing helper. Option format is [module]:level
 * where level can be either a number or log level name ("none", err etc.) */
gboolean
gutil_log_parse_option(
    const char* opt,                /* String to parse */
    GLogModule** modules,           /* Known modules */
    int count,                      /* Number of known modules */
    GError** error);                /* Optional error message */

/* Set log type by name ("syslog", "stdout" or "glib"). This is also
 * primarily for parsing command line options */
gboolean
gutil_log_set_type(
    const char* type,
    const char* default_name);

const char*
gutil_log_get_type(
    void);

/* Generates the string containg description of log levels and list of
 * log modules. The caller must deallocate the string with g_free */
char*
gutil_log_description(
    GLogModule** modules,           /* Known modules */
    int count);                     /* Number of known modules */

/* Logging function */
void
gutil_log(
    const GLogModule* module,       /* Calling module (NULL for default) */
    int level,                      /* Message log level */
    const char* format,             /* Message format */
    ...) G_GNUC_PRINTF(3,4);        /* Followed by arguments */

void
gutil_logv(
    const GLogModule* module,
    int level,
    const char* format,
    va_list va);

void
gutil_log_dump(
    const GLogModule* module,
    int level,
    const char* prefix,
    const void* data,
    gsize size); /* Since 1.0.55 */

void
gutil_log_dump_bytes(
    const GLogModule* module,
    int level,
    const char* prefix,
    GBytes* bytes); /* Since 1.0.67 */

/* Check if logging is enabled for the specified log level */
gboolean
gutil_log_enabled(
    const GLogModule* module,
    int level);

/* Known log types */
extern const char GLOG_TYPE_STDOUT[];
extern const char GLOG_TYPE_STDERR[];
extern const char GLOG_TYPE_GLIB[];
extern const char GLOG_TYPE_CUSTOM[];
extern const char GLOG_TYPE_SYSLOG[];

/* Available log handlers */
GUTIL_DEFINE_LOG_FN(gutil_log_stdout);
GUTIL_DEFINE_LOG_FN(gutil_log_stderr);
GUTIL_DEFINE_LOG_FN(gutil_log_glib);
GUTIL_DEFINE_LOG_FN(gutil_log_syslog);
GUTIL_DEFINE_LOG_FN2(gutil_log_stdout2);  /* Since 1.0.43 */
GUTIL_DEFINE_LOG_FN2(gutil_log_stderr2);  /* Since 1.0.43 */
GUTIL_DEFINE_LOG_FN2(gutil_log_glib2);    /* Since 1.0.43 */
GUTIL_DEFINE_LOG_FN2(gutil_log_syslog2);  /* Since 1.0.43 */

/* Log configuration */
GLOG_MODULE_DECL(gutil_log_default)
extern GLogProc gutil_log_func;
extern GLogProc2 gutil_log_func2;
extern gboolean gutil_log_timestamp; /* Only affects stdout and stderr */
extern gboolean gutil_log_tid;       /* Since 1.0.51 */

/* Log module (optional) */
#define GLOG_MODULE_DEFINE_(var,name) \
  GLogModule var = {name, NULL, NULL, \
  GLOG_LEVEL_MAX, GLOG_LEVEL_INHERIT, 0, 0}
#define GLOG_MODULE_DEFINE2_(var,name,parent) \
  GLogModule var = {name, &(parent), NULL, \
  GLOG_LEVEL_MAX, GLOG_LEVEL_INHERIT, 0, 0}
#ifdef GLOG_MODULE_NAME
extern GLogModule GLOG_MODULE_NAME;
#  define GLOG_MODULE_CURRENT   (&GLOG_MODULE_NAME)
#  define GLOG_MODULE_DEFINE(name) \
    GLOG_MODULE_DEFINE_(GLOG_MODULE_NAME,name)
#  define GLOG_MODULE_DEFINE2(name,parent) \
    GLOG_MODULE_DEFINE2_(GLOG_MODULE_NAME,name,parent)
#else
#  define GLOG_MODULE_CURRENT   NULL
#endif

/* Logging macros */

#define GLOG_NOTHING ((void)0)
#define GLOG_ENABLED(level)   gutil_log_enabled(GLOG_MODULE_CURRENT,level)
#define GERRMSG(err) (((err) && (err)->message) ? (err)->message : \
  "Unknown error")

#if !defined(GLOG_VARARGS) && defined(__GNUC__)
#  define GLOG_VARARGS
#endif

#ifndef GLOG_VARARGS
#  define GLOG_VA_FN(x) _gutil_log_##x
#  define GLOG_VA_NONE(x) G_INLINE_FUNC \
    void GLOG_VA_FN(x)(const char* f, ...) {}
#  define GLOG_VA(x) GLOG_VA_(GLOG_VA_FN(x),x)
#  define GLOG_VA_(fn,x) G_INLINE_FUNC \
    void fn(const char* f, ...) { \
    if (f && f[0]) {                                                    \
        va_list va; va_start(va,f);                                     \
        gutil_logv(GLOG_MODULE_CURRENT, GLOG_LEVEL_##x, f, va);         \
        va_end(va);                                                     \
    }                                                                   \
}
#endif /* GLOG_VARARGS */

#define GUTIL_LOG_ANY           (GLOG_LEVEL_MAX >= GLOG_LEVEL_NONE)
#define GUTIL_LOG_ERR           (GLOG_LEVEL_MAX >= GLOG_LEVEL_ERR)
#define GUTIL_LOG_WARN          (GLOG_LEVEL_MAX >= GLOG_LEVEL_WARN)
#define GUTIL_LOG_INFO          (GLOG_LEVEL_MAX >= GLOG_LEVEL_INFO)
#define GUTIL_LOG_DEBUG         (GLOG_LEVEL_MAX >= GLOG_LEVEL_DEBUG)
#define GUTIL_LOG_VERBOSE       (GLOG_LEVEL_MAX >= GLOG_LEVEL_VERBOSE)
#define GUTIL_LOG_ASSERT        (GLOG_LEVEL_MAX >= GLOG_LEVEL_ASSERT)

#if GUTIL_LOG_ASSERT
void
gutil_log_assert(
    const GLogModule* module, /* Calling module (NULL for default) */
    int level,                /* Assert log level */
    const char* expr,         /* Assert expression */
    const char* file,         /* File name */
    int line);                /* Line number */
#  define GASSERT(expr)         ((expr) ? GLOG_NOTHING : \
   gutil_log_assert(GLOG_MODULE_CURRENT, GLOG_LEVEL_ASSERT, \
   #expr, __FILE__, __LINE__))
#  define GVERIFY(expr)         GASSERT(expr)
#  define GVERIFY_FALSE(expr)   GASSERT(!(expr))
#  define GVERIFY_EQ(expr,val)  GASSERT((expr) == (val))
#  define GVERIFY_NE(expr,val)  GASSERT((expr) != (val))
#  define GVERIFY_GE(expr,val)  GASSERT((expr) >= (val))
#  define GVERIFY_GT(expr,val)  GASSERT((expr) >  (val))
#  define GVERIFY_LE(expr,val)  GASSERT((expr) <= (val))
#  define GVERIFY_LT(expr,val)  GASSERT((expr) <  (val))
#else
#  define GASSERT(expr)
#  define GVERIFY(expr)         (expr)
#  define GVERIFY_FALSE(expr)   (expr)
#  define GVERIFY_EQ(expr,val)  (expr)
#  define GVERIFY_NE(expr,val)  (expr)
#  define GVERIFY_GE(expr,val)  (expr)
#  define GVERIFY_GT(expr,val)  (expr)
#  define GVERIFY_LE(expr,val)  (expr)
#  define GVERIFY_LT(expr,val)  (expr)
#endif

#ifdef GLOG_VARARGS
#  if GUTIL_LOG_ERR
#    define GERR(f,args...)     gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_ERR, f, ##args)
#    define GERR_(f,args...)    gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_ERR, "%s() " f, __FUNCTION__, ##args)
#  else
#    define GERR(f,args...)     GLOG_NOTHING
#    define GERR_(f,args...)    GLOG_NOTHING
#  endif /* GUTIL_LOG_ERR */
#else
#  define GERR_                 GERR
#  define GERR                  GLOG_VA_FN(ERR)
#  if GUTIL_LOG_ERR
     GLOG_VA(ERR)
#  else
     GLOG_VA_NONE(ERR)
#  endif /* GUTIL_LOG_ERR */
#endif /* GLOG_VARARGS */

#ifdef GLOG_VARARGS
#  if GUTIL_LOG_WARN
#    define GWARN(f,args...)    gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_WARN, f, ##args)
#    define GWARN_(f,args...)   gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_WARN, "%s() " f, __FUNCTION__, ##args)
#  else
#    define GWARN(f,args...)    GLOG_NOTHING
#    define GWARN_(f,args...)   GLOG_NOTHING
#  endif /* GUTIL_LOGL_WARN */
#else
#  define GWARN_                GWARN
#  define GWARN                 GLOG_VA_FN(WARN)
#  if GUTIL_LOG_WARN
     GLOG_VA(WARN)
#  else
     GLOG_VA_NONE(WARN)
#  endif /* GUTIL_LOGL_WARN */
#  endif /* GLOG_VARARGS */

#ifdef GLOG_VARARGS
#  if GUTIL_LOG_INFO
#    define GINFO(f,args...)    gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_INFO, f, ##args)
#    define GINFO_(f,args...)   gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_INFO, "%s() " f, __FUNCTION__, ##args)
#  else
#    define GINFO(f,args...)    GLOG_NOTHING
#    define GINFO_(f,args...)   GLOG_NOTHING
#  endif /* GUTIL_LOG_INFO */
#else
#  define GINFO_                GINFO
#  define GINFO                 GLOG_VA_FN(INFO)
#  if GUTIL_LOG_INFO
     GLOG_VA(INFO)
#  else
     GLOG_VA_NONE(INFO)
#  endif /* GUTIL_LOG_INFO */
#endif /* GLOG_VARARGS */

#ifdef GLOG_VARARGS
#  if GUTIL_LOG_DEBUG
#    define GDEBUG(f,args...)   gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_DEBUG, f, ##args)
#    define GDEBUG_(f,args...)  gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_DEBUG, "%s() " f, __FUNCTION__, ##args)
#    define GDEBUG_DUMP(buf,n)  gutil_log_dump(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_DEBUG, NULL, buf, n) /* Since 1.0.55 */
#    define GDEBUG_DUMP_BYTES(b) gutil_log_dump_bytes(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_DEBUG, NULL, b) /* Since 1.0.67 */
#  else
#    define GDEBUG(f,args...)   GLOG_NOTHING
#    define GDEBUG_(f,args...)  GLOG_NOTHING
#    define GDEBUG_DUMP(buf,n)  GLOG_NOTHING /* Since 1.0.55 */
#    define GDEBUG_DUMP_BYTES(b) GLOG_NOTHING /* Since 1.0.67 */
#  endif /* GUTIL_LOG_DEBUG */
#else
#  define GDEBUG_               GDEBUG
#  define GDEBUG                GLOG_VA_FN(debug)
#  if GUTIL_LOG_DEBUG
     GLOG_VA_(GDEBUG,DEBUG)
#  else
     GLOG_VA_NONE_(GDEBUG,DEBUG)
#  endif /* GUTIL_LOG_DEBUG */
#endif /* GLOG_VARARGS */

#ifdef GLOG_VARARGS
#  if GUTIL_LOG_VERBOSE
#    define GVERBOSE(f,args...)  gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_VERBOSE, f, ##args)
#    define GVERBOSE_(f,args...) gutil_log(GLOG_MODULE_CURRENT, \
       GLOG_LEVEL_VERBOSE, "%s() " f, __FUNCTION__, ##args)
#  else
#    define GVERBOSE(f,args...)  GLOG_NOTHING
#    define GVERBOSE_(f,args...) GLOG_NOTHING
#  endif /* GUTIL_LOG_VERBOSE */
#else
#  define GVERBOSE_              GVERBOSE
#  define GVERBOSE               GLOG_VA_FN(VERBOSE)
#  if GUTIL_LOG_VERBOSE
     GLOG_VA(VERBOSE)
#  else
     GLOG_VA_NONE(VERBOSE)
#  endif /* GUTIL_LOG_VERBOSE */
#endif /* GLOG_VARARGS */

G_END_DECLS

#endif /* GUTIL_LOG_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000017000081A400000000000000000000000164304BB20000090A000000000000000000000000000000000000003600000000libglibutil-1680886706.91f2bff/include/gutil_macros.h/*
 * Copyright (C) 2014-2020 Jolla Ltd.
 * Copyright (C) 2014-2020 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_MACROS_H
#define GUTIL_MACROS_H

#include <gutil_types.h>

#define G_CAST(address,type,field) \
    ((type *)((guint8*)(address) - G_STRUCT_OFFSET(type,field)))

#define G_ALIGN2(value) (((value)+1) & ~1)
#define G_ALIGN4(value) (((value)+3) & ~3)
#define G_ALIGN8(value) (((value)+7) & ~7)

#ifdef __GNUC__
#  define G_PACKED __attribute__((packed))
#else
#  define G_PACKED
#endif

#define gutil_slice_free(x) g_slice_free1(sizeof(*(x)), x)  /* Since 1.0.49 */

#endif /* GUTIL_MACROS_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000018000081A400000000000000000000000164304BB200001197000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/include/gutil_misc.h/*
 * Copyright (C) 2016-2022 Jolla Ltd.
 * Copyright (C) 2016-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_MISC_H
#define GUTIL_MISC_H

#include "gutil_types.h"

G_BEGIN_DECLS

void
gutil_disconnect_handlers(
    gpointer instance,
    gulong* ids,
    int count);

void*
gutil_hex2bin(
    const char* str,
    gssize len,
    void* data);

GBytes*
gutil_hex2bytes(
    const char* str,
    gssize len);

#define GUTIL_HEXDUMP_BUFSIZE  (70)
#define GUTIL_HEXDUMP_MAXBYTES (16)

guint
gutil_hexdump(
    char* buf,
    const void* data,
    guint size); /* Since 1.0.29 */

gboolean
gutil_parse_int(
    const char* str,
    int base,
    int* value); /* Since 1.0.30 */

gboolean
gutil_parse_uint(
    const char* str,
    int base,
    unsigned int* value); /* Since 1.0.53 */

gboolean
gutil_parse_int64(
    const char* str,
    int base,
    gint64* value); /* Since 1.0.56 */

gboolean
gutil_parse_uint64(
    const char* str,
    int base,
    guint64* value); /* Since 1.0.56 */

gboolean
gutil_data_equal(
    const GUtilData* data1,
    const GUtilData* data2); /* Since 1.0.31 */

gboolean
gutil_data_has_prefix(
    const GUtilData* data,
    const GUtilData* prefix); /* Since 1.0.38 */

gboolean
gutil_data_has_suffix(
    const GUtilData* data,
    const GUtilData* suffix); /* Since 1.0.38 */

const GUtilData*
gutil_data_from_string(
    GUtilData* data,
    const char* str); /* Since 1.0.31 */

const GUtilData*
gutil_data_from_bytes(
    GUtilData* data,
    GBytes* bytes); /* Since 1.0.31 */

GBytes*
gutil_bytes_concat(
    GBytes* bytes,
    ...) /* Since 1.0.37 */
    G_GNUC_WARN_UNUSED_RESULT
    G_GNUC_NULL_TERMINATED;

GBytes*
gutil_bytes_xor(
    GBytes* bytes1,
    GBytes* bytes2); /* Since 1.0.37 */

gboolean
gutil_bytes_equal(
    GBytes* bytes,
    const void* data,
    gsize size); /* Since 1.0.41 */

gboolean
gutil_bytes_equal_data(
    GBytes* bytes,
    const GUtilData* data); /* Since 1.0.41 */

gboolean
gutil_bytes_has_prefix(
    GBytes* bytes,
    const void* data,
    gsize size); /* Since 1.0.63 */

gboolean
gutil_bytes_has_suffix(
    GBytes* bytes,
    const void* data,
    gsize size); /* Since 1.0.63 */

gsize
gutil_ptrv_length(
    const void* ptrv); /* Since 1.0.50 */

void
gutil_ptrv_free(
    void** ptrv); /* Since 1.0.51 */

void*
gutil_memdup(
    const void* ptr,
    gsize size); /* Since 1.0.52 */

gsize
gutil_strlen0(
    const char* str); /* Since 1.0.62 */

gsize
gutil_range_init_with_bytes(
    GUtilRange* range,
    GBytes* bytes); /* Since 1.0.55 */

gboolean
gutil_range_has_prefix(
    const GUtilRange* range,
    const GUtilData* prefix); /* Since 1.0.55 */

gboolean
gutil_range_skip_prefix(
    GUtilRange* range,
    const GUtilData* prefix); /* Since 1.0.55 */

G_END_DECLS

#endif /* GUTIL_MISC_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000019000081A400000000000000000000000164304BB200000DF7000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/include/gutil_ring.h/*
 * Copyright (C) 2016-2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_RING_H
#define GUTIL_RING_H

#include "gutil_types.h"

G_BEGIN_DECLS

/*
 * GLib-style "first in, first out" ring buffer.
 *
 * Note that `get' functions don't invoke the free function on the
 * elements they remove from the ring buffer. The ring buffer only
 * frees the elements it removes internally in gutil_ring_clear,
 * gutil_ring_drop functions and the last gutil_ring_unref.
 */

#define GUTIL_RING_UNLIMITED_SIZE (-1)

GUtilRing*
gutil_ring_new(void);

GUtilRing*
gutil_ring_sized_new(
    gint reserved_size,
    gint max_size);

GUtilRing*
gutil_ring_new_full(
    gint reserved_size,
    gint max_size,
    GDestroyNotify free_func);

GUtilRing*
gutil_ring_ref(
    GUtilRing* ring);

void
gutil_ring_unref(
    GUtilRing* ring);

void
gutil_ring_set_free_func(
    GUtilRing* ring,
    GDestroyNotify free_func);

gint
gutil_ring_max_size(
    GUtilRing* ring);

void
gutil_ring_set_max_size(
    GUtilRing* ring,
    gint max_size);

gint
gutil_ring_size(
    GUtilRing* ring);

void
gutil_ring_clear(
    GUtilRing* ring);

void
gutil_ring_compact(
    GUtilRing* ring);

gboolean
gutil_ring_reserve(
    GUtilRing* ring,
    gint reserved_size);

gboolean
gutil_ring_can_put(
    GUtilRing* ring,
    gint num_elements);

gboolean
gutil_ring_put(
    GUtilRing* ring,
    gpointer data);

gboolean
gutil_ring_put_front(
    GUtilRing* ring,
    gpointer data);

gpointer
gutil_ring_get(
    GUtilRing* ring);

gpointer
gutil_ring_get_last(
    GUtilRing* ring);

gint
gutil_ring_drop(
    GUtilRing* ring,
    gint count);

gint
gutil_ring_drop_last(
    GUtilRing* ring,
    gint count);

gpointer
gutil_ring_data_at(
    GUtilRing* ring,
    gint pos);

gpointer*
gutil_ring_flatten(
    GUtilRing* ring,
    gint* size);

G_END_DECLS

#endif /* GUTIL_RING_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000001A000081A400000000000000000000000164304BB2000011F7000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/include/gutil_strv.h/*
 * Copyright (C) 2014-2022 Jolla Ltd.
 * Copyright (C) 2014-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_STRV_H
#define GUTIL_STRV_H

#include "gutil_types.h"

G_BEGIN_DECLS

/**
 * NULL-tolerant version of g_strv_length
 */
guint
gutil_strv_length(
    const GStrV* sv);

/**
 * Returns i-th strings in the array, NULL if index is out of bounds.
 */
const char*
gutil_strv_at(
    const GStrV* sv,
    guint i);

/**
 * Returns the last string in the array, NULL if there's nothing there.
 */
const char*
gutil_strv_last(
    const GStrV* sv); /* Since 1.0.35 */

/**
 * Returns index of the specified string in the string array,
 * or -1 if the string is not found.
 */
int
gutil_strv_find(
    const GStrV* sv,
    const char* s);

/**
 * Returns index of the last occurrence of specified string in the string
 * array, or -1 if the string is not found.
 */
int
gutil_strv_find_last(
    const GStrV* sv,
    const char* s);  /* Since 1.0.62 */

/**
 * Checks if string array contains the specified string.
 */
gboolean
gutil_strv_contains(
    const GStrV* sv,
    const char* s);

/**
 * Appends new string to the array.
 */
GStrV*
gutil_strv_add(
    GStrV* sv,
    const char* s)
    G_GNUC_WARN_UNUSED_RESULT;

/**
 * Appends new string(s) to the array.
 */
GStrV*
gutil_strv_addv(
    GStrV* sv,
    const char* s,
    ...) /* Since 1.0.47 */
    G_GNUC_WARN_UNUSED_RESULT
    G_GNUC_NULL_TERMINATED;

/**
 * Removes the string from the specified position in the array.
 */
GStrV*
gutil_strv_remove_at(
    GStrV* sv,
    int pos,
    gboolean free_string)
    G_GNUC_WARN_UNUSED_RESULT;

/**
 * Removes one or all matching strings from the array and frees them.
 */
GStrV*
gutil_strv_remove(
    GStrV* sv,
    const char* s,
    gboolean remove_all) /* Since 1.0.61 */
    G_GNUC_WARN_UNUSED_RESULT;

#define gutil_strv_remove_one(sv, s) gutil_strv_remove(sv, s, FALSE)
#define gutil_strv_remove_all(sv, s) gutil_strv_remove(sv, s, TRUE)

/**
 * Checks two string arrays for equality.
 */
gboolean
gutil_strv_equal(
    const GStrV* sv1,
    const GStrV* sv2);

/**
 * Removes all duplicates from the string array.
 */
GStrV*
gutil_strv_remove_dups(
    GStrV* sv); /* Since 1.0.62 */

/**
 * Sorts the string array
 */
GStrV*
gutil_strv_sort(
    GStrV* sv,
    gboolean ascending);

/**
 * Removes leading and trailing whitespaces from all strings in the vector.
 */
GStrV*
gutil_strv_strip(
    GStrV* sv);

G_END_DECLS

#endif /* GUTIL_STRV_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000001B000081A400000000000000000000000164304BB200000951000000000000000000000000000000000000003A00000000libglibutil-1680886706.91f2bff/include/gutil_timenotify.h/*
 * Copyright (C) 2016-2018 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_TIMENOTIFY_H
#define GUTIL_TIMENOTIFY_H

#include "gutil_types.h"

G_BEGIN_DECLS

typedef void
(*GUtilTimeNotifyFunc)(
    GUtilTimeNotify* notify,
    void* arg);

GUtilTimeNotify*
gutil_time_notify_new(
    void);

GUtilTimeNotify*
gutil_time_notify_ref(
    GUtilTimeNotify* notify);

void
gutil_time_notify_unref(
    GUtilTimeNotify* notify);

gulong
gutil_time_notify_add_handler(
    GUtilTimeNotify* notify,
    GUtilTimeNotifyFunc fn,
    void* arg);

void
gutil_time_notify_remove_handler(
    GUtilTimeNotify* notify,
    gulong id);

G_END_DECLS

#endif /* GUTIL_TIMENOTIFY_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000001C000081A400000000000000000000000164304BB200000A80000000000000000000000000000000000000003500000000libglibutil-1680886706.91f2bff/include/gutil_types.h/*
 * Copyright (C) 2014-2021 Jolla Ltd.
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_TYPES_H
#define GUTIL_TYPES_H

#include <glib.h>
#include <string.h>
#include <stdio.h>

G_BEGIN_DECLS

typedef char* GStrV;
typedef struct gutil_idle_pool GUtilIdlePool;
typedef struct gutil_idle_queue GUtilIdleQueue;
typedef struct gutil_ints GUtilInts;
typedef struct gutil_int_array GUtilIntArray;
typedef struct gutil_int_history GUtilIntHistory;
typedef struct gutil_inotify_watch GUtilInotifyWatch;
typedef struct gutil_ring GUtilRing;
typedef struct gutil_time_notify GUtilTimeNotify;
typedef struct gutil_weakref GUtilWeakRef; /* Since 1.0.68 */

typedef struct gutil_data {
    const guint8* bytes;
    gsize size;
} GUtilData;

typedef struct gutil_range {
    const guint8* ptr;
    const guint8* end;
} GUtilRange; /* Since 1.0.54 */

#define GLOG_MODULE_DECL(m) extern GLogModule m;
typedef struct glog_module GLogModule;

G_END_DECLS

#endif /* GUTIL_TYPES_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000001D000081A400000000000000000000000164304BB200000C3A000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/include/gutil_version.h/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_VERSION_H
#define GUTIL_VERSION_H

#include "gutil_types.h"

/*
 * GUTIL_VERSION_X_Y_Z macros will be added with each release. The fact that
 * such macro is defined means that you're compiling against libgutil version
 * X.Y.Z or greater.
 *
 * Since 1.0.69
 */

G_BEGIN_DECLS

#define GUTIL_VERSION_MAJOR   1
#define GUTIL_VERSION_MINOR   0
#define GUTIL_VERSION_MICRO   69
#define GUTIL_VERSION_STRING  "1.0.69"

extern const guint gutil_version_major; /* GUTIL_VERSION_MAJOR */
extern const guint gutil_version_minor; /* GUTIL_VERSION_MINOR */
extern const guint gutil_version_micro; /* GUTIL_VERSION_MICRO */

/* Version as a single word */
#define GUTIL_VERSION_(v1,v2,v3) \
    ((((v1) & 0x7f) << 24) | \
     (((v2) & 0xfff) << 12) | \
      ((v3) & 0xfff))

#define GUTIL_VERSION_MAJOR_(v)   (((v) >> 24) & 0x7f)
#define GUTIL_VERSION_MINOR_(v)   (((v) >> 12) & 0xfff)
#define GUTIL_VERSION_MICRO_(v)   (((v) & 0xfff))

/* Current compile time version as a single word */
#define GUTIL_VERSION GUTIL_VERSION_ \
    (GUTIL_VERSION_MAJOR, GUTIL_VERSION_MINOR, GUTIL_VERSION_MICRO)

/* Runtime version as a single word */
#define gutil_version() GUTIL_VERSION_ \
    (gutil_version_major, gutil_version_minor, gutil_version_micro)

/* Specific versions */
#define GUTIL_VERSION_1_0_69 GUTIL_VERSION_(1,0,69)

G_END_DECLS

#endif /* GUTIL_VERSION_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000001E000081A400000000000000000000000164304BB200000A91000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/include/gutil_weakref.h/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef GUTIL_WEAKREF_H
#define GUTIL_WEAKREF_H

#include "gutil_types.h"

/*
 * Ref-countable weak reference can be used to avoid calling g_weak_ref_set()
 * too often because it grabs global weak_locations_lock for exclusive access.
 * Note that g_weak_ref_set() is also invoked internally by g_weak_ref_init()
 * and g_weak_ref_clear().
 *
 * g_weak_ref_get() on the other hand only acquires weak_locations_lock
 * for read-only access which is less of a bottleneck in a multi-threaded
 * environment. And it's generally significantly simpler and faster than
 * g_weak_ref_set().
 *
 * Since 1.0.68
 */

G_BEGIN_DECLS

GUtilWeakRef*
gutil_weakref_new(
    gpointer obj);

GUtilWeakRef*
gutil_weakref_ref(
    GUtilWeakRef* ref);

void
gutil_weakref_unref(
    GUtilWeakRef* ref);

gpointer
gutil_weakref_get(
    GUtilWeakRef* ref);

void
gutil_weakref_set(
    GUtilWeakRef* ref,
    gpointer obj);

G_END_DECLS

#endif /* GUTIL_WEAKREF_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000001F000081A400000000000000000000000164304BB2000000E8000000000000000000000000000000000000003100000000libglibutil-1680886706.91f2bff/libglibutil.pc.inname=glibutil
libdir=@libdir@
includedir=/usr/include

Name: libglibutil
Description: Library of glib utilities
Version: @version@
Requires.private: glib-2.0
Libs: -L${libdir} -l${name}
Cflags: -I${includedir} -I${includedir}/gutil
07070100000020000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002300000000libglibutil-1680886706.91f2bff/rpm07070100000021000081A400000000000000000000000164304BB2000004FF000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/rpm/libglibutil.specName: libglibutil

Version: 1.0.69
Release: 0
Summary: Library of glib utilities
License: BSD
URL: https://github.com/sailfishos/libglibutil
Source: %{name}-%{version}.tar.bz2

%define glib_version 2.32

BuildRequires: pkgconfig
BuildRequires: pkgconfig(glib-2.0) >= %{glib_version}

# license macro requires rpm >= 4.11
BuildRequires: pkgconfig(rpm)
%define license_support %(pkg-config --exists 'rpm >= 4.11'; echo $?)

Requires: glib2 >= %{glib_version}
Requires(post): /sbin/ldconfig
Requires(postun): /sbin/ldconfig

%description
Provides glib utility functions and macros

%package devel
Summary: Development library for %{name}
Requires: %{name} = %{version}
Requires: pkgconfig(glib-2.0) >= %{glib_version}

%description devel
This package contains the development library for %{name}.

%prep
%setup -q

%build
make %{_smp_mflags} LIBDIR=%{_libdir} KEEP_SYMBOLS=1 release pkgconfig

%install
make LIBDIR=%{_libdir} DESTDIR=%{buildroot} install-dev

%check
make -C test test

%post -p /sbin/ldconfig

%postun -p /sbin/ldconfig

%files
%defattr(-,root,root,-)
%{_libdir}/%{name}.so.*
%if %{license_support} == 0
%license LICENSE
%endif

%files devel
%defattr(-,root,root,-)
%dir %{_includedir}/gutil
%{_libdir}/pkgconfig/*.pc
%{_libdir}/%{name}.so
%{_includedir}/gutil/*.h
07070100000022000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002300000000libglibutil-1680886706.91f2bff/src07070100000023000081A400000000000000000000000164304BB20000338A000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/src/gutil_datapack.c/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_datapack.h"

guint
gutil_signed_mbn_size(
    gint64 value)
{
    guint n = 1, msc = (value & 0x7f); /* Most Significant Chunk */

value >>= 7;
    if (value < 0) {
        while (value != -1) {
            msc = (value & 0x7f);
            value >>= 7;
            n++;
        }
        if (!(msc & 0x40)) {
            n++; /* Sign bit didn't fit */
        }
    } else {
        while (value) {
            msc = (value & 0x7f);
            value >>= 7;
            n++;
        }
        if (msc & 0x40) {
            n++; /* Sign bit didn't fit */
        }
    }
    return n;
}

guint
gutil_signed_mbn_encode(
    gpointer buf,
    gint64 value)
{
    return gutil_signed_mbn_encode2(buf, value,
        gutil_signed_mbn_size(value));
}

guint
gutil_signed_mbn_encode2(
    gpointer buf,
    gint64 value,
    guint size)
{
    guchar* ptr = buf;

/* Zero or too large size must be a programming error.  */
    if (size > 0) {
        guint n = size;

ptr[--n] = (guchar)(value & 0x7f);
        value >>= 7;
        while (n) {
            ptr[--n] = (guchar)(value | 0x80);
            value >>= 7;
        }

if (value < 0) {
            const int maxbits = sizeof(value) * 8;

/* Special treatment of negative numbers */
            if (size * 7 > maxbits) {
                /* Extend the sign bit */
                ptr[0] |= ~((1 << (maxbits - (size - 1) * 7)) - 1);
            }
        }
    }
    return size;
}

gboolean
gutil_signed_mbn_decode(
    GUtilRange* in,
    gint64* out)
{
    if (in->ptr < in->end) {
        guchar last = in->ptr[0];

if (last & 0x80) {
            const int maxbits = sizeof(*out) * 8;
            const guchar msc = last; /* Most Significant Chunk */
            int nbits = 7;
            guint off = 1;
            guint64 value = (last & 0x7f);

while ((in->ptr + off) < in->end &&
                   ((last = in->ptr[off++]) & 0x80)) {
                value = (value << 7) | (last & 0x7f);
                if ((nbits + 7) <= maxbits) {
                    nbits += 7;
                } else {
                    /* Too many bytes */
                    return FALSE;
                }
            }

if (!(last & 0x80)) {
                value = (value << 7) | last;
                if (msc & 0x40) {
                    /* Negative number */
                    if ((nbits + 7) < maxbits) {
                        /* Extend the sign bit */
                        if (out) {
                            *out = value | ~((G_GINT64_CONSTANT(1) <<
                                (nbits + 7)) - 1);
                        }
                        in->ptr += off;
                        return TRUE;
                    } else {
                        /* Unused bits must be set to 1 */
                        if ((msc | ((1 << (maxbits - nbits)) - 1)) == 0xff) {
                            if (out) {
                                *out = value;
                            }
                            in->ptr += off;
                            return TRUE;
                        }
                    }
                } else {
                    /* Positive number, unused bits (if any) must be zeroed */
                    /* Unused bits must be zeroed */
                    if ((nbits + 7) < maxbits ||
                        (msc & ~((1 << (maxbits - nbits)) - 1)) == 0x80) {
                        if (out) {
                            *out = value;
                        }
                        in->ptr += off;
                        return TRUE;
                    }
                }
            }
            /* Broken sequence */
        } else {
            /* Single byte, very common case */
            if (out) {
                if ((*out = *in->ptr++) & 0x40) {
                    /* Small negative number */
                    *out |= (G_GINT64_CONSTANT(-1) ^ 0x7f);
                }
            } else {
                in->ptr++;
            }
            return TRUE;
        }
    }
    return FALSE;
}

gboolean
gutil_signed_mbn_decode2(
    const GUtilData* data,
    gint64* out)
{
    if (data && data->size) {
        GUtilRange in;
        gint64 value;

in.end = (in.ptr = data->bytes) + data->size;
        if (gutil_signed_mbn_decode(&in, &value) && in.ptr == in.end) {
            if (out) {
                *out = value;
            }
            return TRUE;
        }
    }
    return FALSE;
}

guint
gutil_unsigned_mbn_size(
    guint64 value)
{
    guint n;

value >>= 7;
    for (n = 1; value; n++) {
        value >>= 7;
    }
    return n;
}

guint
gutil_unsigned_mbn_encode(
    gpointer buf,
    guint64 value)
{
    return gutil_unsigned_mbn_encode2(buf, value,
        gutil_unsigned_mbn_size(value));
}

guint
gutil_unsigned_mbn_encode2(
    gpointer buf,
    guint64 value,
    guint size)
{
    guchar* ptr = buf;

/* Zero or too large size must be a programming error.  */
    if (size > 0) {
        guint n = size;

ptr[--n] = (guchar)(value & 0x7f);
        value >>= 7;
        while (n) {
            ptr[--n] = (guchar)(value | 0x80);
            value >>= 7;
        }
    }
    return size;
}

gboolean
gutil_unsigned_mbn_decode(
    GUtilRange* in,
    guint64* out)
{
    if (in->ptr < in->end) {
        guchar last = in->ptr[0];

if (!(last & 0x80)) {
                value = (value << 7) | last;
                /* Unused bits must be zeroed */
                if ((nbits + 7) < maxbits ||
                    (msc & ~((1 << (maxbits - nbits)) - 1)) == 0x80) {
                    if (out) {
                        *out = value;
                    }
                    in->ptr += off;
                    return TRUE;
                }
            }
            /* Broken sequence */
        } else {
            /* Single byte, very common case */
            if (out) {
                *out = *in->ptr++;
            } else {
                in->ptr++;
            }
            return TRUE;
        }
    }
    return FALSE;
}

gboolean
gutil_unsigned_mbn_decode2(
    const GUtilData* data,
    guint64* out)
{
    if (data && data->size) {
        GUtilRange in;
        guint64 value;

in.end = (in.ptr = data->bytes) + data->size;
        if (gutil_unsigned_mbn_decode(&in, &value) && in.ptr == in.end) {
            if (out) {
                *out = value;
            }
            return TRUE;
        }
    }
    return FALSE;
}

guint
gutil_tlv_size(
    guint tag,
    gsize len)
{
    return gutil_unsigned_mbn_size(tag) + gutil_unsigned_mbn_size(len) + len;
}

gsize
gutil_tlv_encode(
    gpointer buf,
    guint tag,
    const GUtilData* val)
{
    guchar* ptr = buf;
    const guint tag_size = gutil_unsigned_mbn_encode(ptr, tag);

ptr += tag_size;
    if (val && val->size) {
        const guint len_size = gutil_unsigned_mbn_encode(ptr, val->size);

memcpy(ptr + len_size, val->bytes, val->size);
        return tag_size + len_size + val->size;
    } else {
        ptr[0] = 0;
        return tag_size + 1;
    }
}

guint
gutil_tlv_decode(
    GUtilRange* in,
    GUtilData* val)
{
    GUtilRange tmp = *in;
    guint64 tag, len;

if (gutil_unsigned_mbn_decode(&tmp, &tag) && tag <= INT_MAX &&
        gutil_unsigned_mbn_decode(&tmp, &len) && (tmp.end - tmp.ptr) >= len) {
        if (val) {
            val->bytes = tmp.ptr;
            val->size = (gsize) len;
        }
        in->ptr = tmp.ptr + len;
        return (guint) tag;
    }
    return 0;
}

int
gutil_tlvs_decode(
    const GUtilData* in,
    const guint* tags,
    GUtilData* vals,
    GUTIL_TLVS_DECODE_FLAGS flags)
{
    /* No more than first 31 tags from the tags array are considered */
    const int max_tags = sizeof(int) * 8 - 1;
    int mask = 0;
    GUtilRange range;
    GUtilData val;
    guint tag;

range.end = (range.ptr = in->bytes) + in->size;

if (vals) {
        int n = 0;
        const guint* tag = tags;

/* Clear the output values */
        while (*tag++) n++;
        memset(vals, 0, sizeof(vals[0]) * n);
    }

while ((tag = gutil_tlv_decode(&range, &val)) != 0) {
        int i, bit = 0;

for (i = 0; tags[i] && i < max_tags; i++) {
            if (tags[i] == tag) {
                bit = 1 << i;
                break;
            }
        }

if (bit) {
            if (mask & bit) {
                return GUTIL_TLVS_DECODE_DUPLICATE_TAG;
            } else {
                mask |= bit;
                if (vals) {
                    vals[i] = val;
                }
            }
        } else if (!(flags & GUTIL_TLVS_DECODE_FLAG_SKIP_UNKNOWN_TAGS)) {
            return GUTIL_TLVS_DECODE_UNKNOWN_TAG;
        }
    }

return (range.ptr == range.end) ? mask : GUTIL_TLVS_DECODE_ERROR;
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000024000081A400000000000000000000000164304BB200001A7F000000000000000000000000000000000000003300000000libglibutil-1680886706.91f2bff/src/gutil_history.c/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_history.h"
#include "gutil_log.h"

#define GUTIL_HISTORY_DEFAULT_TIME_FUNC g_get_monotonic_time

typedef struct gutil_int_history_entry {
    gint64 time;
    int value;
} GUtilIntHistoryEntry;

struct gutil_int_history {
    gint ref_count;
    GUtilHistoryTimeFunc time;
    gint64 max_interval;
    int first;                          /* Oldest position (inclusive) */
    int last;                           /* Latest position (inclusive) */
    int max_size;                       /* Number of entries */
    GUtilIntHistoryEntry entry[1];
};

GUtilIntHistory*
gutil_int_history_new(
   int max_size,
   gint64 max_interval)
{
    return gutil_int_history_new_full(max_size, max_interval, NULL);
}

GUtilIntHistory*
gutil_int_history_new_full(
    int max_size,
    gint64 max_interval,
    GUtilHistoryTimeFunc fn)
{
    if (max_size > 0 && max_interval > 0) {
        /* 
         * We don't allow to dynamically change the maximum history size
         * so we can allocate the whole thing from a single memory block.
         */
        GUtilIntHistory* h = g_malloc0(sizeof(GUtilIntHistory) +
            (max_size-1)*sizeof(GUtilIntHistoryEntry));
        h->ref_count = 1;
        h->max_size = max_size;
        h->max_interval = max_interval;
        h->first = h->last = -1;
        h->time = fn ? fn : GUTIL_HISTORY_DEFAULT_TIME_FUNC;
        return h;
    }
    return NULL;
}

GUtilIntHistory*
gutil_int_history_ref(
    GUtilIntHistory* h)
{
    if (G_LIKELY(h)) {
        GASSERT(h->ref_count > 0);
        g_atomic_int_inc(&h->ref_count);
    }
    return h;
}

void
gutil_int_history_unref(
    GUtilIntHistory* h)
{
    if (G_LIKELY(h)) {
        GASSERT(h->ref_count > 0);
        if (g_atomic_int_dec_and_test(&h->ref_count)) {
            g_free(h);
        }
    }
}

static
gboolean
gutil_int_history_flush(
    GUtilIntHistory* h,
    const gint64 now)
{
    const gint64 cutoff = now - h->max_interval;
    if (h->entry[h->last].time >= cutoff) {
        /* At least the last entry is valid */
        while (h->entry[h->first].time < cutoff) {
            h->first = (h->first + 1) % h->max_size;
        }
        return TRUE;
    } else {
        /* The last entry has expired */
        h->last = h->first = -1;
        return FALSE;
    }
}

guint
gutil_int_history_size(
    GUtilIntHistory* h)
{
    if (G_LIKELY(h) && h->last >= 0) {
        if (gutil_int_history_flush(h, h->time())) {
            if (h->first > h->last) {
                return (h->max_size + h->last - h->first + 1);
            } else {
                GASSERT(h->last > h->first);
                return (h->last - h->first + 1);
            }
        }
    }
    return 0;
}

gint64
gutil_int_history_interval(
    GUtilIntHistory* h)
{
    if (G_LIKELY(h) && h->last >= 0) {
	const gint64 now = h->time();
        if (gutil_int_history_flush(h, now)) {
            return now - h->entry[h->first].time;
        }
    }
    return 0;
}

void
gutil_int_history_clear(
    GUtilIntHistory* h)
{
    if (G_LIKELY(h)) {
        h->last = h->first = -1;
    }
}

static
int
gutil_int_history_median_at(
    GUtilIntHistory* h,
    const gint64 now)
{
    /* The caller has already checked that the history is not empty */
    if (h->first == h->last) {
        return h->entry[h->last].value;
    } else {
        int pos = h->first;
        int v = h->entry[pos].value;
        gint64 t = h->entry[pos].time;
        gint64 dt = 0;
        gint64 area = 0;
        while (pos != h->last) {
            gint64 t1;
            int v1;
            pos = (pos + 1) % h->max_size;
            t1 = h->entry[pos].time;
            v1 = h->entry[pos].value;
            dt += t1 - t;
            area += (t1 - t)*(v + v1)/2;
            t = t1;
            v = v1;
        }
        /* Integral area divided by time */
        return (int)(area/dt);
    }
}

int
gutil_int_history_add(
    GUtilIntHistory* h,
    int value)
{
    if (G_LIKELY(h)) {
	gint64 now = h->time();
        if (h->last < 0 || !gutil_int_history_flush(h, now)) {
            h->last = h->first = 0;
        } else {
            const gint64 last_time = h->entry[h->last].time;
            if (now > last_time) {
                /* Need a new entry */
                h->last = (h->last + 1) % h->max_size;
                if (h->last == h->first) {
                    h->first = (h->first + 1) % h->max_size;
                }
            } else if (now < last_time) {
                /* Time goes back? */
                now = last_time;
            }
        }
        h->entry[h->last].time = now;
        h->entry[h->last].value = value;
        return gutil_int_history_median_at(h, now);
    }
    return 0;
}

int
gutil_int_history_median(
    GUtilIntHistory* h,
    int default_value)
{
    if (G_LIKELY(h) && h->last >= 0) {
	const gint64 now = h->time();
        if (gutil_int_history_flush(h, now)) {
            return gutil_int_history_median_at(h, now);
        }
    }
    return default_value;
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000025000081A400000000000000000000000164304BB200001B71000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/src/gutil_idlepool.c/*
 * Copyright (C) 2016-2020 Jolla Ltd.
 * Copyright (C) 2016-2020 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <gutil_idlepool.h>
#include <gutil_macros.h>
#include <gutil_log.h>

#include <glib-object.h>

typedef struct gutil_idle_pool_item GUtilIdlePoolItem;

struct gutil_idle_pool_item {
    GUtilIdlePoolItem* next;
    gpointer pointer;
    GDestroyNotify destroy;
};

struct gutil_idle_pool {
    gint ref_count;
    guint idle_id;
    GUtilIdlePoolItem* first;
    GUtilIdlePoolItem* last;
    GUtilIdlePool** shared;
};

GUtilIdlePool*
gutil_idle_pool_new()
{
    GUtilIdlePool* self = g_slice_new0(GUtilIdlePool);
    g_atomic_int_set(&self->ref_count, 1);
    return self;
}

GUtilIdlePool*
gutil_idle_pool_get(
    GUtilIdlePool** shared)
{
    if (shared) {
        if (*shared) {
            /* The object already exists */
            return *shared;
        } else {
            GUtilIdlePool* pool = gutil_idle_pool_new();
            pool->shared = shared;
            /* New shared object will destroy itself if the caller
             * doesn't reference it. */
            gutil_idle_pool_add(pool, pool, (GDestroyNotify)
                gutil_idle_pool_unref);
            *shared = pool;
            return pool;
        }
    } else {
        return gutil_idle_pool_new();
    }
}

GUtilIdlePool*
gutil_idle_pool_ref(
    GUtilIdlePool* self)
{
    if (G_LIKELY(self)) {
        GASSERT(self->ref_count > 0);
        g_atomic_int_inc(&self->ref_count);
    }
    return self;
}

void
gutil_idle_pool_unref(
    GUtilIdlePool* self)
{
    if (G_LIKELY(self)) {
        GASSERT(self->ref_count > 0);
        if (g_atomic_int_dec_and_test(&self->ref_count)) {
            /* Clear pointer to the shared instance */
            if (self->shared) *(self->shared) = NULL;
            gutil_idle_pool_drain(self);
            gutil_slice_free(self);
        }
    }
}

void
gutil_idle_pool_destroy(
    GUtilIdlePool* self) /* Since 1.0.34 */
{
    gutil_idle_pool_drain(self);
    gutil_idle_pool_unref(self);
}

void
gutil_idle_pool_drain(
    GUtilIdlePool* self)
{
    if (G_LIKELY(self)) {
        GUtilIdlePoolItem* items = self->first;
        while (items) {
            GUtilIdlePoolItem* item = items;
            self->first = self->last = NULL;
            while (item) {
                item->destroy(item->pointer);
                item = item->next;
            }
            g_slice_free_chain(GUtilIdlePoolItem, items, next);
            items = self->first;
        }
        if (self->idle_id) {
            g_source_remove(self->idle_id);
            self->idle_id = 0;
        }
    }
}

static
gboolean
gutil_idle_pool_idle(
    gpointer user_data)
{
    GUtilIdlePool* self = user_data;
    self->idle_id = 0;
    gutil_idle_pool_ref(self);
    gutil_idle_pool_drain(self);
    gutil_idle_pool_unref(self);
    return G_SOURCE_REMOVE;
}

void
gutil_idle_pool_add(
    GUtilIdlePool* self,
    gpointer pointer,
    GDestroyNotify destroy)
{
    if (G_LIKELY(self) && G_LIKELY(destroy)) {
        GUtilIdlePoolItem* item = g_slice_new(GUtilIdlePoolItem);
        item->next = NULL;
        item->pointer = pointer;
        item->destroy = destroy;
        if (self->last) {
            self->last->next = item;
        } else {
            GASSERT(!self->first);
            self->first = item;
        }
        self->last = item;
        if (!self->idle_id) {
            self->idle_id = g_idle_add(gutil_idle_pool_idle, self);
        }
    }
}

void
gutil_idle_pool_add_strv(
    GUtilIdlePool* self,
    char** strv) /* Since 1.0.32 */
{
    if (G_LIKELY(strv)) {
        gutil_idle_pool_add(self, strv, (GDestroyNotify) g_strfreev);
    }
}

void
gutil_idle_pool_add_object(
    GUtilIdlePool* self,
    gpointer object)
{
    if (G_LIKELY(object)) {
        gutil_idle_pool_add(self, G_OBJECT(object), g_object_unref);
    }
}

void
gutil_idle_pool_add_variant(
    GUtilIdlePool* self,
    GVariant* variant)
{
    if (G_LIKELY(variant)) {
        gutil_idle_pool_add(self, variant, (GDestroyNotify)g_variant_unref);
    }
}

void
gutil_idle_pool_add_ptr_array(
    GUtilIdlePool* self,
    GPtrArray* array)
{
    if (G_LIKELY(array)) {
        gutil_idle_pool_add(self, array, (GDestroyNotify)g_ptr_array_unref);
    }
}

void
gutil_idle_pool_add_bytes(
    GUtilIdlePool* self,
    GBytes* bytes) /* Since 1.0.34 */
{
    if (G_LIKELY(bytes)) {
        gutil_idle_pool_add(self, bytes, (GDestroyNotify)g_bytes_unref);
    }
}

void
gutil_idle_pool_add_object_ref(
    GUtilIdlePool* self,
    gpointer object)
{
    if (G_LIKELY(self) && G_LIKELY(object)) {
        gutil_idle_pool_add_object(self, g_object_ref(object));
    }
}

void
gutil_idle_pool_add_variant_ref(
    GUtilIdlePool* self,
    GVariant* variant)
{
    if (G_LIKELY(self) && G_LIKELY(variant)) {
        gutil_idle_pool_add_variant(self, g_variant_ref(variant));
    }
}

void
gutil_idle_pool_add_ptr_array_ref(
    GUtilIdlePool* self,
    GPtrArray* array)
{
    if (G_LIKELY(self) && G_LIKELY(array)) {
        gutil_idle_pool_add_ptr_array(self, g_ptr_array_ref(array));
    }
}

void
gutil_idle_pool_add_bytes_ref(
    GUtilIdlePool* self,
    GBytes* bytes) /* Since 1.0.34 */
{
    if (G_LIKELY(self) && G_LIKELY(bytes)) {
        gutil_idle_pool_add_bytes(self, g_bytes_ref(bytes));
    }
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000026000081A400000000000000000000000164304BB200001F32000000000000000000000000000000000000003500000000libglibutil-1680886706.91f2bff/src/gutil_idlequeue.c/*
 * Copyright (C) 2017-2020 Jolla Ltd.
 * Copyright (C) 2017-2020 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_idlequeue.h"
#include "gutil_macros.h"
#include "gutil_log.h"

typedef struct gutil_idle_queue_item GUtilIdleQueueItem;

struct gutil_idle_queue_item {
    GUtilIdleQueueItem* next;
    GUtilIdleQueueTag tag;
    gpointer data;
    GUtilIdleFunc run;
    GFreeFunc destroy;
    gboolean completed;
};

struct gutil_idle_queue {
    gint ref_count;
    guint source_id;
    GUtilIdleQueueItem* first;
    GUtilIdleQueueItem* last;
};

static
void
gutil_idle_queue_item_destroy(
    GUtilIdleQueueItem* item)
{
    GASSERT(item->completed);
    if (item->destroy) {
        item->destroy(item->data);
    }
    gutil_slice_free(item);
}

static
gboolean
gutil_idle_queue_run(
    gpointer data)
{
    GUtilIdleQueue* q = data;
    GUtilIdleQueueItem* item;
    GUtilIdleQueueItem* done = NULL;

/*
     * Mark all currently existing items as as completed. Callbacks
     * that we are about to invoke may add more items, those we are
     * not supposed to run until the next idle loop. Also, note that
     * callbacks may cancel some of the completed items, that's why
     * we can't remove them from the list just yet.
     */
    for (item = q->first; item; item = item->next) {
        item->completed = TRUE;
    }

while ((item = q->first) && item->completed) {
        /* Remove this one from the list */
        q->first = item->next;
        if (!q->first) {
            q->last = NULL;
        }

/* Place it to the "done" list */
        item->next = done;
        done = item;

/* Invoke the callbacks */
        if (item->run) {
            item->run(item->data);
        }

if (item->destroy) {
            item->destroy(item->data);
        }
    }

/* Free the completed items */
    g_slice_free_chain(GUtilIdleQueueItem, done, next);

if (q->first) {
        /* New callbacks have been added */
        return G_SOURCE_CONTINUE;
    } else {
        q->source_id = 0;
        return G_SOURCE_REMOVE;
    }
}

GUtilIdleQueue*
gutil_idle_queue_new()
{
    GUtilIdleQueue* q = g_slice_new0(GUtilIdleQueue);
    q->ref_count = 1;
    return q;
}

void
gutil_idle_queue_free(
    GUtilIdleQueue* q)
{
    gutil_idle_queue_cancel_all(q);
    gutil_idle_queue_unref(q);
}

GUtilIdleQueue*
gutil_idle_queue_ref(
    GUtilIdleQueue* q)
{
    if (G_LIKELY(q)) {
        GASSERT(q->ref_count > 0);
        g_atomic_int_inc(&q->ref_count);
    }
    return q;
}

void
gutil_idle_queue_unref(
    GUtilIdleQueue* q)
{
    if (G_LIKELY(q)) {
        GASSERT(q->ref_count > 0);
        if (g_atomic_int_dec_and_test(&q->ref_count)) {
            gutil_idle_queue_cancel_all(q);
            gutil_slice_free(q);
        }
    }
}

void
gutil_idle_queue_add(
    GUtilIdleQueue* q,
    GUtilIdleFunc run,
    gpointer data)
{
    gutil_idle_queue_add_tag_full(q, 0, run, data, NULL);
}

void
gutil_idle_queue_add_full(
    GUtilIdleQueue* q,
    GUtilIdleFunc run,
    gpointer data,
    GFreeFunc free)
{
    gutil_idle_queue_add_tag_full(q, 0, run, data, free);
}

void
gutil_idle_queue_add_tag(
    GUtilIdleQueue* q,
    GUtilIdleQueueTag tag,
    GUtilIdleFunc run,
    gpointer data)
{
    gutil_idle_queue_add_tag_full(q, tag, run, data, NULL);
}

void
gutil_idle_queue_add_tag_full(
    GUtilIdleQueue* q,
    GUtilIdleQueueTag tag,
    GUtilIdleFunc run,
    gpointer data,
    GFreeFunc destroy)
{
    if (G_LIKELY(q)) {
        GUtilIdleQueueItem* item = g_slice_new0(GUtilIdleQueueItem);

/* Fill the item */
        item->tag = tag;
        item->run = run;
        item->destroy = destroy;
        item->data = data;

/* Add it to the queue */
        if (q->last) {
            GASSERT(q->first);
            q->last->next = item;
        } else {
            GASSERT(!q->first);
            q->first = item;
        }
        q->last = item;

/* Schedule the callback if necessary */
        if (!q->source_id) {
            q->source_id = g_idle_add(gutil_idle_queue_run, q);
        }
    } else if (destroy) {
        destroy(data);
    }
}

gboolean
gutil_idle_queue_contains_tag(
    GUtilIdleQueue* q,
    GUtilIdleQueueTag tag)
{
    if (G_LIKELY(q)) {
        const GUtilIdleQueueItem* item;
        for (item = q->first; item; item = item->next) {
            if (item->tag == tag) {
                return TRUE;
            }
        }
    }
    return FALSE;
}

static
void
gutil_idle_queue_cancel_first(
    GUtilIdleQueue* q)
{
    GUtilIdleQueueItem* item = q->first;
    q->first = item->next;
    if (!q->first) {
        q->last = NULL;
    }
    gutil_idle_queue_item_destroy(item);
}

gboolean
gutil_idle_queue_cancel_tag(
    GUtilIdleQueue* q,
    GUtilIdleQueueTag tag)
{
    if (G_LIKELY(q) && q->first) {
        GUtilIdleQueueItem* item = q->first;
        if (item->tag == tag) {
            item->completed = TRUE;
            gutil_idle_queue_cancel_first(q);
            GASSERT(q->source_id);
            if (!q->first) {
                g_source_remove(q->source_id);
                q->source_id = 0;
            }
            return TRUE;
        } else {
            GUtilIdleQueueItem* prev = item;
            for (item = item->next; item; prev = item, item = item->next) {
                if (item->tag == tag) {
                    if (item->next) {
                        prev->next = item->next;
                    } else {
                        GASSERT(q->last == item);
                        prev->next = NULL;
                        q->last = prev;
                    }
                    item->completed = TRUE;
                    gutil_idle_queue_item_destroy(item);
                    return TRUE;
                }
            }
        }
    }
    return FALSE;
}

void
gutil_idle_queue_cancel_all(
    GUtilIdleQueue* q)
{
    if (G_LIKELY(q)) {
        GUtilIdleQueueItem* item;
        for (item = q->first; item; item = item->next) {
            item->completed = TRUE;
        }
        while (q->first && q->first->completed) {
            gutil_idle_queue_cancel_first(q);
        }
        if (!q->first && q->source_id) {
            g_source_remove(q->source_id);
            q->source_id = 0;
        }
    }
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000027000081A400000000000000000000000164304BB200002E0A000000000000000000000000000000000000003300000000libglibutil-1680886706.91f2bff/src/gutil_inotify.c/*
 * Copyright (C) 2014-2018 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <gutil_inotify.h>
#include <gutil_log.h>

#include <glib-object.h>

#include <sys/inotify.h>
#include <unistd.h>
#include <errno.h>

typedef struct gutil_inotify {
    int ref_count;
    int fd;
    GHashTable* watches;
    GIOChannel* io_channel;
    guint io_watch_id;
    gchar buf[sizeof(struct inotify_event) + NAME_MAX + 1];
} GUtilInotify;

typedef GObjectClass GUtilInotifyWatchClass;
typedef GUtilInotifyWatch GUtilInotifyWatch;

struct gutil_inotify_watch {
    GObject object;
    GUtilInotify* inotify;
    GUtilInotifyWatch* parent;
    guint32 mask;
    char* path;
    int wd;
};

struct gutil_inotify_watch_callback {
    GUtilInotifyWatch* watch;
    gulong id;
};

enum gutil_inotify_watch_signal {
    SIGNAL_WATCH_EVENT,
    SIGNAL_COUNT
};

#define SIGNAL_WATCH_EVENT_NAME        "gutil-inotify-watch-event"

static guint gutil_inotify_watch_signals[SIGNAL_COUNT] = { 0 };

G_DEFINE_TYPE(GUtilInotifyWatch, gutil_inotify_watch, G_TYPE_OBJECT)
#define GUTIL_INOTIFY_WATCH_TYPE (gutil_inotify_watch_get_type())
#define GUTIL_INOTIFY_WATCH(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),\
        GUTIL_INOTIFY_WATCH_TYPE, GUtilInotifyWatch))

/*==========================================================================*
 * GUtilInotify
 *==========================================================================*/

static GUtilInotify* gutil_inotify_instance = NULL;

static
GUtilInotify*
gutil_inotify_ref(
    GUtilInotify* self)
{
    GASSERT(self->ref_count > 0);
    g_atomic_int_inc(&self->ref_count);
    return self;
}

static
void
gutil_inotify_unref(
    GUtilInotify* self)
{
    GASSERT(self->ref_count > 0);
    if (g_atomic_int_dec_and_test(&self->ref_count)) {
        if (self->io_watch_id) {
            g_source_remove(self->io_watch_id);
        }
        GASSERT(!g_hash_table_size(self->watches));
        g_hash_table_destroy(self->watches);
        g_io_channel_shutdown(self->io_channel, FALSE, NULL);
        g_io_channel_unref(self->io_channel);
        close(self->fd);
        g_free(self);
        if (gutil_inotify_instance == self) {
            gutil_inotify_instance = NULL;
        }
    }
}

static
gboolean
gutil_inotify_read(
    GUtilInotify* self)
{
    gsize nbytes = 0;
    GError* error = NULL;
    g_io_channel_read_chars(self->io_channel, self->buf, sizeof(self->buf),
        &nbytes, &error);
    if (error) {
        GERR("Inotify read failed: %s", error->message);
        g_error_free(error);
        return FALSE;
    } else {
        const char* next = self->buf;
        while (nbytes > 0) {
            const struct inotify_event* event = (void*)next;
            const size_t len = sizeof(struct inotify_event) + event->len;
            const char* path = event->len ? event->name : NULL;
            GDEBUG("Inotify event 0x%04x for %s", event->mask, path);
            GASSERT(len <= nbytes);
            if (len > nbytes) {
                break;
            } else  {
                GUtilInotifyWatch* watch = g_hash_table_lookup(self->watches,
                    GINT_TO_POINTER(event->wd));
                if (watch) {
                    gutil_inotify_watch_ref(watch);
                    g_signal_emit(watch,
                        gutil_inotify_watch_signals[SIGNAL_WATCH_EVENT], 0,
                            event->mask, event->cookie, path);
                    gutil_inotify_watch_unref(watch);
                }
                next += len;
                nbytes -= len;
            }
        }
        return TRUE;
    }
}

static
gboolean
gutil_inotify_callback(
    GIOChannel* channel,
    GIOCondition condition,
    gpointer user_data)
{
    GUtilInotify* self = user_data;
    if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
        self->io_watch_id = 0;
        return G_SOURCE_REMOVE;
    } else {
        gboolean ok;
        gutil_inotify_ref(self);
        ok = (condition & G_IO_IN) && gutil_inotify_read(self);
        if (!ok) self->io_watch_id = 0;
        gutil_inotify_unref(self);
        return ok;
    }
}

static
GUtilInotify*
gutil_inotify_create(
    int fd)
{
    GIOChannel* channel = g_io_channel_unix_new(fd);
    GASSERT(channel);
    if (channel) {
        GUtilInotify* inotify = g_new(GUtilInotify, 1);
        inotify->ref_count = 1;
        inotify->fd = fd;
        inotify->io_channel = channel;
        inotify->watches = g_hash_table_new_full(g_direct_hash,
            g_direct_equal, NULL, NULL);
        g_io_channel_set_encoding(channel, NULL, NULL);
        g_io_channel_set_buffered(channel, FALSE);
        inotify->io_watch_id = g_io_add_watch(channel,
            G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
            gutil_inotify_callback, inotify);
        return inotify;
    }
    return NULL;
}

static
GUtilInotify*
gutil_inotify_new()
{
    if (gutil_inotify_instance) {
        gutil_inotify_ref(gutil_inotify_instance);
    } else {
        int fd = inotify_init();
        if (fd >= 0) {
            /* GUtilInotify takes ownership of the file descriptor */
            gutil_inotify_instance = gutil_inotify_create(fd);
            if (!gutil_inotify_instance) {
                close(fd);
            }
        } else {
            GERR("Failed to init inotify: %s", strerror(errno));
        }
    }
    return gutil_inotify_instance;
}

static
void
gutil_inotify_add_watch(
    GUtilInotify* self,
    GUtilInotifyWatch* watch)
{
    GASSERT(watch->wd >= 0);
    g_hash_table_insert(self->watches, GINT_TO_POINTER(watch->wd), watch);
}

static
void
gutil_inotify_remove_watch(
    GUtilInotify* self,
    GUtilInotifyWatch* watch)
{
    GASSERT(watch->wd >= 0);
    GVERIFY(g_hash_table_remove(self->watches, GINT_TO_POINTER(watch->wd)));
}

/*==========================================================================*
 * GUtilInotifyWatch
 *==========================================================================*/

GUtilInotifyWatch*
gutil_inotify_watch_new(
    const char* path,
    guint32 mask)
{
    if (G_LIKELY(path)) {
        GUtilInotify* inotify = gutil_inotify_new();
        if (G_LIKELY(inotify)) {
            int wd = inotify_add_watch(inotify->fd, path, mask);
            if (wd >= 0) {
                GUtilInotifyWatch* self =
                    g_object_new(GUTIL_INOTIFY_WATCH_TYPE,0);
                self->inotify = inotify;
                self->wd = wd;
                self->mask = mask;
                self->path = g_strdup(path);
                gutil_inotify_add_watch(inotify, self);
                return self;
            } else if (errno == ENOENT) {
                GDEBUG("%s doesn't exist", path);
            } else {
                GERR("Failed to add inotify watch %s mask 0x%04x: %s",
                    path, mask, strerror(errno));
            }
            gutil_inotify_unref(inotify);
        }
    }
    return NULL;
}

static
void
gutil_inotify_watch_stop(
    GUtilInotifyWatch* self)
{
    if (self->wd >= 0) {
        gutil_inotify_remove_watch(self->inotify, self);
        inotify_rm_watch(self->inotify->fd, self->wd);
        self->wd = -1;
    }
}

void
gutil_inotify_watch_destroy(
    GUtilInotifyWatch* self)
{
    if (G_LIKELY(self)) {
        gutil_inotify_watch_stop(self);
        gutil_inotify_watch_unref(self);
    }
}

GUtilInotifyWatch*
gutil_inotify_watch_ref(
    GUtilInotifyWatch* self)
{
    if (G_LIKELY(self)) {
        g_object_ref(GUTIL_INOTIFY_WATCH(self));
        return self;
    } else {
        return NULL;
    }
}

void
gutil_inotify_watch_unref(
    GUtilInotifyWatch* self)
{
    if (G_LIKELY(self)) {
        g_object_unref(GUTIL_INOTIFY_WATCH(self));
    }
}

gulong
gutil_inotify_watch_add_handler(
    GUtilInotifyWatch* self,
    GUtilInotifyWatchFunc cb,
    void* arg)
{
    return (G_LIKELY(self) && G_LIKELY(cb)) ? g_signal_connect(self,
        SIGNAL_WATCH_EVENT_NAME, G_CALLBACK(cb), arg) : 0;
}

void
gutil_inotify_watch_remove_handler(
    GUtilInotifyWatch* self,
    gulong id)
{
    if (G_LIKELY(self) && G_LIKELY(id)) {
        g_signal_handler_disconnect(self, id);
    }
}

static
void
gutil_inotify_watch_init(
    GUtilInotifyWatch* self)
{
}

static
void
gutil_inotify_watch_dispose(
    GObject* object)
{
    GUtilInotifyWatch* self = GUTIL_INOTIFY_WATCH(object);
    gutil_inotify_watch_stop(self);
    G_OBJECT_CLASS(gutil_inotify_watch_parent_class)->dispose(object);
}

static
void
gutil_inotify_watch_finalize(
    GObject* object)
{
    GUtilInotifyWatch* self = GUTIL_INOTIFY_WATCH(object);
    gutil_inotify_unref(self->inotify);
    g_free(self->path);
    G_OBJECT_CLASS(gutil_inotify_watch_parent_class)->finalize(object);
}

static
void gutil_inotify_watch_class_init(
    GUtilInotifyWatchClass* klass)
{
    GObjectClass* object_class = G_OBJECT_CLASS(klass);
    object_class->dispose = gutil_inotify_watch_dispose;
    object_class->finalize = gutil_inotify_watch_finalize;
    gutil_inotify_watch_signals[SIGNAL_WATCH_EVENT] =
        g_signal_new(SIGNAL_WATCH_EVENT_NAME, G_OBJECT_CLASS_TYPE(klass),
            G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL,
            G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_POINTER);
}

/*==========================================================================*
 * GUtilInotifyWatchCallback
 *==========================================================================*/

GUtilInotifyWatchCallback*
gutil_inotify_watch_callback_new(
    const char* path,
    guint32 mask,
    GUtilInotifyWatchFunc fn,
    void* arg)
{
    GUtilInotifyWatch* watch = gutil_inotify_watch_new(path, mask);
    if (watch) {
        GUtilInotifyWatchCallback* cb = g_new(GUtilInotifyWatchCallback,1);
        cb->watch = watch;
        cb->id = gutil_inotify_watch_add_handler(watch, fn, arg);
        return cb;
    }
    return NULL;
}

void
gutil_inotify_watch_callback_free(
    GUtilInotifyWatchCallback* cb)
{
    if (G_LIKELY(cb)) {
        gutil_inotify_watch_remove_handler(cb->watch, cb->id);
        gutil_inotify_watch_unref(cb->watch);
        g_free(cb);
    }
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000028000081A400000000000000000000000164304BB200001D3F000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/src/gutil_intarray.c/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_intarray.h"
#include "gutil_ints.h"

G_STATIC_ASSERT(sizeof(GUtilIntArray) == sizeof(GArray));
#define ELEMENT_SIZE (sizeof(int))

GUtilIntArray*
gutil_int_array_new()
{
    return (GUtilIntArray*)g_array_sized_new(FALSE, FALSE, ELEMENT_SIZE, 0);
}

GUtilIntArray*
gutil_int_array_sized_new(
    guint reserved)
{
    return (GUtilIntArray*)g_array_sized_new(FALSE, FALSE, ELEMENT_SIZE,
        reserved * ELEMENT_SIZE);
}

GUtilIntArray*
gutil_int_array_new_from_vals(
    const int* vals,
    guint count)
{
    GUtilIntArray* array = gutil_int_array_sized_new(count);
    gutil_int_array_append_vals(array, vals, count);
    return array;
}

GUtilIntArray*
gutil_int_array_new_from_value(
    int value)
{
    return gutil_int_array_new_from_vals(&value, 1);
}

int*
gutil_int_array_free(
    GUtilIntArray* array,
    gboolean free_data)
{
    if (array) {
        if (array->count) {
            return (int*)g_array_free((GArray*)array, free_data);
        } else {
            return (int*)g_array_free((GArray*)array, TRUE);
        }
    } else {
        return NULL;
    }
}

GUtilInts*
gutil_int_array_free_to_ints(
    GUtilIntArray* array)
{
    if (array) {
        if (array->count) {
            guint count = array->count;
            int* values = gutil_int_array_free(array, FALSE);
            return gutil_ints_new_take(values, count);
        } else {
            gutil_int_array_free(array, TRUE);
        }
    }
    return NULL;
}

GUtilIntArray*
gutil_int_array_ref(
    GUtilIntArray* array)
{
    if (array) {
        return (GUtilIntArray*)g_array_ref((GArray*)array);
    }
    return NULL;
}

void
gutil_int_array_unref(
    GUtilIntArray* array)
{
    if (array) {
        g_array_unref((GArray*)array);
    }
}

GUtilIntArray*
gutil_int_array_append(
    GUtilIntArray* array,
    int val)
{
    return gutil_int_array_append_vals(array, &val, 1);
}

GUtilIntArray*
gutil_int_array_append_vals(
    GUtilIntArray* array,
    const int* vals,
    guint count)
{
    if (array) {
        g_array_append_vals((GArray*)array, (void*)vals, count);
    }
    return array;
}

GUtilIntArray*
gutil_int_array_prepend(
    GUtilIntArray* array,
    int val)
{
    return gutil_int_array_prepend_vals(array, &val, 1);
}

GUtilIntArray*
gutil_int_array_prepend_vals(
    GUtilIntArray* array,
    const int* vals,
    guint count)
{
    if (array) {
        g_array_prepend_vals((GArray*)array, (void*)vals, count);
    }
    return array;
}

GUtilIntArray*
gutil_int_array_insert(
    GUtilIntArray* array,
    guint pos,
    int val)
{
    return gutil_int_array_insert_vals(array, pos, &val, 1);
}

GUtilIntArray*
gutil_int_array_insert_vals(
    GUtilIntArray* array,
    guint pos,
    const int* vals,
    guint count)
{
    if (array) {
        g_array_insert_vals((GArray*)array, pos, (void*)vals, count);
    }
    return array;
}

GUtilIntArray*
gutil_int_array_set_count(
    GUtilIntArray* array,
    guint count)
{
    if (array) {
        g_array_set_size((GArray*)array, count);
    }
    return array;
}

int
gutil_int_array_find(
    GUtilIntArray* array,
    int value)
{
    if (array) {
        guint i;
        for (i = 0; i < array->count; i++) {
            if (array->data[i] == value) {
                return i;
            }
        }
    }
    return -1;
}

gboolean
gutil_int_array_contains(
    GUtilIntArray* array,
    int value)
{
    return gutil_int_array_find(array, value) >= 0;
}

gboolean
gutil_int_array_remove(
    GUtilIntArray* array,
    int value)
{
    int pos = gutil_int_array_find(array, value);
    if (pos >= 0) {
        g_array_remove_index((GArray*)array, pos);
        return TRUE;
    }
    return FALSE;
}

gboolean
gutil_int_array_remove_fast(
    GUtilIntArray* array,
    int value)
{
    int pos = gutil_int_array_find(array, value);
    if (pos >= 0) {
        g_array_remove_index_fast((GArray*)array, pos);
        return TRUE;
    }
    return FALSE;
}

guint
gutil_int_array_remove_all(
    GUtilIntArray* array,
    int value)
{
    guint n;
    for (n = 0; gutil_int_array_remove(array, value); n++);
    return n;
}

guint
gutil_int_array_remove_all_fast(
    GUtilIntArray* array,
    int value)
{
    guint n;
    for (n = 0; gutil_int_array_remove_fast(array, value); n++);
    return n;
}

GUtilIntArray*
gutil_int_array_remove_index(
    GUtilIntArray* array,
    guint pos)
{
    if (array && pos < array->count) {
        g_array_remove_index((GArray*)array, pos);
    }
    return array;
}

GUtilIntArray*
gutil_int_array_remove_index_fast(
    GUtilIntArray* array,
    guint pos)
{
    if (array) {
        g_array_remove_index_fast((GArray*)array, pos);
    }
    return array;
}

GUtilIntArray*
gutil_int_array_remove_range(
    GUtilIntArray* array,
    guint pos,
    guint count)
{
    if (array && pos < array->count && count) {
        guint end = pos + count;
        if (end > array->count) {
            end = array->count;
        }
        g_array_remove_range((GArray*)array, pos, end - pos);
    }
    return array;
}

static
gint
gutil_int_array_sort_ascending_proc(
    gconstpointer a,
    gconstpointer b)
{
    const int* v1 = a;
    const int* v2 = b;
    return *v1 - *v2;
}

void
gutil_int_array_sort_ascending(
    GUtilIntArray* array)
{
    if (array) {
        g_array_sort((GArray*)array, gutil_int_array_sort_ascending_proc);
    }
}

static
gint
gutil_int_array_sort_descending_proc(
    gconstpointer a,
    gconstpointer b)
{
    const int* v1 = a;
    const int* v2 = b;
    return *v2 - *v1;
}

void
gutil_int_array_sort_descending(
    GUtilIntArray* array)
{
    if (array) {
        g_array_sort((GArray*)array, gutil_int_array_sort_descending_proc);
    }
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000029000081A400000000000000000000000164304BB200001B52000000000000000000000000000000000000003000000000libglibutil-1680886706.91f2bff/src/gutil_ints.c/*
 * Copyright (C) 2017-2021 Jolla Ltd.
 * Copyright (C) 2017-2021 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_intarray.h"
#include "gutil_ints.h"
#include "gutil_misc.h"
#include "gutil_macros.h"

struct gutil_ints {
    const int* data;
    guint count;
    gint ref_count;
    GDestroyNotify free_func;
    gpointer user_data;
};

GUtilInts*
gutil_ints_new(
    const int* data,
    guint n)
{
    if (data && n) {
        return gutil_ints_new_take(gutil_memdup(data, n * sizeof(int)), n);
    } else {
        return NULL;
    }
}

GUtilInts*
gutil_ints_new_take(
    int* data,
    guint count)
{
    return gutil_ints_new_with_free_func(data, count, g_free, data);
}

GUtilInts*
gutil_ints_new_static(
    const int* data,
    guint count)
{
    return gutil_ints_new_with_free_func(data, count, NULL, NULL);
}

GUtilInts*
gutil_ints_new_with_free_func(
    const int* data,
    guint count,
    GDestroyNotify free_func,
    gpointer user_data)
{
    if (data && count) {
        GUtilInts* ints = g_slice_new(GUtilInts);
        ints->data = data;
        ints->count = count;
        ints->free_func = free_func;
        ints->user_data = user_data;
        ints->ref_count = 1;
        return ints;
    } else {
        return NULL;
    }
}

static
void
gutil_ints_unref1(
    gpointer ints)
{
    gutil_ints_unref(ints);
}

GUtilInts*
gutil_ints_new_from_ints(
    GUtilInts* ints,
    guint offset,
    guint count)
{
    if (ints && offset < ints->count) {
        guint end = offset + count;
        if (end > ints->count) {
            end = ints->count;
        }
        return gutil_ints_new_with_free_func(ints->data + offset, end - offset,
            gutil_ints_unref1, gutil_ints_ref(ints));
    }
    return NULL;
}

GUtilInts*
gutil_ints_ref(
    GUtilInts* ints)
{
    if (ints) {
        g_atomic_int_inc(&ints->ref_count);
        return ints;
    }
    return NULL;
}

void
gutil_ints_unref(
    GUtilInts* ints)
{
    if (ints) {
        if (g_atomic_int_dec_and_test(&ints->ref_count)) {
            if (ints->free_func) {
                ints->free_func(ints->user_data);
            }
            gutil_slice_free(ints);
        }
    }
}

int*
gutil_ints_unref_to_data(
    GUtilInts* ints,
    guint* count)
{
    if (ints) {
        int* result;
        if (count) {
            *count = ints->count;
        }
        if (g_atomic_int_dec_and_test(&ints->ref_count)) {
            if (ints->free_func == g_free) {
                /* We can allow the caller to free the data */
                result = (int*)ints->data;
            } else {
                result = gutil_memdup(ints->data, ints->count * sizeof(int));
                ints->free_func(ints->user_data);
            }
            gutil_slice_free(ints);
        } else {
            result = gutil_memdup(ints->data, ints->count * sizeof(int));
        }
        return result;
    } else {
        if (count) {
            *count = 0;
        }
        return NULL;
    }
}

const int*
gutil_ints_get_data(
    GUtilInts* ints,
    guint* count)
{
    if (ints) {
        if (count) {
            *count = ints->count;
        }
        return ints->data;
    } else {
        if (count) {
            *count = 0;
        }
        return NULL;
    }
}

guint
gutil_ints_get_count(
    GUtilInts* ints)
{
    return ints ? ints->count : 0;
}

int
gutil_ints_find(
    GUtilInts* ints,
    int value)
{
    if (ints) {
        guint i;
        for (i=0; i<ints->count; i++) {
            if (ints->data[i] == value) {
                return i;
            }
        }
    }
    return -1;
}

gboolean
gutil_ints_contains(
    GUtilInts* ints,
    int value)
{
    /*
     * Could use gutil_ints_find() here but it would return negative value
     * if the array contains more than MAX_INT entries. Let's be a bit more
     * reliable.
     */
    if (ints) {
        guint i;
        for (i=0; i<ints->count; i++) {
            if (ints->data[i] == value) {
                return TRUE;
            }
        }
    }
    return FALSE;
}

guint
gutil_ints_hash(
    gconstpointer data)
{
    if (data) {
        const GUtilInts* ints = data;
        guint i, h = 1234;
        for (i=0; i<ints->count; i++) {
            h ^= ints->data[i] * (i+1);
        }
        return h;
    } else {
        return 0;
    }
}

gboolean
gutil_ints_equal(
    gconstpointer a,
    gconstpointer b)
{
    const GUtilInts* i1 = a;
    const GUtilInts* i2 = b;
    if (i1 == i2) {
        return TRUE;
    } else if (i1 && i2) {
        return i1->count == i2->count &&
            !memcmp(i1->data, i2->data, i1->count * sizeof(int));
    } else {
        return FALSE;
    }
}

/*
 * Returns: a negative value if b is greater,
 * a positive value if a is greater,
 * and zero if a is equals b
 */
gint
gutil_ints_compare(
    gconstpointer a,
    gconstpointer b)
{
    const GUtilInts* i1 = a;
    const GUtilInts* i2 = b;
    if (i1 == i2) {
        return 0;
    } else if (i1 && i2) {
        const int ret = memcmp(i1->data, i2->data,
            MIN(i1->count, i2->count) * sizeof(int));
        if (ret || i1->count == i2->count) {
            return ret;
        } else {
            return (i1->count > i2->count) ? 1 : -1;
        }
    } else {
        return i1 ? 1 : -1;
    }
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000002A000081A400000000000000000000000164304BB200004B3F000000000000000000000000000000000000002F00000000libglibutil-1680886706.91f2bff/src/gutil_log.c/*
 * Copyright (C) 2014-2022 Jolla Ltd.
 * Copyright (C) 2014-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_log.h"
#include "gutil_misc.h"

#include <stdlib.h>

#ifdef unix
#  include <unistd.h>
#  include <sys/syscall.h>
#  define gettid() ((int)syscall(SYS_gettid))
#elif defined(_WIN32)
#  include <windows.h>
#  define gettid() ((int)GetCurrentThreadId())
#endif

#ifndef GLOG_SYSLOG
#  ifdef unix
#    define GLOG_SYSLOG 1
#  else
#    define GLOG_SYSLOG 0
#  endif
#endif /* GLOG_SYSLOG */

#ifndef GLOG_GLIB
#  define GLOG_GLIB 1
#endif /* GLOG_GLIB */

/* Allows timestamps in stdout log */
gboolean gutil_log_timestamp = FALSE;

/* Adds thread id prefix */
gboolean gutil_log_tid = FALSE; /* Since 1.0.51 */

/* Log configuration */
static GUTIL_DEFINE_LOG_FN2(gutil_log_default_proc);
GLogProc gutil_log_func = gutil_log_stdout;
GLogProc2 gutil_log_func2 = gutil_log_default_proc;
GLogModule gutil_log_default = {
    NULL,               /* name      */
    NULL,               /* parent    */
    NULL,               /* log_proc  */
    GLOG_LEVEL_MAX,     /* max_level */
    GLOG_LEVEL_DEFAULT, /* level     */
    0,                  /* flags     */
    0                   /* reserved2 */
};

/* Log level descriptions */
static const struct _gutil_log_level {
    const char* name;
    const char* description;
} gutil_log_levels [] = {
    { "none",    "Disable log output" },
    { "error",   "Errors only"},
    { "warning", "From warning level to errors" },
    { "info",    "From information level to errors" },
    { "debug",   "From debug messages to errors" },
    { "verbose", "From verbose trace messages to errors" }
};

const char GLOG_TYPE_STDOUT[] = "stdout";
const char GLOG_TYPE_STDERR[] = "stderr";
const char GLOG_TYPE_CUSTOM[] = "custom";
#if GLOG_GLIB
const char GLOG_TYPE_GLIB[]   = "glib";
#endif
#if GLOG_SYSLOG
const char GLOG_TYPE_SYSLOG[] = "syslog";
#endif

G_STATIC_ASSERT(G_N_ELEMENTS(gutil_log_levels) > GLOG_LEVEL_MAX);
G_STATIC_ASSERT(G_N_ELEMENTS(gutil_log_levels) > GLOG_LEVEL_DEFAULT);

/**
 * Formats the string into the given buffer (most commonly allocated
 * on caller's stack). If formatted string fits into the provided buffer,
 * returns pointer to the given buffer. If formatted string is too long
 * to fit into the provided buffer, allocates a new one and returns pointer
 * to it.
 */
static
char*
gutil_log_format(
    char* buf,
    int bufsize,
    const char* format,
    va_list va)
{
    int size, nchars = -1;
    char* buffer;

if (buf) {
        size = bufsize;
        buffer = buf;
    } else {
        size = MAX(100,bufsize);
        buffer = g_malloc(size);
    }

while (buffer) {
        /* Try to print in the allocated space. */
        va_list va2;

G_VA_COPY(va2, va);
        nchars = g_vsnprintf(buffer, size, format, va2);
        va_end(va2);

/* Return the string or try again with more space. */
        if (nchars >= 0) {
            if (nchars < size) break;
            size = nchars+1;  /* Precisely what is needed */
        } else {
            size *= 2;        /* Twice the old size */
        }

if (buffer != buf) g_free(buffer);
        buffer = g_malloc(size);
    }

return buffer;
}

/* Forward output to stdout or stderr */
void
gutil_log_stdio(
    FILE* out,
    const char* name,
    int level,
    const char* format,
    va_list va)
{
    char t[32];
    char buf[512];
    const char* prefix = "";
    char* msg;

if (gutil_log_timestamp) {
        time_t now;
#ifndef _WIN32
        struct tm tm_;
#define localtime(t) localtime_r(t, &tm_)
#endif

time(&now);
        strftime(t, sizeof(t), "%Y-%m-%d %H:%M:%S ", localtime(&now));
#undef localtime
    } else {
        t[0] = 0;
    }

/* Empty name is treated the same way as NULL */
    if (name && !name[0]) {
        name = NULL;
    }

switch (level) {
    case GLOG_LEVEL_WARN: prefix = "WARNING: "; break;
    case GLOG_LEVEL_ERR:  prefix = "ERROR: ";   break;
    default:              break;
    }
    msg = gutil_log_format(buf, sizeof(buf), format, va);
#if defined(DEBUG) && defined(_WIN32)
    {
        char s[1023];
        if (name) {
            g_snprintf(s, sizeof(s), "%s[%s] %s%s\n", t, name, prefix, msg);
        } else {
            g_snprintf(s, sizeof(s), "%s%s%s\n", t, prefix, msg);
        }
        OutputDebugStringA(s);
    }
#endif
    if (name) {
#ifdef gettid
        if (gutil_log_tid)
            fprintf(out, "[%d] %s[%s] %s%s\n", gettid(), t, name, prefix, msg);
        else
#endif
        fprintf(out, "%s[%s] %s%s\n", t, name, prefix, msg);
    } else {
#ifdef gettid
        if (gutil_log_tid)
            fprintf(out, "[%d] %s%s%s\n", gettid(), t, prefix, msg);
        else
#endif
        fprintf(out, "%s%s%s\n", t, prefix, msg);
    }
    if (msg != buf) g_free(msg);
}

void
gutil_log_stdout(
    const char* name,
    int level,
    const char* format,
    va_list va)
{
    gutil_log_stdio(stdout, name, level, format, va);
}

void
gutil_log_stderr(
    const char* name,
    int level,
    const char* format,
    va_list va)
{
    gutil_log_stdio(stderr, name, level, format, va);
}

void
gutil_log_stdout2(
    const GLogModule* module,
    int level,
    const char* format,
    va_list va) /* Since 1.0.43 */
{
    gutil_log_stdout(module ? module->name : NULL, level, format, va);
}

void
gutil_log_stderr2(
    const GLogModule* module,
    int level,
    const char* format,
    va_list va) /* Since 1.0.43 */
{
    gutil_log_stderr(module ? module->name : NULL, level, format, va);
}

/* Formards output to syslog */
#if GLOG_SYSLOG
#include <syslog.h>
void
gutil_log_syslog(
    const char* name,
    int level,
    const char* format,
    va_list va)
{
    int priority;
    const char* prefix = NULL;

switch (level) {
    default:
    case GLOG_LEVEL_INFO:
        priority = LOG_NOTICE;
        break;
    case GLOG_LEVEL_VERBOSE:
        priority = LOG_DEBUG;
        break;
    case GLOG_LEVEL_DEBUG:
        priority = LOG_INFO;
        break;
    case GLOG_LEVEL_WARN:
        priority = LOG_WARNING;
        prefix = "WARNING! ";
        break;
    case GLOG_LEVEL_ERR:
        priority = LOG_ERR;
        prefix = "ERROR! ";
        break;
    }

if (name) {
        /* We don't want to see default name twice in the log */
        if (!name[0] || name == gutil_log_default.name ||
            !g_strcmp0(name, gutil_log_default.name)) {
            name = NULL;
        }
    }

if (name || prefix
#ifdef gettid
        || gutil_log_tid
#endif
        ) {
        char buf[512];
        char* msg = gutil_log_format(buf, sizeof(buf), format, va);
        if (!prefix) prefix = "";
        if (name) {
#ifdef gettid
            if (gutil_log_tid)
                syslog(priority, "[%d] [%s] %s%s", gettid(), name, prefix, msg);
            else
#endif
            syslog(priority, "[%s] %s%s", name, prefix, msg);
        } else {
#ifdef gettid
            if (gutil_log_tid)
                syslog(priority, "[%d] %s%s", gettid(), prefix, msg);
            else
#endif
            syslog(priority, "%s%s", prefix, msg);
        }
        if (msg != buf) g_free(msg);
    } else {
        vsyslog(priority, format, va);
    }
}

void
gutil_log_syslog2(
    const GLogModule* module,
    int level,
    const char* format,
    va_list va) /* Since 1.0.43 */
{
    gutil_log_syslog(module ? module->name : NULL, level, format, va);
}
#endif /* GLOG_SYSLOG */

/* Forwards output to g_logv */
#if GLOG_GLIB
void
gutil_log_glib(
    const char* name,
    int level,
    const char* format,
    va_list va)
{
    GLogLevelFlags flags;
    switch (level) {
    default:
    case GLOG_LEVEL_INFO:    flags = G_LOG_LEVEL_MESSAGE;  break;
    case GLOG_LEVEL_VERBOSE: flags = G_LOG_LEVEL_DEBUG;    break;
    case GLOG_LEVEL_DEBUG:   flags = G_LOG_LEVEL_INFO;     break;
    case GLOG_LEVEL_WARN:    flags = G_LOG_LEVEL_WARNING;  break;
    case GLOG_LEVEL_ERR:     flags = G_LOG_LEVEL_CRITICAL; break;
    }
    g_logv(name, flags, format, va);
}

void
gutil_log_glib2(
    const GLogModule* module,
    int level,
    const char* format,
    va_list va) /* Since 1.0.43 */
{
    gutil_log_glib(module ? module->name : NULL, level, format, va);
}
#endif /* GLOG_GLIB */

/**
 * The caller of this function has already verified that the message needs
 * to be printed. The default action is to forward it to gutil_log_func.
 */
static
void
gutil_log_default_proc(
    const GLogModule* module,
    int level,
    const char* format,
    va_list va)
{
    GLogProc log = gutil_log_func;
    if (G_LIKELY(log)) {
        log((module->flags & GLOG_FLAG_HIDE_NAME) ? NULL : module->name,
            level, format, va);
    }
}

/* Logging function */
static
void
gutil_logv_r(
    const GLogModule* module,
    const GLogModule* check,
    int level,
    const char* format,
    va_list va)
{
    if (!check || !(check->flags & GLOG_FLAG_DISABLE)) {
        if (check && check->level == GLOG_LEVEL_INHERIT && check->parent) {
            gutil_logv_r(module, check->parent, level, format, va);
        } else {
            const int max_level =
                (check && check->level != GLOG_LEVEL_INHERIT) ?
                check->level : gutil_log_default.level;
            if ((level > GLOG_LEVEL_NONE && level <= max_level) ||
                (level == GLOG_LEVEL_ALWAYS)) {
                GLogProc2 log;
                /* Caller makes sure that at least gutil_log_func2 is there */
                if (!module) module = &gutil_log_default;
                log = module->log_proc ? module->log_proc : gutil_log_func2;
                log(module, level, format, va);
            }
        }
    }
}

void
gutil_logv(
    const GLogModule* module,
    int level,
    const char* format,
    va_list va)
{
    if (level != GLOG_LEVEL_NONE && gutil_log_func2) {
        gutil_logv_r(module, module, level, format, va);
    }
}

void
gutil_log(
    const GLogModule* module,
    int level,
    const char* format,
    ...)
{
    va_list va;
    va_start(va, format);
    gutil_logv(module, level, format, va);
    va_end(va);
}

void
gutil_log_assert(
    const GLogModule* module,
    int level,
    const char* expr,
    const char* file,
    int line)
{
    gutil_log(module, level, "Assert %s failed at %s:%d", expr, file, line);
}

/**
 * Check if logging is enabled for the specified log level
 */
static
gboolean
gutil_log_enabled_r(
    const GLogModule* module,
    int level)
{
    if (module->flags & GLOG_FLAG_DISABLE) {
        return FALSE;
    } else if (module->level == GLOG_LEVEL_INHERIT && module->parent) {
        return gutil_log_enabled_r(module->parent, level);
    } else {
        const int max_level = (module->level == GLOG_LEVEL_INHERIT) ?
            gutil_log_default.level : module->level;
        return (level > GLOG_LEVEL_NONE && level <= max_level) ||
               (level == GLOG_LEVEL_ALWAYS);
    }
}

gboolean
gutil_log_enabled(
    const GLogModule* module,
    int level)
{
    if (level != GLOG_LEVEL_NONE && gutil_log_func2) {
        return gutil_log_enabled_r(module ? module : &gutil_log_default,
            level);
    }
    return FALSE;
}

static
void
gutil_log_dump2(
    const GLogModule* module,
    int level,
    const char* prefix,
    const void* data,
    gsize size)
{
    const guint8* ptr = data;
    guint off = 0;

if (!prefix) prefix = "";
    while (size > 0) {
        char buf[GUTIL_HEXDUMP_BUFSIZE];
        const guint consumed = gutil_hexdump(buf, ptr + off, size);

gutil_log(module, level, "%s%04X: %s", prefix, off, buf);
        size -= consumed;
        off += consumed;
    }
}

void
gutil_log_dump(
    const GLogModule* module,
    int level,
    const char* prefix,
    const void* data,
    gsize size) /* Since 1.0.55 */
{
    if (gutil_log_enabled(module, level)) {
        gutil_log_dump2(module, level, prefix, data, size);
    }
}

void
gutil_log_dump_bytes(
    const GLogModule* module,
    int level,
    const char* prefix,
    GBytes* bytes) /* Since 1.0.67 */
{
    if (G_LIKELY(bytes) && gutil_log_enabled(module, level)) {
        gsize size = 0;
        const guint8* data = g_bytes_get_data(bytes, &size);
        gutil_log_dump2(module, level, prefix, data, size);
    }
}

/* gutil_log_parse_option helper */
static
int
gutil_log_parse_level(
    const char* str,
    GError** error)
{
    if (str && str[0]) {
        guint i;
        const size_t len = strlen(str);
        if (len == 1) {
            const char* valid_numbers = "012345";
            const char* number = strchr(valid_numbers, str[0]);
            if (number) {
                return number - valid_numbers;
            }
        }

for (i=0; i<G_N_ELEMENTS(gutil_log_levels); i++) {
            if (!strncmp(gutil_log_levels[i].name, str, len)) {
                return i;
            }
        }
    }
    if (error) {
        *error = g_error_new(G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
            "Invalid log level '%s'", str);
    }
    return -1;
}

/**
 * Command line parsing helper. Option format is [module:]level where level
 * can be either a number or log level name ("none", "error", etc.)
 */
gboolean
gutil_log_parse_option(
    const char* opt,
    GLogModule** modules,
    int count,
    GError** error)
{
    const char* sep = strchr(opt, ':');
    if (sep) {
        const int modlevel = gutil_log_parse_level(sep+1, error);
        if (modlevel >= 0) {
            int i;
            const size_t namelen = sep - opt;
            for (i=0; i<count; i++) {
                if (!g_ascii_strncasecmp(modules[i]->name, opt, namelen) &&
                    strlen(modules[i]->name) == namelen) {
                    modules[i]->level = modlevel;
                    return TRUE;
                }
            }
            if (error) {
                *error = g_error_new(G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
                    "Unknown log module '%.*s'", (int)namelen, opt);
            }
        }
    } else {
        const int deflevel = gutil_log_parse_level(opt, error);
        if (deflevel >= 0) {
            gutil_log_default.level = deflevel;
            return TRUE;
        }
    }
    return FALSE;
}

/**
 * Generates the string containg description of log levels and list of
 * log modules. The caller must deallocate the string with g_free
 */
char*
gutil_log_description(
    GLogModule** modules,   /* Known modules */
    int count)              /* Number of known modules */
{
    int i;
    GString* desc = g_string_sized_new(128);
    g_string_append(desc, "Log Levels:\n");
    for (i=0; i<=GLOG_LEVEL_VERBOSE; i++) {
        g_string_append_printf(desc, "   %d, ", i);
        g_string_append_printf(desc, "%-8s    ", gutil_log_levels[i].name);
        g_string_append(desc, gutil_log_levels[i].description);
        if (i == GLOG_LEVEL_DEFAULT) g_string_append(desc, " (default)");
        g_string_append(desc, "\n");
    }
    if (modules) {
        g_string_append(desc, "\nLog Modules:\n");
        for (i=0; i<count; i++) {
            g_string_append_printf(desc, "  %s\n", modules[i]->name);
        }
    }
    return g_string_free(desc, FALSE);
}

gboolean
gutil_log_set_type(
    const char* type,
    const char* default_name)
{
#if GLOG_SYSLOG
    if (!g_ascii_strcasecmp(type, GLOG_TYPE_SYSLOG)) {
        if (gutil_log_func != gutil_log_syslog) {
            openlog(NULL, LOG_PID | LOG_CONS, LOG_USER);
        }
        /* NULL default_name means "don't change the default name" */
        if (default_name) {
            gutil_log_default.name = default_name;
        }
        gutil_log_func = gutil_log_syslog;
        return TRUE;
    }
    if (gutil_log_func == gutil_log_syslog) {
        closelog();
    }
#endif /* GLOG_SYSLOG */
    /* NULL default_name means "don't change the default name" */
    if (default_name) {
        gutil_log_default.name = default_name;
    }
    if (!g_ascii_strcasecmp(type, GLOG_TYPE_STDOUT)) {
        gutil_log_func = gutil_log_stdout;
        return TRUE;
    } if (!g_ascii_strcasecmp(type, GLOG_TYPE_STDERR)) {
        gutil_log_func = gutil_log_stderr;
        return TRUE;
#if GLOG_GLIB
    } else if (!g_ascii_strcasecmp(type, GLOG_TYPE_GLIB)) {
        gutil_log_func = gutil_log_glib;
        return TRUE;
#endif /* GLOG_GLIB */
    }
    return FALSE;
}

const char*
gutil_log_get_type()
{
    return (gutil_log_func == gutil_log_stdout) ? GLOG_TYPE_STDOUT :
           (gutil_log_func == gutil_log_stderr) ? GLOG_TYPE_STDERR :
#if GLOG_SYSLOG
           (gutil_log_func == gutil_log_syslog) ? GLOG_TYPE_SYSLOG :
#endif /* GLOG_SYSLOG */
#if GLOG_GLIB
           (gutil_log_func == gutil_log_glib)   ? GLOG_TYPE_GLIB :
#endif /* GLOG_GLIB */
                                                  GLOG_TYPE_CUSTOM;
}

/* Initialize defaults from the environment */
#ifndef _WIN32
__attribute__((constructor))
static
void
gutil_log_init()
{
    int val = 0;

if (gutil_parse_int(getenv("GUTIL_LOG_DEFAULT_LEVEL"), 0, &val) &&
        val >= GLOG_LEVEL_INHERIT) {
        gutil_log_default.level = val;
        GDEBUG("Default log level %d", val);
    }

if (gutil_parse_int(getenv("GUTIL_LOG_TIMESTAMP"), 0, &val) && val >= 0) {
        gutil_log_timestamp = (val > 0);
        GDEBUG("Timestamps %s", (val > 0) ? "enabled" : "disabled");
    }

if (gutil_parse_int(getenv("GUTIL_LOG_TID"), 0, &val) && val >= 0) {
        gutil_log_tid = (val > 0);
        GDEBUG("Thread id prefix %s", (val > 0) ? "enabled" : "disabled");
    }
}
#endif

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000002B000081A400000000000000000000000164304BB20000421E000000000000000000000000000000000000003000000000libglibutil-1680886706.91f2bff/src/gutil_misc.c/*
 * Copyright (C) 2016-2022 Jolla Ltd.
 * Copyright (C) 2016-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_misc.h"

#include <glib-object.h>

#include <ctype.h>
#include <errno.h>
#include <limits.h>

void
gutil_disconnect_handlers(
    gpointer instance,
    gulong *ids,
    int count)
{
    if (G_LIKELY(instance) && G_LIKELY(ids)) {
        int i;

for (i=0; i<count; i++) {
            if (ids[i]) {
                g_signal_handler_disconnect(instance, ids[i]);
                ids[i] = 0;
            }
        }
    }
}

void*
gutil_hex2bin(
    const char* str,
    gssize len,
    void* data)
{
    if (str && data && len > 0 && !(len & 1)) {
        gssize i;
        guint8* ptr = data;

for (i=0; i<len; i+=2) {
            static const guint8 hex[] = {
                0, 1, 2, 3, 4, 5, 6, 7,     /* 0x30..0x37 */
                8, 9, 0, 0, 0, 0, 0, 0,     /* 0x3a..0x3f */
                0,10,11,12,13,14,15, 0,     /* 0x40..0x47 */
                0, 0, 0, 0, 0, 0, 0, 0,     /* 0x4a..0x4f */
                0, 0, 0, 0, 0, 0, 0, 0,     /* 0x40..0x47 */
                0, 0, 0, 0, 0, 0, 0, 0,     /* 0x5a..0x5f */
                0,10,11,12,13,14,15         /* 0x60..0x66 */
            };
            const char x1 = str[i];
            const char x2 = str[i+1];

if (g_ascii_isxdigit(x1) && g_ascii_isxdigit(x2)) {
                *ptr++ = (hex[x1-0x30] << 4) + hex[x2-0x30];
            } else {
                return NULL;
            }
        }
        return data;
    }
    return NULL;
}

GBytes*
gutil_hex2bytes(
    const char* str,
    gssize len)
{
    if (str) {
        if (len < 0) len = strlen(str);
        if (len > 0 && !(len & 1)) {
            const gsize n = len/2;
            void* data = g_malloc(n);

if (gutil_hex2bin(str, len, data)) {
                return g_bytes_new_take(data, n);
            }
            g_free(data);
        }
    }
    return NULL;
}

/**
 * The caller makes sure that the destination buffer has at least
 * GUTIL_HEXDUMP_BUFSIZE bytes available. Returns the number of
 * bytes actually dumped (no more than GUTIL_HEXDUMP_MAXBYTES).
 *
 * Since 1.0.29
 */
guint
gutil_hexdump(
    char* buf,
    const void* data,
    guint len)
{
    static const char hex[] = "0123456789abcdef";
    const guint bytes_dumped = MIN(len, GUTIL_HEXDUMP_MAXBYTES);
    const guchar* bytes = data;
    char* ptr = buf;
    guint i;

for (i=0; i<GUTIL_HEXDUMP_MAXBYTES; i++) {
        if (i > 0) {
            *ptr++ = ' ';
            if (i == 8) *ptr++ = ' ';
        }
        if (i < len) {
            const guchar b = bytes[i];
            *ptr++ = hex[(b >> 4) & 0xf];
            *ptr++ = hex[b & 0xf];
        } else {
            *ptr++ = ' ';
            *ptr++ = ' ';
        }
    }

*ptr++ = ' ';
    *ptr++ = ' ';
    *ptr++ = ' ';
    *ptr++ = ' ';
    for (i=0; i<bytes_dumped; i++) {
        const char c = bytes[i];
        if (i == 8) *ptr++ = ' ';
        *ptr++ = isprint(c) ? c : '.';
    }

*ptr++ = 0;
    return bytes_dumped;
}

static
const char*
gutil_strstrip(
    const char* str,
    char** tmp)
{
    /* Caller makes sure that str isn't NULL */
    const gsize len = strlen(str);

if (g_ascii_isspace(str[0]) || g_ascii_isspace(str[len - 1])) {
        /* Need to modify the original string */
        return (*tmp = g_strstrip(gutil_memdup(str, len + 1)));
    } else {
        /* The original string is fine as is */
        return str;
    }
}

gboolean
gutil_parse_int(
    const char* str,
    int base,
    int* value) /* Since 1.0.30 */
{
    gint64 ll;

if (gutil_parse_int64(str, base, &ll) && ll >= INT_MIN && ll <= INT_MAX) {
        if (value) {
            *value = (int)ll;
        }
        return TRUE;
    }
    return FALSE;
}

gboolean
gutil_parse_uint(
    const char* str,
    int base,
    unsigned int* value) /* Since 1.0.53 */
{
    guint64 ull;

if (gutil_parse_uint64(str, base, &ull) && ull <= UINT_MAX) {
        if (value) {
            *value = (unsigned int)ull;
        }
        return TRUE;
    }
    return FALSE;
}

gboolean
gutil_parse_int64(
    const char* str,
    int base,
    gint64* value) /* Since 1.0.56 */
{
    gboolean ok = FALSE;

if (str && *str) {
        char* tmp = NULL;
        char* end = NULL;
        const char* stripped = gutil_strstrip(str, &tmp);
        gint64 ll;

errno = 0;
        ll = g_ascii_strtoll(stripped, &end, base);
        if (end && !*end &&
            !((ll == G_MAXINT64 || ll == G_MININT64) && errno == ERANGE) &&
            !(ll == 0 && errno == EINVAL)) {
            if (value) {
                *value = ll;
            }
            ok = TRUE;
        }
        g_free(tmp);
    }
    return ok;
}

gboolean
gutil_parse_uint64(
    const char* str,
    int base,
    guint64* value) /* Since 1.0.56 */
{
    gboolean ok = FALSE;

/*
     * Sorry, we don't accept minus as a part of an unsigned number
     * (unlike strtoul)
     */
    if (str && *str && *str != '-') {
        char* tmp = NULL;
        const char* stripped = gutil_strstrip(str, &tmp);

if (*stripped != '-') {
            char* end = NULL;
            guint64 ull;

errno = 0;
            ull = g_ascii_strtoull(stripped, &end, base);
            if (end && !*end &&
                !(ull == G_MAXUINT64 && errno == ERANGE) &&
                !(ull == 0 && errno == EINVAL)) {
                if (value) {
                    *value = ull;
                }
                ok = TRUE;
            }
        }
        g_free(tmp);
    }
    return ok;
}

gboolean
gutil_data_equal(
    const GUtilData* data1,
    const GUtilData* data2) /* Since 1.0.31 */
{
    if (data1 == data2) {
        return TRUE;
    } else if (!data1 || !data2) {
        return FALSE;
    } else if (data1->size == data2->size) {
        return !memcmp(data1->bytes, data2->bytes, data1->size);
    } else {
        return FALSE;
    }
}

const GUtilData*
gutil_data_from_string(
    GUtilData* data,
    const char* str)
{
    if (data) {
        if (str) {
            data->bytes = (const void*)str;
            data->size = strlen(str);
        } else {
            data->bytes = NULL;
            data->size = 0;
        }
    }
    return data;
}

const GUtilData*
gutil_data_from_bytes(
    GUtilData* data,
    GBytes* bytes)
{
    if (data) {
        if (bytes) {
            data->bytes = g_bytes_get_data(bytes, &data->size);
        } else {
            data->bytes = NULL;
            data->size = 0;
        }
    }
    return data;
}

gboolean
gutil_data_has_prefix(
    const GUtilData* data,
    const GUtilData* prefix) /* Since 1.0.38 */
{
    /*
     * Not that it was overly important, but let's postulate that
     * NULL begins with NULL, empty block begins with empty block
     * but NULL doesn't begin with empty block and empty block
     * doesn't begin with NULL.
     */
    if (G_LIKELY(data)) {
        return G_LIKELY(prefix) &&
            prefix->size <= data->size &&
            !memcmp(data->bytes, prefix->bytes, prefix->size);
    } else {
        return !prefix;
    }
}

gboolean
gutil_data_has_suffix(
    const GUtilData* data,
    const GUtilData* suffix) /* Since 1.0.38 */
{
    /*
     * Similarly to gutil_data_has_prefix, NULL ends with NULL, empty
     * block ends with empty block but NULL doesn't end with empty block
     * and empty block doesn't end with NULL.
     */
    if (G_LIKELY(data)) {
        return G_LIKELY(suffix) &&
            suffix->size <= data->size &&
            !memcmp(data->bytes + (data->size - suffix->size),
                suffix->bytes, suffix->size);
    } else {
        return !suffix;
    }
}

GBytes*
gutil_bytes_concat(
    GBytes* bytes1,
    ...) /* Since 1.0.37 */
{
    if (G_LIKELY(bytes1)) {
        va_list args;
        gsize size = g_bytes_get_size(bytes1);
        gsize total = size;
        guint non_empty_count;
        GBytes* non_empty;
        GBytes* b;

if (!size) {
            non_empty_count = 0;
            non_empty = NULL;
        } else {
            non_empty_count = 1;
            non_empty = bytes1;
        }

va_start(args, bytes1);
        b = va_arg(args, GBytes*);
        while (b) {
            size = g_bytes_get_size(b);
            total += size;
            if (size) {
                non_empty_count++;
                non_empty = b;
            }
            b = va_arg(args, GBytes*);
        }
        va_end(args);

if (non_empty_count == 0) {
            /* All arrays are empty */
            return g_bytes_ref(bytes1);
        } else if (non_empty_count == 1) {
            /* Only one array is non-empty */
            return g_bytes_ref(non_empty);
        } else {
            /* We actually need to concatenate something */
            guint8* buf = g_malloc(total);
            guint8* dest;
            gsize size;
            const void* src = g_bytes_get_data(bytes1, &size);

memcpy(buf, src, size);
            dest = buf + size;

va_start(args, bytes1);
            b = va_arg(args, GBytes*);
            while (b) {
                src = g_bytes_get_data(b, &size);
                memcpy(dest, src, size);
                dest += size;
                b = va_arg(args, GBytes*);
            }
            va_end(args);

return g_bytes_new_take(buf, total);
        }
    }
    return NULL;
}

GBytes*
gutil_bytes_xor(
    GBytes* bytes1,
    GBytes* bytes2) /* Since 1.0.37 */
{
    if (G_LIKELY(bytes1) && G_LIKELY(bytes2)) {
        gsize size1, size2;
        const guint8* data1 = g_bytes_get_data(bytes1, &size1);
        const guint8* data2 = g_bytes_get_data(bytes2, &size2);
        const gsize size = MIN(size1, size2);

if (G_LIKELY(size)) {
            gsize i;
            guint8* xor_data = g_malloc(size);
            unsigned long* xor_long = (unsigned long*)xor_data;
            const unsigned long* long1 = (const unsigned long*)data1;
            const unsigned long* long2 = (const unsigned long*)data2;
            const guint8* tail1;
            const guint8* tail2;
            guint8* xor_tail;

/* Optimize by XOR-ing entire words */
            for (i = 0; (i + sizeof(*long1)) <= size; i += sizeof(*long1)) {
                *xor_long++ = (*long1++) ^ (*long2++);
            }

/* Finish the process byte-by-byte */
            tail1 = (const guint8*)long1;
            tail2 = (const guint8*)long2;
            xor_tail = (guint8*)xor_long;
            for(; i < size; i++) {
                *xor_tail++ = (*tail1++) ^ (*tail2++);
            }
            return g_bytes_new_take(xor_data, size);
        }
        return g_bytes_ref(size1 ? bytes2 : bytes1);
    }
    return NULL;
}

gboolean
gutil_bytes_equal(
    GBytes* bytes,
    const void* data,
    gsize size) /* Since 1.0.41 */
{
    if (bytes && data) {
        gsize bytes_size;
        const guint8* contents = g_bytes_get_data(bytes, &bytes_size);

if (bytes_size == size) {
            return !bytes_size || !memcmp(contents, data, size);
        } else {
            return FALSE;
        }
    } else {
        /* NULLs are equal to each other but not to anything else */
        return !bytes && !data;
    }
}

gboolean
gutil_bytes_equal_data(
    GBytes* bytes,
    const GUtilData* data) /* Since 1.0.41 */
{
    if (bytes && data) {
        gsize bytes_size;
        const guint8* contents = g_bytes_get_data(bytes, &bytes_size);

if (bytes_size == data->size) {
            return !bytes_size || !memcmp(contents, data->bytes, data->size);
        } else {
            return FALSE;
        }
    } else {
        /* NULLs are equal to each other but not to anything else */
        return !bytes && !data;
    }
}

gboolean
gutil_bytes_has_prefix(
    GBytes* bytes,
    const void* data,
    gsize size) /* Since 1.0.63 */
{
    if (!bytes) {
        /* NULL GBytes has neither prefix nor suffix, even an empty one */
        return FALSE;
    } else if (!size) {
        /*
         * That's largely a philosophical question - can anything have
         * an empty prefix? Let's assume that the answer is yes. And
         * then if anything can have such a prefix, everything has it.
         * Right? Except for NULL GBytes which doesn't have anything
         * as said earlier.
         */
        return TRUE;
    } else {
        gsize bytes_size;
        const guint8* contents = g_bytes_get_data(bytes, &bytes_size);

return (bytes_size >= size) && !memcmp(contents, data, size);
    }
}

gboolean
gutil_bytes_has_suffix(
    GBytes* bytes,
    const void* data,
    gsize size) /* Since 1.0.63 */
{
    /* Treat an empty suffix the same way as an empty prefix */
    if (!bytes) {
        return FALSE;
    } else if (!size) {
        return TRUE;
    } else {
        gsize bytes_size;
        const guint8* contents = g_bytes_get_data(bytes, &bytes_size);

return (bytes_size >= size) &&
            !memcmp(contents + (bytes_size - size), data, size);
    }
}

/* Calculates the length of NULL-terminated array of pointers */
gsize
gutil_ptrv_length(
    const void* ptrv) /* Since 1.0.50 */
{
    if (G_LIKELY(ptrv)) {
        gsize len = 0;
        const gconstpointer* ptr = ptrv;

while (*ptr++) len++;
        return len;
    } else {
        return 0;
    }
}

/* Frees NULL-terminated array of pointers and whatever they're pointing to. */
void
gutil_ptrv_free(
    void** ptrv) /* Since 1.0.51 */
{
    if (G_LIKELY(ptrv)) {
        void** ptr = ptrv;

while (*ptr) g_free(*ptr++);
        g_free(ptrv);
    }
}

/* Similar to g_memdup but takes gsize as the number of bytes to copy */
void*
gutil_memdup(
    const void* ptr,
    gsize size) /* Since 1.0.52 */
{
    if (G_LIKELY(ptr) && G_LIKELY(size)) {
        void* copy = g_malloc(size);

memcpy(copy, ptr, size);
        return copy;
    } else {
        return NULL;
    }
}

/* NULL-tolerant version of strlen */
gsize
gutil_strlen0(
    const char* str) /* Since 1.0.62 */
{
    return str ? strlen(str) : 0;
}

gsize
gutil_range_init_with_bytes(
    GUtilRange* range,
    GBytes* bytes) /* Since 1.0.55 */
{
    gsize size = 0;

if (G_LIKELY(range)) {
        if (G_LIKELY(bytes)) {
            range->ptr = (const guint8*) g_bytes_get_data(bytes, &size);
            range->end = range->ptr + size;
        } else {
            memset(range, 0, sizeof(*range));
        }
    }
    return size;
}

gboolean
gutil_range_has_prefix(
    const GUtilRange* range,
    const GUtilData* prefix) /* Since 1.0.55 */
{
    if (G_LIKELY(range) && G_LIKELY(range->ptr) && G_LIKELY(prefix)) {
        if (range->end > range->ptr) {
            return (gsize)(range->end - range->ptr) >= prefix->size &&
                !memcmp(range->ptr, prefix->bytes, prefix->size);
        } else {
            return !prefix->size;
        }
    }
    return FALSE;
}

gboolean
gutil_range_skip_prefix(
    GUtilRange* range,
    const GUtilData* prefix) /* Since 1.0.55 */
{
    if (gutil_range_has_prefix(range, prefix)) {
        range->ptr += prefix->size;
        return TRUE;
    }
    return FALSE;
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000002C000081A400000000000000000000000164304BB200002B47000000000000000000000000000000000000003000000000libglibutil-1680886706.91f2bff/src/gutil_ring.c/*
 * Copyright (C) 2016-2020 Jolla Ltd.
 * Copyright (C) 2016-2020 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_ring.h"
#include "gutil_macros.h"
#include "gutil_log.h"

struct gutil_ring {
    gint ref_count;
    gint alloc;
    gint maxsiz;
    gint start;
    gint end;
    gpointer* data;
    GDestroyNotify free_func;
};

GUtilRing*
gutil_ring_new()
{
    return gutil_ring_sized_new(0, GUTIL_RING_UNLIMITED_SIZE);
}

GUtilRing*
gutil_ring_sized_new(
    gint reserved_size,
    gint max_size)
{
    return gutil_ring_new_full(reserved_size, max_size, NULL);
}

GUtilRing*
gutil_ring_new_full(
    gint reserved_size,
    gint max_size,
    GDestroyNotify free_func)
{
    GUtilRing* r = g_slice_new0(GUtilRing);
    r->ref_count = 1;
    r->start = r->end = -1;
    r->maxsiz = (max_size < 0) ? GUTIL_RING_UNLIMITED_SIZE : max_size;
    r->free_func = free_func;
    if (reserved_size) {
        r->data = g_new(gpointer, reserved_size);
        r->alloc = reserved_size;
    }
    return r;
}

GUtilRing*
gutil_ring_ref(
    GUtilRing* r)
{
    if (G_LIKELY(r)) {
        GASSERT(r->ref_count > 0);
        g_atomic_int_inc(&r->ref_count);
    }
    return r;
}

void
gutil_ring_unref(
    GUtilRing* r)
{
    if (G_LIKELY(r)) {
        GASSERT(r->ref_count > 0);
        if (g_atomic_int_dec_and_test(&r->ref_count)) {
            if (r->free_func) {
                const gint n = gutil_ring_size(r);
                gint i;
                for (i=0; i<n; i++) {
                    r->free_func(r->data[(r->start + i) % r->alloc]);
                }
            }
            g_free(r->data);
            gutil_slice_free(r);
        }
    }
}

void
gutil_ring_set_free_func(
    GUtilRing* r,
    GDestroyNotify free_func)
{
    if (G_LIKELY(r)) {
        r->free_func = free_func;
    }    
}

gint
gutil_ring_max_size(
    GUtilRing* r)
{
    return G_LIKELY(r) ? r->maxsiz : 0;
}

void
gutil_ring_set_max_size(
    GUtilRing* r,
    gint max_size)
{
    /* Normalize the value */
    if (max_size < 0) max_size = GUTIL_RING_UNLIMITED_SIZE;
    if (G_LIKELY(r) && r->maxsiz != max_size) {
        const gint size = gutil_ring_size(r);
        if (max_size >= 0 && size > max_size) {
            gutil_ring_drop(r, size - max_size);
        }
        r->maxsiz = max_size;
    }
}

gint
gutil_ring_size(
    GUtilRing* r)
{
    if (G_LIKELY(r) && r->start >= 0) {
        if (r->start > r->end) {
            return (r->alloc + r->end - r->start);
        } else if (r->end > r->start) {
            return (r->end - r->start);
        } else {
            GASSERT(r->start >= 0 && r->start < r->alloc);
            GASSERT(r->end >= 0 && r->end < r->alloc);
            return r->alloc;
        }
    }
    return 0;
}

void
gutil_ring_clear(
    GUtilRing* r)
{
    if (G_LIKELY(r)) {
        gint n = gutil_ring_size(r);
        if (n > 0) {
            GDestroyNotify free_func = r->free_func;
            if (free_func) {
                do {
                    free_func(gutil_ring_get(r));
                    n--;
                } while (n > 0 && gutil_ring_size(r) > 0);
            } else {
                r->start = r->end = -1;
            }
        }
    }
}

void
gutil_ring_compact(
    GUtilRing* r)
{
    if (G_LIKELY(r)) {
        int n = gutil_ring_size(r);
        if (r->alloc > n) {
            if (n > 0) {
                gpointer* buf = g_new(gpointer,n);
                if (r->start < r->end) {
                    memcpy(buf, r->data + r->start, sizeof(gpointer) * n);
                } else {
                    const int tail = r->alloc - r->start;
                    memcpy(buf, r->data + r->start, sizeof(gpointer) * tail);
                    memcpy(buf + tail, r->data, sizeof(gpointer) * r->end);
                }
                g_free(r->data);
                r->data = buf;
                r->alloc = n;
                r->start = 0;
                r->end = 0;
            } else {
                GASSERT(r->data);
                g_free(r->data);
                r->data = NULL;
                r->alloc = 0;
            }
        }
    }
}

gboolean
gutil_ring_reserve(
    GUtilRing* r,
    gint minsize)
{
    if (G_LIKELY(r)) {
        if (minsize <= r->alloc) {
            /* The buffer is already large enough */
            return TRUE;
        } else if (r->maxsiz >= 0 && r->alloc >= r->maxsiz) {
            /* Can't grow the buffer anymore */
            return FALSE;
        } else {
            gpointer* buf;
            /* At least double the allocation size */
            minsize = MAX(minsize, r->alloc*2);
            if (r->maxsiz > 0 && minsize > r->maxsiz) {
                /* Do not exceed the maximum size though */
                minsize = r->maxsiz;
            }
            buf = g_new(gpointer, minsize);
            if (r->start < r->end) {
                const int n = r->end - r->start;
                memcpy(buf, r->data + r->start, sizeof(gpointer) * n);
                r->start = 0;
                r->end = n;
            } else if (r->start >= 0) {
                const int tail = r->alloc - r->start;
                memcpy(buf, r->data + r->start, sizeof(gpointer) * tail);
                memcpy(buf + tail, r->data, sizeof(gpointer) * r->end);
                r->start = 0;
                r->end += tail;
                GASSERT(r->end < minsize);
            }
            g_free(r->data);
            r->data = buf;
            r->alloc = minsize;
            return TRUE;
        }
    }
    return FALSE;
}

gboolean
gutil_ring_can_put(
    GUtilRing* r,
    gint n)
{
    if (G_LIKELY(r)) {
        return r->maxsiz < 0 || (gutil_ring_size(r) + n) <= r->maxsiz;
    }
    return FALSE;
}

gboolean
gutil_ring_put(
    GUtilRing* r,
    gpointer data)
{
    if (gutil_ring_reserve(r, gutil_ring_size(r) + 1)) {
        if (r->start < 0) {
            r->start = r->end = 0;
        }
        GASSERT(r->end < r->alloc);
        r->data[r->end++] = data;
        r->end %= r->alloc;
        return TRUE;
    }
    return FALSE;
}

gboolean
gutil_ring_put_front(
    GUtilRing* r,
    gpointer data)
{
    if (gutil_ring_reserve(r, gutil_ring_size(r) + 1)) {
        if (r->start >= 0) {
            r->start = (r->start + r->alloc - 1) % r->alloc;
        } else {
            r->start = 0;
            r->end = 1;
        }
        r->data[r->start] = data;
        return TRUE;
    }
    return FALSE;
}

gpointer
gutil_ring_get(
    GUtilRing* r)
{
    if (G_LIKELY(r) && r->start >= 0) {
        gpointer data = r->data[r->start++];
        if (r->start == r->end) {
            r->start = r->end = -1;
        } else {
            r->start %= r->alloc;
            if (r->start == r->end) {
                r->start = r->end = -1;
            }
        }
        return data;
    }
    return NULL;
}

gpointer
gutil_ring_get_last(
    GUtilRing* r)
{
    if (G_LIKELY(r) && r->start >= 0) {
        gpointer data;
        r->end = (r->end + r->alloc - 1) % r->alloc;
        data = r->data[r->end];
        if (r->start == r->end) {
            r->start = r->end = -1;
        }
        return data;
    }
    return NULL;
}

gint
gutil_ring_drop(
    GUtilRing* r,
    gint n)
{
    int size, dropped = 0;
    if (n > 0 && (size = gutil_ring_size(r)) > 0) {
        if (n >= size) {
            dropped = size;
            gutil_ring_clear(r);
        } else {
            dropped = n;
            if (r->free_func) {
                while ((n--) > 0) {
                    r->free_func(r->data[r->start]);
                    r->start = (r->start + 1) % r->alloc;
                    GASSERT(r->start != r->end);
                }
            } else {
                r->start = (r->start + n) % r->alloc;
                GASSERT(r->start != r->end);
            }
        }
    }
    return dropped;
}

gint
gutil_ring_drop_last(
    GUtilRing* r,
    gint n)
{
    int size, dropped = 0;
    if (n > 0 && (size = gutil_ring_size(r)) > 0) {
        if (n >= size) {
            dropped = size;
            gutil_ring_clear(r);
        } else {
            dropped = n;
            if (r->free_func) {
                while ((n--) > 0) {
                    r->end = (r->end + r->alloc - 1) % r->alloc;
                    r->free_func(r->data[r->end]);
                    GASSERT(r->start != r->end);
                }
            } else {
                r->end = (r->end + r->alloc - n) % r->alloc;
                GASSERT(r->start != r->end);
            }
        }
    }
    return dropped;
}

gpointer
gutil_ring_data_at(
    GUtilRing* r,
    gint pos)
{
    if (pos >= 0 && pos < gutil_ring_size(r)) {
        return r->data[(r->start + pos) % r->alloc];
    }
    return NULL;

}

gpointer*
gutil_ring_flatten(
    GUtilRing* r,
    gint* size)
{
    gpointer* data = NULL;
    gint n = gutil_ring_size(r);
    if (G_LIKELY(r) && n > 0) {
        if (r->start > 0 && r->start >= r->end) {
            gpointer* buf = g_new(gpointer, n); 
            const gint n1 = r->alloc - r->start;
            memcpy(buf, r->data + r->start, sizeof(gpointer) * n1);
            memcpy(buf + n1, r->data, sizeof(gpointer) * r->end);
            g_free(r->data);
            r->data = buf;
            r->start = 0;
            r->end = (n % r->alloc);
        }
        data = r->data + r->start;
    }
    if (size) *size = n;
    return data;
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000002D000081A400000000000000000000000164304BB2000023EC000000000000000000000000000000000000003000000000libglibutil-1680886706.91f2bff/src/gutil_strv.c/*
 * Copyright (C) 2014-2022 Jolla Ltd.
 * Copyright (C) 2014-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_strv.h"
#include "gutil_misc.h"

#include <stdlib.h>

/**
 * NULL-tolerant version of g_strv_length
 */
guint
gutil_strv_length(
    const GStrV* sv)
{
    return (guint) gutil_ptrv_length(sv);
}

/**
 * Returns i-th strings in the array, NULL if index is out of bounds.
 */
const char*
gutil_strv_at(
    const GStrV* sv,
    guint i)
{
    if (G_LIKELY(sv)) {
        guint k = 0;
        while (sv[k] && k < i) k++;
        if (k == i) {
            /* We also end up here if i == len but that's OK */
            return sv[k];
        }
    }
    return NULL;
}

/**
 * Returns the last string in the array, NULL if there's nothing there.
 */
const char*
gutil_strv_last(
    const GStrV* sv) /* Since 1.0.35 */
{
    if (G_LIKELY(sv) && G_LIKELY(sv[0])) {
        guint k = 0;
        while (sv[k + 1]) k++;
        return sv[k];
    }
    return NULL;
}

/**
 * Returns index of the specified string in the string array,
 * or -1 if the string is not found.
 */
int
gutil_strv_find(
    const GStrV* sv,
    const char* s)
{
    if (G_LIKELY(sv) && G_LIKELY(s)) {
        int i = 0;
        const GStrV* ptr;

for (ptr = sv; *ptr; ptr++, i++) {
            if (!strcmp(*ptr, s)) {
                return i;
            }
        }
    }
    return -1;
}

/* Helper for gutil_strv_find_last and friends */
static
int
gutil_strv_find_last_impl(
    const GStrV* sv,
    const char* s,
    int i /* exclisive */)
{
    while (i > 0) {
        if (!strcmp(sv[--i], s)) {
            return i;
        }
    }
    return -1;
}

/**
 * Returns index of the last occurrence of specified string in the string
 * array, or -1 if the string is not found.
 */
int
gutil_strv_find_last(
    const GStrV* sv,
    const char* s)  /* Since 1.0.62 */
{
    /* NULL sv is handled by gutil_strv_length() */
    return G_LIKELY(s) ?  gutil_strv_find_last_impl(sv, s,
        gutil_strv_length(sv)) : -1;
}

/**
 * Checks if string array contains the specified string.
 */
gboolean
gutil_strv_contains(
    const GStrV* sv,
    const char* s)
{
    return gutil_strv_find(sv, s) >= 0;
}

/**
 * Appends new string to the array.
 */
GStrV*
gutil_strv_add(
    GStrV* sv,
    const char* s)
{
    if (s) {
        guint len = gutil_strv_length(sv);

sv = g_renew(char*, sv, len + 2);
        sv[len++] = g_strdup(s);
        sv[len] = NULL;
    }
    return sv;
}

/**
 * Appends new strings to the array.
 */
GStrV*
gutil_strv_addv(
    GStrV* sv,
    const char* s,
    ...)
{
    if (s) {
        va_list va;
        const char* s1;
        guint len, i, n;

va_start(va, s);
        for (n = 1; (s1 = va_arg(va, char*)) != NULL; n++);
        va_end(va);

len = gutil_strv_length(sv);
        sv = g_renew(gchar*, sv, len + n + 1);
        sv[len++] = g_strdup(s);
        va_start(va, s);
        for (i = 1; i < n; i++) sv[len++] = g_strdup(va_arg(va, char*));
        va_end(va);
        sv[len] = NULL;
    }
    return sv;
}

/* Internal helper for removal functions */
static
GStrV*
gutil_strv_remove_impl(
    GStrV* sv,
    guint pos,
    guint len,
    gboolean free_string)
{
    if (free_string) {
        g_free(sv[pos]);
    }
    memmove(sv + pos, sv + pos + 1, sizeof(char*)*(len - pos));
    return g_realloc(sv, sizeof(char*)*len);
}

/**
 * Removes the string from the specified position in the array.
 */
GStrV*
gutil_strv_remove_at(
    GStrV* sv,
    int pos,
    gboolean free_string)
{
    if (G_LIKELY(sv) && G_LIKELY(pos >= 0)) {
        const int len = gutil_strv_length(sv);

if (pos < len) {
            sv = gutil_strv_remove_impl(sv, pos, len, free_string);
        }
    }
    return sv;
}

/**
 * Removes one or all matching strings from the array and frees them.
 */
GStrV*
gutil_strv_remove(
    GStrV* sv,
    const char* s,
    gboolean remove_all)
{
    if (G_LIKELY(sv) && G_LIKELY(s)) {
        const int pos = gutil_strv_find(sv, s);

if (pos >= 0) {
            guint len = gutil_strv_length(sv);

sv = gutil_strv_remove_impl(sv, pos, len, TRUE);
            if (remove_all) {
                int i, l;

len--;
                l = len - pos;
                while ((i = gutil_strv_find_last_impl(sv + pos, s, l)) >= 0) {
                    sv = gutil_strv_remove_impl(sv, pos + i, len--, TRUE);
                    l = i;
                }
            }
        }
    }
    return sv;
}

/**
 * Removes all duplicates from the string array.
 */
GStrV*
gutil_strv_remove_dups(
    GStrV* sv) /* Since 1.0.62 */
{
    if (G_LIKELY(sv)) {
        guint len = gutil_strv_length(sv), pos = 0, l = len;

while (pos < len) {
            int i = gutil_strv_find_last_impl(sv + pos + 1, sv[pos], l - 1);

if (i < 0) {
                /* Done with this string, switch to the next one */
                pos++;
                l = len - pos;
            } else {
                sv = gutil_strv_remove_impl(sv, pos + 1 + i, len--, TRUE);
                l = i + 1;
            }
        }
    }
    return sv;
}

/**
 * Checks two string arrays for equality. NULL and empty arrays are equal.
 *
 * This is basically a NULL-tolerant equivalent of g_strv_equal which
 * appeared in glib 2.60.
 */
gboolean
gutil_strv_equal(
    const GStrV* sv1,
    const GStrV* sv2)
{
    if (sv1 == sv2) {
        return TRUE;
    } else if (!sv1) {
        return !sv2[0];
    } else if (!sv2) {
        return !sv1[0];
    } else {
        guint len = 0;

while (sv1[len] && sv2[len]) len++;
        if (!sv1[len] && !sv2[len]) {
            guint i;
            for (i=0; i<len; i++) {
                if (strcmp(sv1[i], sv2[i])) {
                    return FALSE;
                }
            }
            return TRUE;
        }
        return FALSE;
    }
}

static
int
gutil_strv_sort_ascending(
    const void* p1,
    const void* p2)
{
    return strcmp(*(char**)p1, *(char**)p2);
}

static
int
gutil_strv_sort_descending(
    const void* p1,
    const void* p2)
{
    return -strcmp(*(char**)p1, *(char**)p2);
}

/**
 * Sorts the string array
 */
GStrV*
gutil_strv_sort(
    GStrV* sv,
    gboolean ascending)
{
    guint len = gutil_strv_length(sv);
    if (len > 0) {
        qsort(sv, len, sizeof(char*), ascending ?
              gutil_strv_sort_ascending :
              gutil_strv_sort_descending);
    }
    return sv;
}

/**
 * Binary search in the sorted string array. Returns index of the
 * specified string in the string array, or -1 if the string is not
 * found. It's basically a version of gutil_strv_find optimized for
 * sorted arrays. The string array must be sorted by gutil_strv_sort
 * with the same 'ascending' argument.
 */
int
gutil_strv_bsearch(
    GStrV* sv,
    const char* s,
    gboolean ascending) /* Since 1.0.40 */
{
    if (s) {
        guint len = gutil_strv_length(sv);
        if (len > 0) {
            GStrV* found = bsearch(&s, sv, len, sizeof(char*), ascending ?
                gutil_strv_sort_ascending : gutil_strv_sort_descending);
            if (found) {
                return found - sv;
            }
        }
    }
    return -1;
}

/**
 * Removes leading and trailing whitespaces from all strings in the vector.
 */
GStrV*
gutil_strv_strip(
    GStrV* sv)
{
    if (sv) {
        GStrV* ptr;
        for (ptr = sv; *ptr; ptr++) {
            *ptr = g_strstrip(*ptr);
        }
    }
    return sv;
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000002E000081A400000000000000000000000164304BB2000019F5000000000000000000000000000000000000003600000000libglibutil-1680886706.91f2bff/src/gutil_timenotify.c/*
 * Copyright (C) 2016-2019 Jolla Ltd.
 * Copyright (C) 2016-2019 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_timenotify.h"
#include "gutil_log.h"

#include <glib-object.h>

#include <time.h>
#include <errno.h>
#include <string.h>
#include <sys/timerfd.h>

#ifndef TFD_TIMER_CANCEL_ON_SET
#  define TFD_TIMER_CANCEL_ON_SET (1 << 1)
#endif

#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t)*8)-1)) - 1)

struct gutil_time_notify {
    GObject object;
    GIOChannel* io_channel;
    guint io_watch_id;
};

enum gutil_time_notify_signal {
    SIGNAL_TIME_CHANGED,
    SIGNAL_COUNT
};

#define SIGNAL_TIME_CHANGED_NAME   "time-changed"

static guint gutil_time_notify_signals[SIGNAL_COUNT] = { 0 };

typedef GObjectClass GUtilTimeNotifyClass;
G_DEFINE_TYPE(GUtilTimeNotify, gutil_time_notify, G_TYPE_OBJECT)
#define GUTIL_TIME_NOTIFY_TYPE (gutil_time_notify_get_type())
#define GUTIL_TIME_NOTIFY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),\
        GUTIL_TIME_NOTIFY_TYPE, GUtilTimeNotify))

GUtilTimeNotify*
gutil_time_notify_new()
{
    /* There's no need to have more than one instance. */
    static GUtilTimeNotify* gutil_time_notify_instance = NULL;
    if (gutil_time_notify_instance) {
        gutil_time_notify_ref(gutil_time_notify_instance);
    } else {
        gutil_time_notify_instance = g_object_new(GUTIL_TIME_NOTIFY_TYPE, 0);
        g_object_add_weak_pointer(G_OBJECT(gutil_time_notify_instance),
            (gpointer*)(&gutil_time_notify_instance));
    }
    return gutil_time_notify_instance;
}

GUtilTimeNotify*
gutil_time_notify_ref(
    GUtilTimeNotify* self)
{
    if (G_LIKELY(self)) {
        g_object_ref(GUTIL_TIME_NOTIFY(self));
    }
    return self;
}

void
gutil_time_notify_unref(
    GUtilTimeNotify* self)
{
    if (G_LIKELY(self)) {
        g_object_unref(GUTIL_TIME_NOTIFY(self));
    }
}

gulong
gutil_time_notify_add_handler(
    GUtilTimeNotify* self,
    GUtilTimeNotifyFunc fn,
    void* arg)
{
    return (G_LIKELY(self) && G_LIKELY(fn)) ? g_signal_connect(self,
        SIGNAL_TIME_CHANGED_NAME, G_CALLBACK(fn), arg) : 0;
}

void
gutil_time_notify_remove_handler(
    GUtilTimeNotify* self,
    gulong id)
{
    if (G_LIKELY(self) && G_LIKELY(id)) {
        g_signal_handler_disconnect(self, id);
    }
}

static
gboolean
gutil_time_notify_callback(
    GIOChannel* channel,
    GIOCondition condition,
    gpointer user_data)
{
    GUtilTimeNotify* self = GUTIL_TIME_NOTIFY(user_data);
    if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
        self->io_watch_id = 0;
        return G_SOURCE_REMOVE;
    } else {
        gsize bytes_read = 0;
        GError* error = NULL;
        guint64 exp;
        gutil_time_notify_ref(self);
        g_io_channel_read_chars(self->io_channel, (void*)&exp, sizeof(exp),
            &bytes_read, &error);
        if (error) {
            /* ECANCELED is expected */
            GDEBUG("%s", error->message);
            g_error_free(error);
        }
        g_signal_emit(self, gutil_time_notify_signals[SIGNAL_TIME_CHANGED], 0);
        gutil_time_notify_unref(self);
        return G_SOURCE_CONTINUE;
    }
}

static
void
gutil_time_notify_init(
    GUtilTimeNotify* self)
{
    const int fd = timerfd_create(CLOCK_REALTIME, 0);
    if (fd >= 0) {
        struct itimerspec timer;
        self->io_channel = g_io_channel_unix_new(fd);
        g_io_channel_set_close_on_unref(self->io_channel, TRUE);
        g_io_channel_set_encoding(self->io_channel, NULL, NULL);
        g_io_channel_set_buffered(self->io_channel, FALSE);
        self->io_watch_id = g_io_add_watch(self->io_channel,
            G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
            gutil_time_notify_callback, self);

/* Set timeout to the latest possible value */
        memset(&timer, 0, sizeof(timer));
        timer.it_value.tv_sec = TIME_T_MAX;
        timer.it_interval.tv_sec = TIME_T_MAX;
        if (timerfd_settime(fd, TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET,
            &timer, NULL) < 0) {
            GERR("timerfd settime: %s", strerror(errno));
        }
    } else {
        GERR("timerfd open: %s", strerror(errno));
    }
}

static
void
gutil_time_notify_finalize(
    GObject* object)
{
    GUtilTimeNotify* self = GUTIL_TIME_NOTIFY(object);
    if (self->io_channel) {
        if (self->io_watch_id) {
            g_source_remove(self->io_watch_id);
        }
        g_io_channel_shutdown(self->io_channel, FALSE, NULL);
        g_io_channel_unref(self->io_channel);
    }
    G_OBJECT_CLASS(gutil_time_notify_parent_class)->finalize(object);
}

static
void
gutil_time_notify_class_init(
    GUtilTimeNotifyClass* klass)
{
    GObjectClass* object_class = G_OBJECT_CLASS(klass);
    object_class->finalize = gutil_time_notify_finalize;
    gutil_time_notify_signals[SIGNAL_TIME_CHANGED] =
        g_signal_new(SIGNAL_TIME_CHANGED_NAME, G_OBJECT_CLASS_TYPE(klass),
            G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000002F000081A400000000000000000000000164304BB2000007A0000000000000000000000000000000000000003300000000libglibutil-1680886706.91f2bff/src/gutil_version.c/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_version.h"

const guint gutil_version_major = GUTIL_VERSION_MAJOR;
const guint gutil_version_minor = GUTIL_VERSION_MINOR;
const guint gutil_version_micro = GUTIL_VERSION_MICRO;

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000030000081A400000000000000000000000164304BB200000D5B000000000000000000000000000000000000003300000000libglibutil-1680886706.91f2bff/src/gutil_weakref.c/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "gutil_weakref.h"
#include "gutil_log.h"
#include "gutil_macros.h"

#include <glib-object.h>

struct gutil_weakref {
    gint ref_count;
    GWeakRef weak_ref;
};

GUtilWeakRef*
gutil_weakref_new(
    gpointer obj)
{
    GUtilWeakRef* self = g_slice_new(GUtilWeakRef);

g_atomic_int_set(&self->ref_count, 1);
    g_weak_ref_init(&self->weak_ref, obj);
    return self;
}

GUtilWeakRef*
gutil_weakref_ref(
    GUtilWeakRef* self)
{
    if (G_LIKELY(self)) {
        GASSERT(self->ref_count > 0);
        g_atomic_int_inc(&self->ref_count);
    }
    return self;
}

void
gutil_weakref_unref(
    GUtilWeakRef* self)
{
    if (G_LIKELY(self)) {
        GASSERT(self->ref_count > 0);
        if (g_atomic_int_dec_and_test(&self->ref_count)) {
            g_weak_ref_clear(&self->weak_ref);
            gutil_slice_free(self);
        }
    }
}

gpointer
gutil_weakref_get(
    GUtilWeakRef* self)
{
    return G_LIKELY(self) ? g_weak_ref_get(&self->weak_ref) : NULL;
}

void
gutil_weakref_set(
    GUtilWeakRef* self,
    gpointer obj)
{
    if (G_LIKELY(self)) {
        g_weak_ref_set(&self->weak_ref, obj);
    }
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000031000041ED00000000000000000000001064304BB200000000000000000000000000000000000000000000002400000000libglibutil-1680886706.91f2bff/test07070100000032000081A400000000000000000000000164304BB200000179000000000000000000000000000000000000002D00000000libglibutil-1680886706.91f2bff/test/Makefile# -*- Mode: makefile-gmake -*-

all:
%:
	@$(MAKE) -C test_datapack $*
	@$(MAKE) -C test_history $*
	@$(MAKE) -C test_idlepool $*
	@$(MAKE) -C test_idlequeue $*
	@$(MAKE) -C test_inotify $*
	@$(MAKE) -C test_intarray $*
	@$(MAKE) -C test_ints $*
	@$(MAKE) -C test_log $*
	@$(MAKE) -C test_misc $*
	@$(MAKE) -C test_ring $*
	@$(MAKE) -C test_strv $*
	@$(MAKE) -C test_weakref $*
07070100000033000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002B00000000libglibutil-1680886706.91f2bff/test/common07070100000034000081A400000000000000000000000164304BB20000125E000000000000000000000000000000000000003400000000libglibutil-1680886706.91f2bff/test/common/Makefile# -*- Mode: makefile-gmake -*-

.PHONY: clean all debug release coverage debug_lib release_lib coverage_lib

#
# Real test makefile defines EXE (and possibly SRC) and includes this one.
#

ifndef EXE
${error EXE not defined}
endif

SRC ?= $(EXE).c
COMMON_SRC ?= test_main.c test_object.c

#
# Required packages
#

PKGS += gobject-2.0 glib-2.0

#
# Default target
#

all: debug release

#
# Directories
#

SRC_DIR = .
LIB_DIR = ../..
COMMON_DIR = ../common
BUILD_DIR = build
DEBUG_BUILD_DIR = $(BUILD_DIR)/debug
RELEASE_BUILD_DIR = $(BUILD_DIR)/release
COVERAGE_BUILD_DIR = $(BUILD_DIR)/coverage

#
# Tools and flags
#

CC ?= $(CROSS_COMPILE)gcc
LD = $(CC)
WARNINGS = -Wall
INCLUDES = -I$(LIB_DIR)/include -I$(LIB_DIR)/src -I$(COMMON_DIR)
BASE_FLAGS = -fPIC
BASE_LDFLAGS = $(BASE_FLAGS) $(LDFLAGS)
BASE_CFLAGS = $(BASE_FLAGS) $(CFLAGS)
FULL_CFLAGS = $(BASE_CFLAGS) $(DEFINES) $(WARNINGS) $(INCLUDES) -MMD -MP \
  -DGLIB_VERSION_MAX_ALLOWED=GLIB_VERSION_2_32 \
  -DGLIB_VERSION_MIN_REQUIRED=GLIB_VERSION_MAX_ALLOWED \
  $(shell pkg-config --cflags $(PKGS))
FULL_LDFLAGS = $(BASE_LDFLAGS)
LIBS = $(shell pkg-config --libs $(PKGS))
QUIET_MAKE = $(MAKE) --no-print-directory
DEBUG_FLAGS = -g
RELEASE_FLAGS =
COVERAGE_FLAGS = -g

KEEP_SYMBOLS ?= 0
ifneq ($(KEEP_SYMBOLS),0)
RELEASE_FLAGS += -g
SUBMAKE_OPTS += KEEP_SYMBOLS=1
endif

DEBUG_LDFLAGS = $(FULL_LDFLAGS) $(DEBUG_FLAGS)
RELEASE_LDFLAGS = $(FULL_LDFLAGS) $(RELEASE_FLAGS)
COVERAGE_LDFLAGS = $(FULL_LDFLAGS) $(COVERAGE_FLAGS) --coverage

DEBUG_CFLAGS = $(FULL_CFLAGS) $(DEBUG_FLAGS) -DDEBUG
RELEASE_CFLAGS = $(FULL_CFLAGS) $(RELEASE_FLAGS) -O2
COVERAGE_CFLAGS = $(FULL_CFLAGS) $(COVERAGE_FLAGS) --coverage

#
# Files
#

DEBUG_OBJS = \
  $(COMMON_SRC:%.c=$(DEBUG_BUILD_DIR)/common_%.o) \
  $(SRC:%.c=$(DEBUG_BUILD_DIR)/%.o)
RELEASE_OBJS = \
  $(COMMON_SRC:%.c=$(RELEASE_BUILD_DIR)/common_%.o) \
  $(SRC:%.c=$(RELEASE_BUILD_DIR)/%.o)
COVERAGE_OBJS = \
  $(COMMON_SRC:%.c=$(COVERAGE_BUILD_DIR)/common_%.o) \
  $(SRC:%.c=$(COVERAGE_BUILD_DIR)/%.o)

DEBUG_LIB_FILE := $(shell $(QUIET_MAKE) -C $(LIB_DIR) print_debug_lib)
RELEASE_LIB_FILE := $(shell $(QUIET_MAKE) -C $(LIB_DIR) print_release_lib)
COVERAGE_LIB_FILE := $(shell $(QUIET_MAKE) -C $(LIB_DIR) print_coverage_lib)

DEBUG_LIB := $(LIB_DIR)/$(DEBUG_LIB_FILE)
RELEASE_LIB := $(LIB_DIR)/$(RELEASE_LIB_FILE)
COVERAGE_LIB := $(LIB_DIR)/$(COVERAGE_LIB_FILE)

#
# Dependencies
#

DEPS = $(DEBUG_OBJS:%.o=%.d) $(RELEASE_OBJS:%.o=%.d) $(COVERAGE_OBJS:%.o=%.d)
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(strip $(DEPS)),)
-include $(DEPS)
endif
endif

$(DEBUG_LIB): | debug_lib
$(RELEASE_LIB): | release_lib
$(COVERAGE_LIB): | coverage_lib

$(DEBUG_OBJS): | $(DEBUG_BUILD_DIR)
$(RELEASE_OBJS): | $(RELEASE_BUILD_DIR)
$(COVERAGE_OBJS): | $(COVERAGE_BUILD_DIR)

#
# Rules
#

DEBUG_EXE = $(DEBUG_BUILD_DIR)/$(EXE)
RELEASE_EXE = $(RELEASE_BUILD_DIR)/$(EXE)
COVERAGE_EXE = $(COVERAGE_BUILD_DIR)/$(EXE)

debug: debug_lib $(DEBUG_EXE)

release: release_lib $(RELEASE_EXE)

coverage: coverage_lib $(COVERAGE_EXE)

clean:
	rm -f *~
	rm -fr $(BUILD_DIR)

cleaner: clean
	@$(MAKE) -C $(LIB_DIR) clean

test_banner:
	@echo "===========" $(EXE) "=========== "

test: test_banner debug 
	@$(DEBUG_EXE)

valgrind: test_banner debug
	@G_DEBUG=gc-friendly G_SLICE=always-malloc valgrind --tool=memcheck --leak-check=full --show-possibly-lost=no $(DEBUG_EXE)

$(DEBUG_BUILD_DIR):
	mkdir -p $@

$(RELEASE_BUILD_DIR):
	mkdir -p $@

$(COVERAGE_BUILD_DIR):
	mkdir -p $@

$(DEBUG_BUILD_DIR)/%.o : $(SRC_DIR)/%.c
	$(CC) -c $(DEBUG_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(RELEASE_BUILD_DIR)/%.o : $(SRC_DIR)/%.c
	$(CC) -c $(RELEASE_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(COVERAGE_BUILD_DIR)/%.o : $(SRC_DIR)/%.c
	$(CC) -c $(COVERAGE_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(DEBUG_BUILD_DIR)/common_%.o : $(COMMON_DIR)/%.c
	$(CC) -c $(DEBUG_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(RELEASE_BUILD_DIR)/common_%.o : $(COMMON_DIR)/%.c
	$(CC) -c $(RELEASE_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(COVERAGE_BUILD_DIR)/common_%.o : $(COMMON_DIR)/%.c
	$(CC) -c $(COVERAGE_CFLAGS) -MT"$@" -MF"$(@:%.o=%.d)" $< -o $@

$(DEBUG_EXE): $(DEBUG_LIB) $(DEBUG_BUILD_DIR) $(DEBUG_OBJS)
	$(LD) $(DEBUG_LDFLAGS) $(DEBUG_OBJS) $< $(LIBS) -o $@

$(RELEASE_EXE): $(RELEASE_LIB) $(RELEASE_BUILD_DIR) $(RELEASE_OBJS)
	$(LD) $(RELEASE_LDFLAGS) $(RELEASE_OBJS) $< $(LIBS) -o $@
ifeq ($(KEEP_SYMBOLS),0)
	strip $@
endif

$(COVERAGE_EXE): $(COVERAGE_LIB) $(COVERAGE_BUILD_DIR) $(COVERAGE_OBJS)
	$(LD) $(COVERAGE_LDFLAGS) $(COVERAGE_OBJS) $< $(LIBS) -o $@

debug_lib:
	@$(MAKE) $(SUBMAKE_OPTS) -C $(LIB_DIR) debug

release_lib:
	@$(MAKE) $(SUBMAKE_OPTS) -C $(LIB_DIR) release

coverage_lib:
	@$(MAKE) $(SUBMAKE_OPTS) -C $(LIB_DIR) coverage
07070100000035000081A400000000000000000000000164304BB20000094C000000000000000000000000000000000000003900000000libglibutil-1680886706.91f2bff/test/common/test_common.h/*
 * Copyright (C) 2016-2022 Jolla Ltd.
 * Copyright (C) 2016-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef TEST_COMMON_H
#define TEST_COMMON_H

#include <gutil_types.h>

#include <glib-object.h>

#define TEST_FLAG_DEBUG (0x01)

typedef struct test_opt {
    int flags;
} TestOpt;

GType test_object_get_type(void);
#define TEST_OBJECT_TYPE (test_object_get_type())

extern gint test_object_count;

/* Should be invoked after g_test_init */
void
test_init(
    TestOpt* opt,
    int argc,
    char* argv[]);

/* Macros */

#define TEST_INIT_DATA(a,b) ((a).bytes = (void*)(b), (a).size = sizeof(b))
#define TEST_ARRAY_AND_SIZE(a) (a), sizeof(a)

#endif /* TEST_COMMON_H */

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000036000081A400000000000000000000000164304BB2000009D2000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/test/common/test_main.c/*
 * Copyright (C) 2016 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of the Jolla Ltd nor the names of its contributors
 *      may be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include <gutil_log.h>

void
test_init(
    TestOpt* opt,
    int argc,
    char* argv[])
{
    int i;
    memset(opt, 0, sizeof(*opt));
    for (i=1; i<argc; i++) {
        const char* arg = argv[i];
        if (!strcmp(arg, "-d") || !strcmp(arg, "--debug")) {
            opt->flags |= TEST_FLAG_DEBUG;
        } else if (!strcmp(arg, "-v")) {
            GTestConfig* config = (GTestConfig*)g_test_config_vars;
            config->test_verbose = TRUE;
        } else {
            GWARN("Unsupported command line option %s", arg);
        }
    }

/* Setup logging */
    gutil_log_timestamp = FALSE;
    gutil_log_default.level = g_test_verbose() ? GLOG_LEVEL_VERBOSE :
            GLOG_LEVEL_NONE;
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000037000081A400000000000000000000000164304BB200000959000000000000000000000000000000000000003900000000libglibutil-1680886706.91f2bff/test/common/test_object.c/*
 * Copyright (C) 2018 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include <gutil_log.h>

typedef GObject TestObject;
typedef GObjectClass TestObjectClass;

G_DEFINE_TYPE(TestObject, test_object, G_TYPE_OBJECT)

gint test_object_count = 0;

static
void
test_object_init(
    TestObject* self)
{
    g_atomic_int_inc(&test_object_count);
}

static
void
test_object_finalize(
    GObject* object)
{
    GASSERT(test_object_count > 0);
    g_atomic_int_add(&test_object_count, -1);
    G_OBJECT_CLASS(test_object_parent_class)->finalize(object);
}

static
void
test_object_class_init(
    TestObjectClass* klass)
{
    klass->finalize = test_object_finalize;
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000038000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002D00000000libglibutil-1680886706.91f2bff/test/coverage07070100000039000081ED00000000000000000000000164304BB20000047F000000000000000000000000000000000000003100000000libglibutil-1680886706.91f2bff/test/coverage/run#!/bin/bash
#
# This script requires lcov to be installed
#

TESTS="\
test_datapack \
test_history \
test_idlepool \
test_idlequeue \
test_inotify \
test_intarray \
test_ints \
test_log \
test_misc \
test_ring \
test_strv \
test_weakref"

FLAVOR="coverage"

pushd `dirname $0` > /dev/null
COV_DIR="$PWD"
pushd .. > /dev/null
TEST_DIR="$PWD"
pushd .. > /dev/null
BASE_DIR="$PWD"
popd > /dev/null
popd > /dev/null
popd > /dev/null

export LD_LIBRARY_PATH="$BASE_DIR/build/$FLAVOR"

make GCOV=1 -C "$BASE_DIR" clean $FLAVOR
for t in $TESTS ; do
    pushd "$TEST_DIR/$t"
    make -C "$TEST_DIR/$t" clean $FLAVOR || exit 1
    build/$FLAVOR/$t || exit 1
    popd
done

# LCOV 1.10 has branch coverage disabled per default
LCOV_OPT="--rc lcov_branch_coverage=1"
GENHTML_OPT="--branch-coverage"

FULL_COV="$COV_DIR/full.gcov"
GLIBUTIL_COV="$COV_DIR/libglibutil.gcov"
rm -f "$FULL_COV" "$GLIBUTIL_COV"
lcov $LCOV_OPT -c -d "$LD_LIBRARY_PATH" -b "$BASE_DIR" -o "$FULL_COV" || exit 1
lcov $LCOV_OPT -e "$FULL_COV" "$BASE_DIR/src/*" -o "$GLIBUTIL_COV" || exit 1
genhtml $GENHTML_OPT -t libglibutil "$GLIBUTIL_COV" --output-directory "$COV_DIR/results" || exit 1
0707010000003A000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000003200000000libglibutil-1680886706.91f2bff/test/test_datapack0707010000003B000081A400000000000000000000000164304BB200000050000000000000000000000000000000000000003B00000000libglibutil-1680886706.91f2bff/test/test_datapack/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_datapack

include ../common/Makefile
0707010000003C000081A400000000000000000000000164304BB200006D48000000000000000000000000000000000000004200000000libglibutil-1680886706.91f2bff/test/test_datapack/test_datapack.c/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_datapack.h"

static TestOpt test_opt;

#define TEST_(name) "/datapack/" name

static const guint8 test_unsigned_mbn_data_0[] = { 0x00 };
static const guint8 test_unsigned_mbn_data_64[] = { 0x40 };
static const guint8 test_unsigned_mbn_data_127[] = { 0x7f };
static const guint8 test_unsigned_mbn_data_128[] = { 0x81, 0x00 };
static const guint8 test_unsigned_mbn_data_257[] = { 0x82, 0x01 };
static const guint8 test_unsigned_mbn_data_383[] = { 0x82, 0x7f };
static const guint8 test_unsigned_mbn_data_16383[] = { 0xff, 0x7f };
static const guint8 test_unsigned_mbn_data_max64[] =
    { 0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f };

static const guint8 test_signed_mbn_data_0[] = { 0x00 };
static const guint8 test_signed_mbn_data_33[] = { 0x21 };
static const guint8 test_signed_mbn_data_m33[] = { 0x5f };
static const guint8 test_signed_mbn_data_65[] = { 0x80, 0x41 };
static const guint8 test_signed_mbn_data_m65[] = { 0xff, 0x3f };
static const guint8 test_signed_mbn_data_127[] = { 0x80, 0x7f };
static const guint8 test_signed_mbn_data_128[] = { 0x81, 0x00 };
static const guint8 test_signed_mbn_data_129[] = { 0x81, 0x01 };
static const guint8 test_signed_mbn_data_m129[] = { 0xfe, 0x7f };
static const guint8 test_signed_mbn_data_257[] = { 0x82, 0x01 };
static const guint8 test_signed_mbn_data_383[] = { 0x82, 0x7f };
static const guint8 test_signed_mbn_data_16383[] = { 0x80, 0xff, 0x7f };
static const guint8 test_signed_mbn_data_m16383[] = { 0xff, 0x80, 0x01 };
static const guint8 test_signed_mbn_data_min64[] = {
    0xff, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
    0x80, 0x00
};
static const guint8 test_signed_mbn_data_max64[] = {
    0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0x7f
};

typedef struct {
    const char* name;
    GUtilData input;
} TestDecodeFail;

static const guint8 test_mbn_decode_fail_data_short[] = { 0x80 };
static const guint8 test_mbn_decode_fail_data_too_long[] = {
    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f
};

/*==========================================================================*
 * mbn/corner_cases
 *==========================================================================*/

static
void
test_mbn_corner_cases()
{
    guint8 buf[1];

g_assert_cmpuint(gutil_signed_mbn_encode2(buf, 0, 0), == ,0);
    g_assert_cmpuint(gutil_unsigned_mbn_encode2(buf, 0, 0), == ,0);
}

/*==========================================================================*
 * signed_mbn/size
 *==========================================================================*/

typedef struct {
    const char* name;
    gint64 input;
    guint output;
} TestSignedMbnSizeData;

/* Use test_mbn_write test data as input */
static const TestSignedMbnSizeData test_signed_mbn_size_data[] = {
#define TEST_CASE(x) TEST_("signed_mbn/size/") x
#define TEST_DATA(x) TEST_CASE(#x), x, sizeof(test_signed_mbn_data_##x)
#define TEST_DATA_(x) TEST_CASE("-" #x), -x, sizeof(test_signed_mbn_data_m##x)
    { TEST_DATA(0) },
    { TEST_DATA(33) },
    { TEST_DATA_(33) },
    { TEST_DATA(65) },
    { TEST_DATA_(65) },
    { TEST_DATA(127) },
    { TEST_DATA(128) },
    { TEST_DATA(129) },
    { TEST_DATA_(129) },
    { TEST_DATA(257) },
    { TEST_DATA(383) },
    { TEST_DATA(16383) },
    { TEST_DATA_(16383) },
    { TEST_CASE("min64"), G_MININT64, sizeof(test_signed_mbn_data_min64) },
    { TEST_CASE("max64"), G_MAXINT64, sizeof(test_signed_mbn_data_max64) }
#undef TEST_CASE
#undef TEST_DATA
#undef TEST_DATA_
};

static
void
test_signed_mbn_size(
    gconstpointer data)
{
    const TestSignedMbnSizeData* test = data;

g_assert_cmpuint(gutil_signed_mbn_size(test->input), == ,test->output);
}

/*==========================================================================*
 * signed_mbn/encode
 *==========================================================================*/

typedef struct {
    const char* name;
    gint64 input;
    GUtilData output;
} TestSignedMbnEncode;

static const TestSignedMbnEncode test_signed_mbn_encode_data[] = {
#define TEST_CASE(x) TEST_("signed_mbn/encode/") x
#define TEST_DATA(x) TEST_CASE(#x), x, \
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_data_##x) }
#define TEST_DATA_(x) TEST_CASE("-" #x), -x, \
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_data_m##x) }
    { TEST_DATA(0) },
    { TEST_DATA(33) },
    { TEST_DATA_(33) },
    { TEST_DATA(65) },
    { TEST_DATA_(65) },
    { TEST_DATA(127) },
    { TEST_DATA(128) },
    { TEST_DATA(129) },
    { TEST_DATA_(129) },
    { TEST_DATA(257) },
    { TEST_DATA(383) },
    { TEST_DATA(16383) },
    { TEST_DATA_(16383) },
    { TEST_CASE("min64"), G_MININT64,
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_data_min64) } },
    { TEST_CASE("max64"), G_MAXINT64,
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_data_max64) } }
#undef TEST_CASE
#undef TEST_DATA
#undef TEST_DATA_
};

static
void
test_signed_mbn_encode(
    gconstpointer data)
{
    const TestSignedMbnEncode* test = data;
    guint8* buf = g_malloc(test->output.size);

memset(buf, 0xaa, test->output.size);
    g_assert_cmpuint(gutil_signed_mbn_encode(buf, test->input), == ,
        test->output.size);
    g_assert(!memcmp(buf, test->output.bytes, test->output.size));

g_free(buf);
}

/*==========================================================================*
 * signed_mbn/decode/ok
 *==========================================================================*/

typedef struct {
    const char* name;
    GUtilData input;
    gint64 output;
} TestSignedMbnDecodeOk;

static const TestSignedMbnDecodeOk test_signed_mbn_decode_ok_data[] = {
#define TEST_CASE(x) TEST_("signed_mbn/decode/ok/") x
#define TEST_DATA(x) TEST_CASE(#x), \
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_data_##x) }, x
#define TEST_DATA_(x) TEST_CASE("-" #x), \
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_data_m##x) }, -x
    { TEST_DATA(0) },
    { TEST_DATA(33) },
    { TEST_DATA_(33) },
    { TEST_DATA(65) },
    { TEST_DATA_(65) },
    { TEST_DATA(127) },
    { TEST_DATA(128) },
    { TEST_DATA(129) },
    { TEST_DATA_(129) },
    { TEST_DATA(257) },
    { TEST_DATA(383) },
    { TEST_DATA(16383) },
    { TEST_DATA_(16383) },
    { TEST_CASE("min64"),
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_data_min64) }, G_MININT64 },
    { TEST_CASE("max64"),
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_data_max64) }, G_MAXINT64 }
#undef TEST_CASE
#undef TEST_DATA
#undef TEST_DATA_
};

static
void
test_signed_mbn_decode_ok(
    gconstpointer data)
{
    const TestSignedMbnDecodeOk* test = data;
    GUtilRange range;
    gint64 value;

range.ptr = test->input.bytes;
    range.end = range.ptr + test->input.size;
    g_assert(gutil_signed_mbn_decode(&range, NULL));
    g_assert(range.ptr == range.end);

range.ptr = test->input.bytes;
    g_assert(gutil_signed_mbn_decode(&range, &value));
    g_assert_cmpint(value, == ,test->output);
    g_assert(range.ptr == range.end);
}

/*==========================================================================*
 * signed_mbn/decode/fail
 *==========================================================================*/

static const guint8 test_signed_mbn_decode_fail_data_positive_sign_ext[] = {
    0x8f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0x7f
};
static const guint8 test_signed_mbn_decode_fail_data_negative_sign_ext[] = {
    0xf1, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
    0x80, 0x00
};

static const TestDecodeFail test_signed_mbn_decode_fail_data[] = {
#define TEST_CASE(x) TEST_("signed_mbn/decode/fail/") x
#define TEST_DATA(x) TEST_CASE(#x), \
    { TEST_ARRAY_AND_SIZE(test_mbn_decode_fail_data_##x) }
#define TEST_DATA_(x) TEST_CASE(#x), \
    { TEST_ARRAY_AND_SIZE(test_signed_mbn_decode_fail_data_##x) }
    { TEST_CASE("null"), { NULL, 0 } },
    { TEST_CASE("empty"), {test_mbn_decode_fail_data_short, 0} },
    { TEST_DATA(short) },
    { TEST_DATA(too_long) },
    { TEST_DATA_(positive_sign_ext) },
    { TEST_DATA_(negative_sign_ext) }
#undef TEST_CASE
#undef TEST_DATA
#undef TEST_DATA_
};

static
void
test_signed_mbn_decode_fail(
    gconstpointer data)
{
    const TestDecodeFail* test = data;
    GUtilRange range;
    gint64 value;

range.ptr = test->input.bytes;
    range.end = range.ptr + test->input.size;
    g_assert(!gutil_signed_mbn_decode(&range, &value));
    g_assert(range.ptr == test->input.bytes);
    g_assert(!gutil_signed_mbn_decode(&range, NULL));
    g_assert(range.ptr == test->input.bytes);
}

/*==========================================================================*
 * signed_mbn/decode2
 *==========================================================================*/

static
void
test_signed_mbn_decode2()
{
    static const guint8 trailing_garbage[] = { 0x12, 0x34 };
    const TestDecodeFail* fail = test_signed_mbn_decode_fail_data;
    const TestSignedMbnDecodeOk* ok = test_signed_mbn_decode_ok_data;
    gint64 value = 0xaaaaaaaa;
    GUtilData in;
    guint i;

g_assert(!gutil_signed_mbn_decode2(NULL, NULL));
    g_assert(!gutil_signed_mbn_decode2(NULL, &value));

in.bytes = trailing_garbage;
    in.size = sizeof(trailing_garbage);
    g_assert(!gutil_signed_mbn_decode2(&in, NULL));
    g_assert(!gutil_signed_mbn_decode2(&in, &value));

/* Run only NULL, empty and short cases */
    for (i = 0; i < 3; i++) {
        g_assert(!gutil_signed_mbn_decode2(&fail[i].input, NULL));
        g_assert(!gutil_signed_mbn_decode2(&fail[i].input, &value));
    }

g_assert(gutil_signed_mbn_decode2(&ok->input, NULL));
    g_assert(gutil_signed_mbn_decode2(&ok->input, &value));
    g_assert_cmpint(value, == ,ok->output);
}

/*==========================================================================*
 * unsigned_mbn/size
 *==========================================================================*/

typedef struct {
    const char* name;
    guint64 input;
    guint output;
} TestUnsignedMbnSizeData;

/* Use test_mbn_write test data as input */
static const TestUnsignedMbnSizeData test_unsigned_mbn_size_data[] = {
#define TEST_CASE(x) TEST_("unsigned_mbn/size/") x
#define TEST_DATA(x) TEST_CASE(#x), x, sizeof(test_unsigned_mbn_data_##x)
    { TEST_DATA(0) },
    { TEST_DATA(64) },
    { TEST_DATA(127) },
    { TEST_DATA(128) },
    { TEST_DATA(257) },
    { TEST_DATA(383) },
    { TEST_DATA(16383) },
    { TEST_CASE("max64"), G_MAXUINT64, sizeof(test_unsigned_mbn_data_max64) }
#undef TEST_CASE
#undef TEST_DATA
};

static
void
test_unsigned_mbn_size(
    gconstpointer data)
{
    const TestUnsignedMbnSizeData* test = data;

g_assert_cmpuint(gutil_unsigned_mbn_size(test->input), == ,test->output);
}

/*==========================================================================*
 * unsigned_mbn/encode
 *==========================================================================*/

typedef struct {
    const char* name;
    guint64 input;
    GUtilData output;
} TestUnsignedMbnEncode;

static const TestUnsignedMbnEncode test_unsigned_mbn_encode_data[] = {
#define TEST_CASE(x) TEST_("unsigned_mbn/encode/") x
#define TEST_DATA(x) TEST_CASE(#x), x, \
    { TEST_ARRAY_AND_SIZE(test_unsigned_mbn_data_##x) }
    { TEST_DATA(0) },
    { TEST_DATA(64) },
    { TEST_DATA(127) },
    { TEST_DATA(128) },
    { TEST_DATA(257) },
    { TEST_DATA(383) },
    { TEST_DATA(16383) },
    { TEST_CASE("max64"), G_MAXUINT64,
    { TEST_ARRAY_AND_SIZE(test_unsigned_mbn_data_max64) } }
#undef TEST_CASE
#undef TEST_DATA
};

static
void
test_unsigned_mbn_encode(
    gconstpointer data)
{
    const TestUnsignedMbnEncode* test = data;
    guint8* buf = g_malloc(test->output.size);

memset(buf, 0xaa, test->output.size);
    g_assert_cmpuint(gutil_unsigned_mbn_encode(buf, test->input), == ,
        test->output.size);
    g_assert(!memcmp(buf, test->output.bytes, test->output.size));

g_free(buf);
}

/*==========================================================================*
 * unsigned_mbn/decode/ok
 *==========================================================================*/

typedef struct {
    const char* name;
    GUtilData input;
    guint64 output;
} TestUnsignedMbnDecodeOk;

static const TestUnsignedMbnDecodeOk test_unsigned_mbn_decode_ok_data[] = {
#define TEST_CASE(x) TEST_("unsigned_mbn/decode/ok/") x
#define TEST_DATA(x) TEST_CASE(#x), \
    { TEST_ARRAY_AND_SIZE(test_unsigned_mbn_data_##x) }, x
    { TEST_DATA(0) },
    { TEST_DATA(64) },
    { TEST_DATA(127) },
    { TEST_DATA(128) },
    { TEST_DATA(257) },
    { TEST_DATA(383) },
    { TEST_DATA(16383) },
    { TEST_CASE("max64"),
    { TEST_ARRAY_AND_SIZE(test_unsigned_mbn_data_max64) }, G_MAXUINT64 }
#undef TEST_CASE
#undef TEST_DATA
};

static
void
test_unsigned_mbn_decode_ok(
    gconstpointer data)
{
    const TestUnsignedMbnDecodeOk* test = data;
    GUtilRange range;
    guint64 value;

range.ptr = test->input.bytes;
    range.end = range.ptr + test->input.size;
    g_assert(gutil_unsigned_mbn_decode(&range, NULL));
    g_assert(range.ptr == range.end);

range.ptr = test->input.bytes;
    g_assert(gutil_unsigned_mbn_decode(&range, &value));
    g_assert_cmpuint(value, == ,test->output);
    g_assert(range.ptr == range.end);
}

/*==========================================================================*
 * unsigned_mbn/decode/fail
 *==========================================================================*/

static const guint8 test_unsigned_mbn_decode_fail_data_extra_bits[] = {
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0x7f
};
static const TestDecodeFail test_unsigned_mbn_decode_fail_data[] = {
#define TEST_CASE(x) TEST_("unsigned_mbn/decode/fail/") x
#define TEST_DATA(x) TEST_CASE(#x), \
    { TEST_ARRAY_AND_SIZE(test_mbn_decode_fail_data_##x) }
#define TEST_DATA_(x) TEST_CASE(#x), \
    { TEST_ARRAY_AND_SIZE(test_unsigned_mbn_decode_fail_data_##x) }
    { TEST_CASE("null"), { NULL, 0 } },
    { TEST_CASE("empty"), {test_mbn_decode_fail_data_short, 0} },
    { TEST_DATA(short) },
    { TEST_DATA(too_long) },
    { TEST_DATA_(extra_bits) }
#undef TEST_CASE
#undef TEST_DATA
#undef TEST_DATA_
};

static
void
test_unsigned_mbn_decode_fail(
    gconstpointer data)
{
    const TestDecodeFail* test = data;
    GUtilRange range;
    guint64 value;

range.ptr = test->input.bytes;
    range.end = range.ptr + test->input.size;
    g_assert(!gutil_unsigned_mbn_decode(&range, &value));
    g_assert(range.ptr == test->input.bytes);
    g_assert(!gutil_unsigned_mbn_decode(&range, NULL));
    g_assert(range.ptr == test->input.bytes);
}

/*==========================================================================*
 * unsigned_mbn/decode2
 *==========================================================================*/

static
void
test_unsigned_mbn_decode2()
{
    static const guint8 trailing_garbage[] = { 0x12, 0x34 };
    const TestDecodeFail* fail = test_unsigned_mbn_decode_fail_data;
    const TestUnsignedMbnDecodeOk* ok = test_unsigned_mbn_decode_ok_data;
    guint64 value = 0xaaaaaaaa;
    GUtilData in;
    guint i;

g_assert(!gutil_unsigned_mbn_decode2(NULL, NULL));
    g_assert(!gutil_unsigned_mbn_decode2(NULL, &value));

in.bytes = trailing_garbage;
    in.size = sizeof(trailing_garbage);
    g_assert(!gutil_unsigned_mbn_decode2(&in, NULL));
    g_assert(!gutil_unsigned_mbn_decode2(&in, &value));

/* Run only NULL, empty and short cases */
    for (i = 0; i < 3; i++) {
        g_assert(!gutil_unsigned_mbn_decode2(&fail[i].input, NULL));
        g_assert(!gutil_unsigned_mbn_decode2(&fail[i].input, &value));
    }

g_assert(gutil_unsigned_mbn_decode2(&ok->input, NULL));
    g_assert(gutil_unsigned_mbn_decode2(&ok->input, &value));
    g_assert_cmpuint(value, == ,ok->output);
}

/*==========================================================================*
 * tlv/corner_cases
 *==========================================================================*/

static
void
test_tlv_corner_cases()
{
    guint8 buf[2];

memset(buf, 0xaa, sizeof(buf));
    g_assert_cmpuint(gutil_tlv_encode(buf, 3, NULL), == ,2);
    g_assert_cmpuint(buf[0], == ,3);
    g_assert_cmpuint(buf[1], == ,0);
}

/*==========================================================================*
 * tlv/size
 *==========================================================================*/

typedef struct {
    const char* name;
    guint tag;
    gsize len;
    guint size;
} TestTlvSize;

static const TestTlvSize test_tlv_size_data[] = {
#define TEST_CASE(x) TEST_("tlv/size/") x
    { TEST_CASE("2"), 1, 0, 2 },
    { TEST_CASE("3"), 1, 1, 3 },
    { TEST_CASE("4"), 128, 1, 4 },
    { TEST_CASE("130"), 128, 127, 130 },
    { TEST_CASE("133"), 128, 129, 133 }
#undef TEST_CASE
};

static
void
test_tlv_size(
    gconstpointer data)
{
    const TestTlvSize* test = data;

g_assert_cmpuint(gutil_tlv_size(test->tag, test->len), == ,test->size);
}

/*==========================================================================*
 * tlv/encode
 *==========================================================================*/

typedef struct {
    const char* name;
    guint tag;
    GUtilData in;
    GUtilData out;
} TestTlvEncodeDecode;

static const guint8 test_tlv_encode_data_out_0[] = { 0x01, 0x00 };
#define TEST_TLV_ENCODE_TAG_1 1
static const guint8 test_tlv_encode_data_in_1[] = { 0x01, 0x02, 0x03 };
static const guint8 test_tlv_encode_data_out_1[] = {
    0x01, 0x03, 0x01, 0x02, 0x03
};
static const TestTlvEncodeDecode test_tlv_encode_data[] = {
#define TEST_CASE(x) TEST_("tlv/encode/") x
#define TEST_DATA(x) TEST_CASE(#x), TEST_TLV_ENCODE_TAG_##x, \
    { TEST_ARRAY_AND_SIZE(test_tlv_encode_data_in_##x) }, \
    { TEST_ARRAY_AND_SIZE(test_tlv_encode_data_out_##x) }
    { TEST_CASE("0"), 1, { NULL, 0 }, {
      TEST_ARRAY_AND_SIZE(test_tlv_encode_data_out_0)} },
    { TEST_DATA(1) },
#undef TEST_CASE
#undef TEST_DATA
};

static
void
test_tlv_encode(
    gconstpointer data)
{
    const TestTlvEncodeDecode* test = data;
    const gsize size = test->out.size;
    void* buf = g_malloc(size);

g_assert_cmpuint(gutil_tlv_size(test->tag, test->in.size), == , size);
    g_assert_cmpuint(gutil_tlv_encode(buf, test->tag, &test->in), == , size);
    g_assert(!memcmp(test->out.bytes, buf, size));
    g_free(buf);
}

/*==========================================================================*
 * tlv/decode/ok
 *==========================================================================*/

static const TestTlvEncodeDecode test_tlv_decode_ok_data[] = {
#define TEST_CASE(x) TEST_("tlv/decode/ok/") x
#define TEST_DATA(x) TEST_CASE(#x), TEST_TLV_ENCODE_TAG_##x, \
    { TEST_ARRAY_AND_SIZE(test_tlv_encode_data_out_##x) }, \
    { TEST_ARRAY_AND_SIZE(test_tlv_encode_data_in_##x) }
    { TEST_CASE("0"), 1, { TEST_ARRAY_AND_SIZE(test_tlv_encode_data_out_0) },
        { NULL, 0 } },
    { TEST_DATA(1) },
#undef TEST_CASE
#undef TEST_DATA
};

static
void
test_tlv_decode_ok(
    gconstpointer data)
{
    const TestTlvEncodeDecode* test = data;
    GUtilRange in;
    GUtilData val;

in.ptr = test->in.bytes;
    in.end = in.ptr + test->in.size;
    g_assert_cmpuint(gutil_tlv_decode(&in, NULL), == ,test->tag);
    g_assert(in.ptr == in.end);

in.ptr = test->in.bytes;
    in.end = in.ptr + test->in.size;
    g_assert_cmpuint(gutil_tlv_decode(&in, &val), == ,test->tag);
    g_assert_cmpuint(val.size, == ,test->out.size);
    g_assert(!memcmp(val.bytes, test->out.bytes, val.size));
    g_assert(in.ptr == in.end);
}

/*==========================================================================*
 * tlv/decode/fail
 *==========================================================================*/

static const guint8 test_tlv_decode_fail_data_tag_too_large[] =
    { 0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x00 };
static const guint8 test_tlv_decode_fail_data_broken_len[] =
    { 0x01, 0xff };
static const guint8 test_tlv_decode_fail_data_truncated[] =
    { 0x01, 0x02, 0x00 };

static const TestDecodeFail test_tlv_decode_fail_data[] = {
#define TEST_CASE(x) TEST_("tlv/decode/fail/") x
#define TEST_DATA(x) TEST_CASE(#x), \
    { TEST_ARRAY_AND_SIZE(test_tlv_decode_fail_data_##x) }
    { TEST_CASE("null"), { NULL, 0 } },
    { TEST_CASE("empty"), {test_tlv_decode_fail_data_tag_too_large, 0} },
    { TEST_DATA(tag_too_large) },
    { TEST_DATA(broken_len) },
    { TEST_DATA(truncated) }
#undef TEST_CASE
#undef TEST_DATA
};

static
void
test_tlv_decode_fail(
    gconstpointer data)
{
    const TestDecodeFail* test = data;
    GUtilRange in;
    GUtilData value;

in.ptr = test->input.bytes;
    in.end = in.ptr + test->input.size;
    g_assert(!gutil_tlv_decode(&in, &value));
    g_assert(in.ptr == test->input.bytes);

g_assert(!gutil_tlv_decode(&in, NULL));
    g_assert(in.ptr == test->input.bytes);
}

/*==========================================================================*
 * tlvs/decode
 *==========================================================================*/

typedef struct {
    const char* name;
    GUtilData input;
    const guint* tags;
    GUTIL_TLVS_DECODE_FLAGS flags;
    int result;
    const GUtilData* values;
} TestTlvsDecode;

static const guint test_tlvs_decode_tags_1[] = { 1, 0 };
static const guint test_tlvs_decode_tags_1_2[] = { 1, 2, 0 };
static const guint test_tlvs_decode_tags_too_many[] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
    11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
    21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
    31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
    51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
    61, 62, 63, 64, 65, 66, 67, 68, 69, 70
};
static const guint8 test_tlvs_decode_input_dup[] = {
    0x01, 0x02, 0x03, 0x04,
    0x01, 0x00
};
static const guint8 test_tlvs_decode_input_tags_2_x[] = {
    0x02, 0x03, 0x04, 0x05, 0x06,
    0x7f, 0x00
};
static const guint8 test_tlvs_decode_input_tags_x[] = {
    0x7f, 0x00
};
static const guint8 test_tlvs_decode_input_garbage[] = {
    0x01, 0x02, 0x03, 0x04,
    0x05
};
static const guint8 test_tlvs_decode_output_2_data[] = { 0x04, 0x05, 0x06 };
static const GUtilData test_tlvs_decode_output_x_2[] = {
    { NULL, 0 },
    { TEST_ARRAY_AND_SIZE(test_tlvs_decode_output_2_data) }
};

static const TestTlvsDecode test_tlvs_decode_data[] = {
#define TEST_CASE(x) TEST_("tlvs/decode/") x
    {
        TEST_CASE("empty"), { (void*) test_tlvs_decode_data, 0 },
        test_tlvs_decode_tags_1, GUTIL_TLVS_DECODE_NO_FLAGS, 0, NULL
    },{
        TEST_CASE("dup"),
        { TEST_ARRAY_AND_SIZE(test_tlvs_decode_input_dup) },
        test_tlvs_decode_tags_1, GUTIL_TLVS_DECODE_NO_FLAGS,
        GUTIL_TLVS_DECODE_DUPLICATE_TAG, NULL
    },{
        TEST_CASE("unknown_tag/fail/1"),
        { TEST_ARRAY_AND_SIZE(test_tlvs_decode_input_tags_2_x) },
        test_tlvs_decode_tags_too_many, GUTIL_TLVS_DECODE_NO_FLAGS,
        GUTIL_TLVS_DECODE_UNKNOWN_TAG, NULL
    },{
        TEST_CASE("unknown_tag/fail/2"),
        { TEST_ARRAY_AND_SIZE(test_tlvs_decode_input_tags_2_x) },
        test_tlvs_decode_tags_1_2, GUTIL_TLVS_DECODE_NO_FLAGS,
        GUTIL_TLVS_DECODE_UNKNOWN_TAG, NULL
    },{
        TEST_CASE("unknown_tag/ok/1"),
        { TEST_ARRAY_AND_SIZE(test_tlvs_decode_input_tags_2_x) },
        test_tlvs_decode_tags_1_2, GUTIL_TLVS_DECODE_FLAG_SKIP_UNKNOWN_TAGS,
        0x02, test_tlvs_decode_output_x_2
    },{
        TEST_CASE("unknown_tag/ok/2"),
        { TEST_ARRAY_AND_SIZE(test_tlvs_decode_input_tags_x) },
        test_tlvs_decode_tags_1_2, GUTIL_TLVS_DECODE_FLAG_SKIP_UNKNOWN_TAGS,
        0, NULL
    },{
        TEST_CASE("garbage"),
        { TEST_ARRAY_AND_SIZE(test_tlvs_decode_input_garbage) },
        test_tlvs_decode_tags_1, GUTIL_TLVS_DECODE_NO_FLAGS,
        GUTIL_TLVS_DECODE_ERROR, NULL
    }
#undef TEST_CASE
};

static
void
test_tlvs_decode(
    gconstpointer data)
{
    const TestTlvsDecode* test = data;
    int i, n = 0;
    const guint* tag = test->tags;
    GUtilData* vals = NULL;

while (*tag++) n++;
    if (n) {
        vals = g_new(GUtilData, n);
        memset(vals, 0xaa, sizeof(vals[0]) * n);
    }

g_assert_cmpint(gutil_tlvs_decode(&test->input, test->tags, NULL,
        test->flags), == ,test->result);

if (vals) {
        g_assert_cmpint(gutil_tlvs_decode(&test->input, test->tags, vals,
            test->flags), == ,test->result);
    }

if (test->result > 0) {
        for (i = 0; i < n; i++) {
            if (test->result & (1 << i)) {
                const GUtilData* expected = test->values + i;

g_assert_cmpuint(vals[i].size, == ,expected->size);
                g_assert(!memcmp(vals[i].bytes, test->values[i].bytes,
                    expected->size));
            } else {
                g_assert(!vals[i].bytes);
                g_assert_cmpuint(vals[i].size, == ,0);
            }
        }
    }
    g_free(vals);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TESTS_WITH_DATA(x) \
    do { int i; for (i = 0; i < G_N_ELEMENTS(x##_data); i++) {    \
        g_test_add_data_func(x##_data[i].name, x##_data + i, x); \
    } } while (FALSE)

int main(int argc, char* argv[])
{
    g_test_init(&argc, &argv, NULL);
    test_init(&test_opt, argc, argv);
    g_test_add_func(TEST_("mbn/corner_cases"), test_mbn_corner_cases);
    g_test_add_func(TEST_("tlv/corner_cases"), test_tlv_corner_cases);
    g_test_add_func(TEST_("signed_mbn/decode2"), test_signed_mbn_decode2);
    g_test_add_func(TEST_("unsigned_mbn/decode2"), test_unsigned_mbn_decode2);
    TESTS_WITH_DATA(test_signed_mbn_size);
    TESTS_WITH_DATA(test_signed_mbn_encode);
    TESTS_WITH_DATA(test_signed_mbn_decode_ok);
    TESTS_WITH_DATA(test_signed_mbn_decode_fail);
    TESTS_WITH_DATA(test_unsigned_mbn_size);
    TESTS_WITH_DATA(test_unsigned_mbn_encode);
    TESTS_WITH_DATA(test_unsigned_mbn_decode_ok);
    TESTS_WITH_DATA(test_unsigned_mbn_decode_fail);
    TESTS_WITH_DATA(test_tlv_size);
    TESTS_WITH_DATA(test_tlv_encode);
    TESTS_WITH_DATA(test_tlv_decode_ok);
    TESTS_WITH_DATA(test_tlv_decode_fail);
    TESTS_WITH_DATA(test_tlvs_decode);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000003D000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000003100000000libglibutil-1680886706.91f2bff/test/test_history0707010000003E000081A400000000000000000000000164304BB20000004F000000000000000000000000000000000000003A00000000libglibutil-1680886706.91f2bff/test/test_history/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_history

include ../common/Makefile
0707010000003F000081A400000000000000000000000164304BB200002752000000000000000000000000000000000000004000000000libglibutil-1680886706.91f2bff/test/test_history/test_history.c/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_history.h"

static TestOpt test_opt;
static gint64 test_history_time;

static
gint64
test_history_time_func(void)
{
    return test_history_time;
}

/*==========================================================================*
 * NULL tolerance
 *==========================================================================*/

static
void
test_history_null(
    void)
{
    gutil_int_history_unref(NULL);
    gutil_int_history_clear(NULL);
    g_assert(!gutil_int_history_ref(NULL));
    g_assert(!gutil_int_history_size(NULL));
    g_assert(!gutil_int_history_interval(NULL));
    g_assert(!gutil_int_history_add(NULL, 1));
    g_assert(!gutil_int_history_median(NULL, 0));
    g_assert(!gutil_int_history_new(0, 0));
    g_assert(!gutil_int_history_new(1, 0));
    g_assert(!gutil_int_history_new(0, 1));
}

/*==========================================================================*
 * Basic
 *==========================================================================*/

static
void
test_history_basic(
    void)
{
    /* The default time functon returns real time, not usable for testing */
    GUtilIntHistory* h = gutil_int_history_new(1, 1);
    g_assert(gutil_int_history_size(h) == 0);
    g_assert(gutil_int_history_interval(h) == 0);
    gutil_int_history_unref(gutil_int_history_ref(h));
    gutil_int_history_unref(h);
}

/*==========================================================================*
 * Clear
 *==========================================================================*/

static
void
test_history_clear(
    void)
{
    GUtilIntHistory* h = gutil_int_history_new_full(2, 2,
        test_history_time_func);
    g_assert(gutil_int_history_median(h, 0) == 0);
    test_history_time = 2;
    g_assert(gutil_int_history_add(h, 1) == 1);
    /* Time hasn't changed, 1 is replaced with 2 */
    g_assert(gutil_int_history_add(h, 2) == 2);
    /* Time goes back, 2 is replaced with 3 */
    test_history_time -=1;
    g_assert(gutil_int_history_add(h, 3) == 3);
    test_history_time += 2;
    g_assert(gutil_int_history_add(h, 5) == 4);
    g_assert(gutil_int_history_size(h) == 2);
    g_assert(gutil_int_history_median(h, 0) == 4);
    g_assert(gutil_int_history_interval(h) == 1);
    gutil_int_history_clear(h);
    g_assert(!gutil_int_history_size(h));
    g_assert(!gutil_int_history_interval(h));
    gutil_int_history_unref(h);
}

/*==========================================================================*
 * Median
 *==========================================================================*/

static
void
test_history_median(
    void)
{
    GUtilIntHistory* h = gutil_int_history_new_full(2, 2,
        test_history_time_func);
    test_history_time = 1;
    g_assert(gutil_int_history_add(h, 1) == 1);
    test_history_time += 1;
    g_assert(gutil_int_history_add(h, 5) == 3);
    test_history_time += 1;
    /* Still the same, both ends of the interval are inclusive */
    g_assert(gutil_int_history_median(h, 0) == 3);
    test_history_time += 1;
    /* Now one entry expires */
    g_assert(gutil_int_history_median(h, 0) == 5);
    test_history_time += 1;
    /* The last one expires too */
    g_assert(gutil_int_history_median(h, 0) == 0);
    gutil_int_history_unref(h);
}

/*==========================================================================*
 * Size
 *==========================================================================*/

static
void
test_history_size(
    void)
{
    GUtilIntHistory* h = gutil_int_history_new_full(2, 2,
        test_history_time_func);
    test_history_time = 1;
    g_assert(gutil_int_history_add(h, 1) == 1);
    test_history_time += 1;
    g_assert(gutil_int_history_add(h, 5) == 3);
    g_assert(gutil_int_history_size(h) == 2);
    test_history_time += 1;
    /* Still the same, both ends of the interval are inclusive */
    g_assert(gutil_int_history_size(h) == 2);
    test_history_time += 1;
    /* Now one entry expires */
    g_assert(gutil_int_history_size(h) == 1);
    test_history_time += 1;
    /* The last one expires too */
    g_assert(gutil_int_history_size(h) == 0);
    gutil_int_history_unref(h);
}

/*==========================================================================*
 * Interval
 *==========================================================================*/

static
void
test_history_interval(
    void)
{
    GUtilIntHistory* h = gutil_int_history_new_full(2, 3,
        test_history_time_func);
    test_history_time = 1;
    g_assert(gutil_int_history_add(h, 1) == 1);
    test_history_time += 1;
    g_assert(gutil_int_history_add(h, 5) == 3);
    g_assert(gutil_int_history_interval(h) == 1);
    test_history_time += 1;
    /* Both ends of the interval are inclusive */
    g_assert(gutil_int_history_interval(h) == 2);
    test_history_time += 2;
    /* Now one entry with timestamp 1 expires, the one remaining has
     * timestamp 2, the current time is 5 so the interval becomes 3 */
    g_assert(gutil_int_history_interval(h) == 3);
    test_history_time += 1;
    /* The last one expires too */
    g_assert(gutil_int_history_interval(h) == 0);
    gutil_int_history_unref(h);
}

/*==========================================================================*
 * Data
 *==========================================================================*/

typedef struct test_history_sample {
    gint64 time;
    int value;
    int median;
} TestHistorySample;

typedef struct test_history_data {
    int max_size;
    gint64 max_interval;
    const TestHistorySample* samples;
    int count;
    guint size;
    gint64 interval;
} TestHistoryData;

static
void
test_history_data(
    gconstpointer test_data)
{
    int i;
    const TestHistoryData* data = test_data;
    GUtilIntHistory* h = gutil_int_history_new_full(data->max_size,
        data->max_interval, test_history_time_func);
    for (i=0; i<data->count; i++) {
        const TestHistorySample* sample = data->samples + i;
        test_history_time = sample->time;
        g_assert(gutil_int_history_add(h, sample->value) == sample->median);
    }
    g_assert(gutil_int_history_size(h) == data->size);
    g_assert(gutil_int_history_interval(h) == data->interval);
    test_history_time += data->max_interval + 1;
    g_assert(!gutil_int_history_size(h));
    g_assert(!gutil_int_history_interval(h));
    gutil_int_history_unref(h);
}

/*==========================================================================*
 * Common
 *==========================================================================*/
static const TestHistorySample samples1[] = {{1, 1, 1}};
static const TestHistoryData data1 = {
    1, 1, samples1, G_N_ELEMENTS(samples1), 1, 0
};

static const TestHistorySample samples2[] = {{1, 1, 1}, {3, 2, 2}};
static const TestHistoryData data2 = {
    1, 1, samples2, G_N_ELEMENTS(samples2), 1, 0
};

static const TestHistorySample samples3[] = {
    {1, 2, 2}, {3, 2, 2}, {4, 8, 3}
};
static const TestHistoryData data3 = {
    3, 4, samples3, G_N_ELEMENTS(samples3), 3, 3
};

static const TestHistorySample samples4[] = {
    {1, 2, 2}, {3, 2, 2}, {4, 8, 5}
};
static const TestHistoryData data4 = {
    3, 2, samples4, G_N_ELEMENTS(samples4), 2, 1
};

static const TestHistorySample samples5[] = {
    {1, 2, 2}, {3, 2, 2}, {4, 8, 5}
};
static const TestHistoryData data5 = {
    2, 4, samples5, G_N_ELEMENTS(samples5), 2, 1
};

#define TEST_PREFIX "/history/"

int main(int argc, char* argv[])
{
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_PREFIX "null", test_history_null);
    g_test_add_func(TEST_PREFIX "basic", test_history_basic);
    g_test_add_func(TEST_PREFIX "clear", test_history_clear);
    g_test_add_func(TEST_PREFIX "median", test_history_median);
    g_test_add_func(TEST_PREFIX "size", test_history_size);
    g_test_add_func(TEST_PREFIX "interval", test_history_interval);
    g_test_add_data_func(TEST_PREFIX "data1", &data1, test_history_data);
    g_test_add_data_func(TEST_PREFIX "data2", &data2, test_history_data);
    g_test_add_data_func(TEST_PREFIX "data3", &data3, test_history_data);
    g_test_add_data_func(TEST_PREFIX "data4", &data4, test_history_data);
    g_test_add_data_func(TEST_PREFIX "data5", &data5, test_history_data);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000040000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000003200000000libglibutil-1680886706.91f2bff/test/test_idlepool07070100000041000081A400000000000000000000000164304BB200000050000000000000000000000000000000000000003B00000000libglibutil-1680886706.91f2bff/test/test_idlepool/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_idlepool

include ../common/Makefile
07070100000042000081A400000000000000000000000164304BB200001C83000000000000000000000000000000000000004200000000libglibutil-1680886706.91f2bff/test/test_idlepool/test_idlepool.c/*
 * Copyright (C) 2016-2018 Jolla Ltd.
 * Copyright (C) 2016-2018 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_idlepool.h"
#include "gutil_strv.h"
#include "gutil_log.h"

#define TEST_TIMEOUT (10) /* seconds */

static TestOpt test_opt;

static
gboolean
test_timeout(
    gpointer loop)
{
    g_assert(!"TIMEOUT");
    return G_SOURCE_REMOVE;
}

static
void
test_done(
    gpointer loop)
{
    g_main_loop_quit(loop);
}

/*==========================================================================*
 * Null
 *==========================================================================*/

static
void
test_null(
    void)
{
    GUtilIdlePool* pool = gutil_idle_pool_new();

/* These have no effect, just testing NULL-telerance */
    gutil_idle_pool_add_strv(NULL, NULL);
    gutil_idle_pool_add_strv(pool, NULL);
    gutil_idle_pool_add_ptr_array(NULL, NULL);
    gutil_idle_pool_add_ptr_array(pool, NULL);
    gutil_idle_pool_add_ptr_array_ref(NULL, NULL);
    gutil_idle_pool_add_ptr_array_ref(pool, NULL);
    gutil_idle_pool_add_variant(NULL, NULL);
    gutil_idle_pool_add_variant(pool, NULL);
    gutil_idle_pool_add_variant_ref(NULL, NULL);
    gutil_idle_pool_add_variant_ref(pool, NULL);
    gutil_idle_pool_add_object(NULL, NULL);
    gutil_idle_pool_add_object(pool, NULL);
    gutil_idle_pool_add_object_ref(NULL, NULL);
    gutil_idle_pool_add_object_ref(pool, NULL);
    gutil_idle_pool_add_bytes(NULL, NULL);
    gutil_idle_pool_add_bytes(pool, NULL);
    gutil_idle_pool_add_bytes_ref(NULL, NULL);
    gutil_idle_pool_add_bytes_ref(pool, NULL);
    gutil_idle_pool_add(NULL, NULL, NULL);
    gutil_idle_pool_add(pool, NULL, NULL);
    gutil_idle_pool_ref(NULL);
    gutil_idle_pool_unref(NULL);
    gutil_idle_pool_drain(NULL);
    gutil_idle_pool_unref(pool);
}

/*==========================================================================*
 * Basic
 *==========================================================================*/

typedef struct test_basic {
    GUtilIdlePool* pool;
    gboolean array_free_count;
    gboolean ok;
} TestBasic;

static
void
test_basic_array_free(
    gpointer param)
{
    TestBasic* test = param;
    test->array_free_count++;
}

static
void
test_basic_unref_pool(
    gpointer param)
{
    TestBasic* test = param;
    gutil_idle_pool_unref(test->pool);
}

static
void
test_basic_last(
    gpointer param)
{
    TestBasic* test = param;
    if (test->array_free_count == 1) {
        test->ok = TRUE;
    }
}

static
void
test_basic_add_during_drain(
    gpointer param)
{
    /* Add an item when pool is being drained */
    TestBasic* test = param;
    gutil_idle_pool_add(test->pool, test, test_basic_last);
}

static
void
test_basic(
    void)
{
    GPtrArray* array = g_ptr_array_new_with_free_func(test_basic_array_free);
    GVariant* variant = g_variant_take_ref(g_variant_new_int32(1));
    GObject* object = g_object_new(TEST_OBJECT_TYPE, NULL);
    GMainLoop* loop = g_main_loop_new(NULL, TRUE);
    GStrV* strv = gutil_strv_add(NULL, "foo");
    GBytes* bytes = g_bytes_new("bar", 3);
    TestBasic test;

memset(&test, 0, sizeof(test));
    test.pool = gutil_idle_pool_new();

if (!(test_opt.flags & TEST_FLAG_DEBUG)) {
        g_timeout_add_seconds(TEST_TIMEOUT, test_timeout, loop);
    }

gutil_idle_pool_unref(gutil_idle_pool_new());
    gutil_idle_pool_add_strv(test.pool, strv);
    g_ptr_array_add(array, &test);
    gutil_idle_pool_add_ptr_array_ref(test.pool, array);
    g_ptr_array_unref(array);
    gutil_idle_pool_add_variant_ref(test.pool, variant);
    g_variant_unref(variant);
    gutil_idle_pool_add_object_ref(test.pool, object);
    g_object_unref(object);
    gutil_idle_pool_add_bytes_ref(test.pool, bytes);
    g_bytes_unref(bytes);
    gutil_idle_pool_ref(test.pool);
    gutil_idle_pool_add(test.pool, &test, test_basic_unref_pool);
    gutil_idle_pool_add(test.pool, loop, test_done);
    g_main_loop_run(loop);
    gutil_idle_pool_add(test.pool, &test, test_basic_add_during_drain);
    gutil_idle_pool_destroy(test.pool);

g_assert(test.ok);
    g_assert(!test_object_count);
    g_main_loop_unref(loop);
}

/*==========================================================================*
 * Shared
 *==========================================================================*/

static
void
test_shared(
    void)
{
    GUtilIdlePool* shared = NULL;
    GUtilIdlePool* pool = gutil_idle_pool_get(&shared);
    GUtilIdlePool* pool2 = gutil_idle_pool_get(NULL);
    GMainLoop* loop = g_main_loop_new(NULL, TRUE);

g_assert(shared == pool);
    g_assert(gutil_idle_pool_get(&shared) == pool);
    g_assert(pool2 != pool);

if (!(test_opt.flags & TEST_FLAG_DEBUG)) {
        g_timeout_add_seconds(TEST_TIMEOUT, test_timeout, loop);
    }

/* The pool invokes the callback and destroys itself */
    gutil_idle_pool_add(pool, loop, test_done);
    g_main_loop_run(loop);
    g_assert(!shared);
    gutil_idle_pool_unref(pool2);
    g_main_loop_unref(loop);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_(test) "/idlepool/" test

int main(int argc, char* argv[])
{
    G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
    g_type_init();
    G_GNUC_END_IGNORE_DEPRECATIONS;
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_("null"), test_null);
    g_test_add_func(TEST_("basic"), test_basic);
    g_test_add_func(TEST_("shared"), test_shared);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000043000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000003300000000libglibutil-1680886706.91f2bff/test/test_idlequeue07070100000044000081A400000000000000000000000164304BB200000051000000000000000000000000000000000000003C00000000libglibutil-1680886706.91f2bff/test/test_idlequeue/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_idlequeue

include ../common/Makefile
07070100000045000081A400000000000000000000000164304BB200002284000000000000000000000000000000000000004400000000libglibutil-1680886706.91f2bff/test/test_idlequeue/test_idlequeue.c/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_idlequeue.h"
#include "gutil_log.h"

#define TEST_TIMEOUT (10) /* seconds */

static TestOpt test_opt;

static
void
test_idlequeue_noooo(
    gpointer param)
{
    g_assert(!"NOOO!!!");
}

static
gboolean
test_idlequeue_timeout(
    gpointer param)
{
    g_assert(!"TIMEOUT");
    return G_SOURCE_REMOVE;
}

static
void
test_idlequeue_loop_quit(
    gpointer loop)
{
    g_main_loop_quit(loop);
}

static
void
test_idlequeue_int_inc(
    gpointer data)
{
    int* ptr = data;
    (*ptr)++;
}

/*==========================================================================*
 * Null
 *==========================================================================*/

static
void
test_idlequeue_null(
    void)
{
    /* Test NULL tolerance */
    int i = 0;
    g_assert(!gutil_idle_queue_ref(NULL));
    gutil_idle_queue_unref(NULL);
    gutil_idle_queue_free(NULL);
    g_assert(!gutil_idle_queue_contains_tag(NULL, 0));
    g_assert(!gutil_idle_queue_cancel_tag(NULL, 0));
    gutil_idle_queue_cancel_all(NULL);
    gutil_idle_queue_add(NULL, NULL, NULL);
    gutil_idle_queue_add_full(NULL, NULL, NULL, NULL);
    gutil_idle_queue_add_tag(NULL, 0, NULL, NULL);
    gutil_idle_queue_add_tag_full(NULL, 0, NULL, NULL, NULL);
    /* IF queue is NULL, the destroy function gets invoked immediately: */
    gutil_idle_queue_add_tag_full(NULL, 0, NULL, &i, test_idlequeue_int_inc);
    g_assert(i == 1);
}

/*==========================================================================*
 * Basic
 *==========================================================================*/

static
void
test_idlequeue_basic(
    void)
{
    guint timeout_id = 0;
    int count = 0;
    GUtilIdleQueue* q = gutil_idle_queue_new();
    GMainLoop* loop = g_main_loop_new(NULL, TRUE);

gutil_idle_queue_unref(gutil_idle_queue_ref(q));
    gutil_idle_queue_add_tag_full(q, 1, test_idlequeue_int_inc, &count, NULL);
    gutil_idle_queue_add_tag_full(q, 2, NULL, &count, test_idlequeue_int_inc);
    gutil_idle_queue_add_tag_full(q, 3, test_idlequeue_loop_quit, loop, NULL);
    g_assert(!gutil_idle_queue_contains_tag(q, 0));
    g_assert(gutil_idle_queue_contains_tag(q, 1));
    g_assert(gutil_idle_queue_contains_tag(q, 2));
    g_assert(gutil_idle_queue_contains_tag(q, 3));

if (!(test_opt.flags & TEST_FLAG_DEBUG)) {
        timeout_id = g_timeout_add_seconds(TEST_TIMEOUT,
            test_idlequeue_timeout, NULL);
    }

g_main_loop_run(loop);
    g_assert(count == 2);

if (timeout_id) {
        g_source_remove(timeout_id);
    }

gutil_idle_queue_unref(q);
    g_main_loop_unref(loop);
}
/*==========================================================================*
 * Add
 *==========================================================================*/

typedef struct test_idlequeue_add_data {
    GUtilIdleQueue* q;
    GMainLoop* loop;
} TestAdd;

static
void
test_idlequeue_add_cb(
    gpointer data)
{
    /* Adding new item from the callback */
    TestAdd* test = data;
    gutil_idle_queue_add(test->q, test_idlequeue_loop_quit, test->loop);
}

static
void
test_idlequeue_add(
    void)
{
    guint timeout_id = 0;
    TestAdd test;

test.q = gutil_idle_queue_new();
    test.loop = g_main_loop_new(NULL, TRUE);

if (!(test_opt.flags & TEST_FLAG_DEBUG)) {
        timeout_id = g_timeout_add_seconds(TEST_TIMEOUT,
            test_idlequeue_timeout, NULL);
    }

gutil_idle_queue_add(test.q, test_idlequeue_add_cb, &test);
    g_main_loop_run(test.loop);

if (timeout_id) {
        g_source_remove(timeout_id);
    }

gutil_idle_queue_unref(test.q);
    g_main_loop_unref(test.loop);
}

/*==========================================================================*
 * Cancel
 *==========================================================================*/

static
void
test_idlequeue_cancel(
    void)
{
    int count = 0;
    GUtilIdleQueue* q = gutil_idle_queue_new();

/* Destroying the queue cancels the callbacks */
    gutil_idle_queue_add(q, test_idlequeue_int_inc, &count);
    gutil_idle_queue_add_full(q, NULL, &count, test_idlequeue_int_inc);
    gutil_idle_queue_add_full(q, NULL, &count, test_idlequeue_int_inc);
    gutil_idle_queue_unref(q);
    g_assert(count == 2);
    count = 0;

/* Cancelling all requests in an empty queue has no effect */
    q = gutil_idle_queue_new();
    gutil_idle_queue_cancel_all(q);

/* Cancel by tag */
    gutil_idle_queue_add_tag_full(q, 1, NULL, &count, test_idlequeue_int_inc);
    gutil_idle_queue_add_tag_full(q, 2, NULL, &count, test_idlequeue_int_inc);
    gutil_idle_queue_add_tag_full(q, 3, NULL, &count, test_idlequeue_int_inc);
    gutil_idle_queue_add_tag_full(q, 4, NULL, &count, test_idlequeue_int_inc);
    g_assert(!gutil_idle_queue_cancel_tag(q, 0));
    g_assert(gutil_idle_queue_cancel_tag(q, 3));
    g_assert(gutil_idle_queue_cancel_tag(q, 4));
    g_assert(gutil_idle_queue_cancel_tag(q, 1));
    g_assert(gutil_idle_queue_cancel_tag(q, 2));
    g_assert(!gutil_idle_queue_cancel_tag(q, 1));
    g_assert(count == 4);
    count = 0;

gutil_idle_queue_free(q);
}

/*==========================================================================*
 * CancelAll
 *==========================================================================*/

static
void
test_idlequeue_cancel_all_submit_new(
    gpointer q)
{
    /* Adding new item from the destroy callback */
    gutil_idle_queue_add_tag(q, 42, test_idlequeue_noooo, NULL);
}

static
void
test_idlequeue_cancel_all(
    void)
{
    int count = 0;
    GUtilIdleQueue* q = gutil_idle_queue_new();

/* Add new item from the destroy callback */
    gutil_idle_queue_add(q, test_idlequeue_int_inc, &count);
    gutil_idle_queue_add_tag_full(q, 1, NULL, &count, test_idlequeue_int_inc);
    gutil_idle_queue_add_tag_full(q, 2, NULL, q,
        test_idlequeue_cancel_all_submit_new);
    gutil_idle_queue_cancel_all(q);
    g_assert(count == 1);

/* We should still have 42 in there */
    g_assert(!gutil_idle_queue_contains_tag(q, 1));
    g_assert(!gutil_idle_queue_contains_tag(q, 2));
    g_assert(gutil_idle_queue_contains_tag(q, 42));
    gutil_idle_queue_cancel_all(q);

/* Now it has to be really empty */
    g_assert(!gutil_idle_queue_contains_tag(q, 42));
    gutil_idle_queue_free(q);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_PREFIX "/idlequeue/"

int main(int argc, char* argv[])
{
    G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
    g_type_init();
    G_GNUC_END_IGNORE_DEPRECATIONS;
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_PREFIX "null", test_idlequeue_null);
    g_test_add_func(TEST_PREFIX "basic", test_idlequeue_basic);
    g_test_add_func(TEST_PREFIX "add", test_idlequeue_add);
    g_test_add_func(TEST_PREFIX "cancel", test_idlequeue_cancel);
    g_test_add_func(TEST_PREFIX "cancel_all", test_idlequeue_cancel_all);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000046000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000003100000000libglibutil-1680886706.91f2bff/test/test_inotify07070100000047000081A400000000000000000000000164304BB20000004F000000000000000000000000000000000000003A00000000libglibutil-1680886706.91f2bff/test/test_inotify/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_inotify

include ../common/Makefile
07070100000048000081A400000000000000000000000164304BB200002852000000000000000000000000000000000000004000000000libglibutil-1680886706.91f2bff/test/test_inotify/test_inotify.c/*
 * Copyright (C) 2016-2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of the Jolla Ltd nor the names of its contributors
 *      may be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_inotify.h"
#include "gutil_macros.h"
#include "gutil_log.h"

#include <sys/inotify.h>

#define TEST_TIMEOUT (10) /* seconds */
#define TMP_DIR_TEMPLATE "test_inotify_XXXXXX"

static TestOpt test_opt;

typedef struct test_inotify {
    const char* name;
    GMainLoop* loop;
    GUtilInotifyWatch* watch1;
    GUtilInotifyWatch* watch2;
    char* dir1;
    char* dir2;
    guint timeout_id;
    gboolean array_free_count;
    gboolean ok;
} TestInotify;

static
gboolean
test_inotify_timeout(
    gpointer param)
{
    TestInotify* test = param;
    GERR("%s TIMEOUT", test->name);
    test->timeout_id = 0;
    g_main_loop_quit(test->loop);
    return G_SOURCE_REMOVE;
}

static
void
test_inotify_common(
    TestInotify* test,
    gboolean (*init)(TestInotify* test),
    void (*deinit)(TestInotify* test))
{
    const int mask = IN_ALL_EVENTS | IN_ONLYDIR | IN_EXCL_UNLINK;

test->ok = FALSE;
    test->dir1 = g_dir_make_tmp(TMP_DIR_TEMPLATE, NULL);
    test->dir2 = g_dir_make_tmp(TMP_DIR_TEMPLATE, NULL);
    test->watch1 = gutil_inotify_watch_new(test->dir1, mask);
    test->watch2 = gutil_inotify_watch_new(test->dir2, mask);

GDEBUG("%s: directory 1: %s", test->name, test->dir1);
    GDEBUG("%s: directory 2: %s", test->name, test->dir2);

/* Initialize the event loop */
    test->loop = g_main_loop_new(NULL, TRUE);
    if (!(test_opt.flags & TEST_FLAG_DEBUG)) {
        test->timeout_id = g_timeout_add_seconds(TEST_TIMEOUT,
            test_inotify_timeout, test);
    }

if (init) {
        init(test);
    }

/* Run the event loop */
    g_main_loop_run(test->loop);

if (deinit) {
        deinit(test);
    }

g_assert(test->ok);
    if (!(test_opt.flags & TEST_FLAG_DEBUG)) {
        g_assert(test->timeout_id);
        g_source_remove(test->timeout_id);
    }

g_main_loop_unref(test->loop);
    gutil_inotify_watch_destroy(test->watch1);
    gutil_inotify_watch_destroy(test->watch2);
    remove(test->dir1);
    remove(test->dir2);
    g_free(test->dir1);
    g_free(test->dir2);
}

/*==========================================================================*
 * Basic
 *==========================================================================*/

static
void
test_inotify_basic(
    void)
{
    char* dir = g_dir_make_tmp(TMP_DIR_TEMPLATE, NULL);
    GUtilInotifyWatch* watch = gutil_inotify_watch_new(dir, IN_ALL_EVENTS);

/* These have no effect, just testing NULL-telerance */
    g_assert(!gutil_inotify_watch_new(NULL, 0));
    g_assert(!gutil_inotify_watch_ref(NULL));
    gutil_inotify_watch_unref(NULL);
    gutil_inotify_watch_destroy(NULL);
    gutil_inotify_watch_remove_handler(NULL, 0);
    gutil_inotify_watch_remove_handler(watch, 0);

g_assert(!gutil_inotify_watch_callback_new(NULL, 0, NULL, NULL));
    g_assert(!gutil_inotify_watch_add_handler(NULL, NULL, NULL));
    g_assert(!gutil_inotify_watch_add_handler(watch, NULL, NULL));

gutil_inotify_watch_destroy(watch);

/* Remove the directory and try to watch it. That should fail */
    remove(dir);
    g_assert(!gutil_inotify_watch_new(dir, IN_ALL_EVENTS));
    g_free(dir);
}

/*==========================================================================*
 * Move
 *==========================================================================*/

typedef struct test_inotify_move {
    TestInotify test;
    const char* fname;
    char* dest;
    gulong id1;
    gulong id2;
    int from;
} TestInotifyMove;

static
void
test_inotify_move_from(
    GUtilInotifyWatch* watch,
    guint mask,
    guint cookie,
    const char* name,
    void* arg)
{
    TestInotifyMove* move = arg;
    if ((mask & IN_MOVED_FROM) && !g_strcmp0(move->fname, name)) {
        GDEBUG("%s moved from %s", name, move->test.dir1);
        move->from++;
    }
}

static
void
test_inotify_move_to(
    GUtilInotifyWatch* watch,
    guint mask,
    guint cookie,
    const char* name,
    void* arg)
{
    TestInotifyMove* move = arg;
    if ((mask & IN_MOVED_TO) && !g_strcmp0(move->fname, name)) {
        GDEBUG("%s moved to %s", name, move->test.dir2);
        if (move->from == 1) {
            move->test.ok = TRUE;
            g_main_loop_quit(move->test.loop);
        }
    }
}

static
gboolean
test_inotify_move_init(
    TestInotify* test)
{
    TestInotifyMove* move = G_CAST(test, TestInotifyMove, test);
    char* src;

move->fname = "test";
    src = g_strconcat(test->dir1, G_DIR_SEPARATOR_S, move->fname, NULL);
    move->dest = g_strconcat(test->dir2, G_DIR_SEPARATOR_S, move->fname, NULL);
    move->id1 = gutil_inotify_watch_add_handler(test->watch1,
        test_inotify_move_from, move);
    move->id2 = gutil_inotify_watch_add_handler(test->watch2,
        test_inotify_move_to, move);
    g_file_set_contents(src, "contents", -1, NULL);
    GDEBUG("%s -> %s", src, move->dest);
    rename(src, move->dest);
    g_free(src);
    return TRUE;
}

static
void
test_inotify_move_deinit(
    TestInotify* test)
{
    TestInotifyMove* move = G_CAST(test, TestInotifyMove, test);
    gutil_inotify_watch_remove_handler(test->watch1, move->id1);
    gutil_inotify_watch_remove_handler(test->watch2, move->id2);
    remove(move->dest);
    g_free(move->dest);
}

static
void
test_inotify_move(
    void)
{
    TestInotifyMove move;
    memset(&move, 0, sizeof(move));
    move.test.name = "move";
    test_inotify_common(&move.test,
        test_inotify_move_init,
        test_inotify_move_deinit);
}

/*==========================================================================*
 * Callback
 *==========================================================================*/

typedef struct test_inotify_callback {
    TestInotify test;
    const char* fname;
    char* dest;
    GUtilInotifyWatchCallback* cb1;
    GUtilInotifyWatchCallback* cb2;
    int from;
} TestInotifyCallback;

static
void
test_inotify_callback_from(
    GUtilInotifyWatch* watch,
    guint mask,
    guint cookie,
    const char* name,
    void* arg)
{
    TestInotifyCallback* cb = arg;
    if ((mask & IN_MOVED_FROM) && !g_strcmp0(cb->fname, name)) {
        GDEBUG("%s moved from %s", name, cb->test.dir1);
        cb->from++;
    }
}

static
void
test_inotify_callback_to(
    GUtilInotifyWatch* watch,
    guint mask,
    guint cookie,
    const char* name,
    void* arg)
{
    TestInotifyCallback* cb = arg;
    if ((mask & IN_MOVED_TO) && !g_strcmp0(cb->fname, name)) {
        GDEBUG("%s moved to %s", name, cb->test.dir2);
        if (cb->from == 1) {
            cb->test.ok = TRUE;
            g_main_loop_quit(cb->test.loop);
        }
    }
}

static
gboolean
test_inotify_callback_init(
    TestInotify* test)
{
    TestInotifyCallback* cb = G_CAST(test, TestInotifyCallback, test);
    char* src;
    cb->fname = "test";
    src = g_strconcat(test->dir1, G_DIR_SEPARATOR_S, cb->fname, NULL);
    cb->dest = g_strconcat(test->dir2, G_DIR_SEPARATOR_S, cb->fname, NULL);
    cb->cb1 = gutil_inotify_watch_callback_new(test->dir1, IN_MOVED_FROM,
        test_inotify_callback_from, cb);
    cb->cb2 = gutil_inotify_watch_callback_new(test->dir2, IN_MOVED_TO,
        test_inotify_callback_to, cb);
    g_file_set_contents(src, "contents", -1, NULL);
    GDEBUG("%s -> %s", src, cb->dest);
    rename(src, cb->dest);
    g_free(src);
    return TRUE;
}

static
void
test_inotify_callback_deinit(
    TestInotify* test)
{
    TestInotifyCallback* cb = G_CAST(test, TestInotifyCallback, test);
    gutil_inotify_watch_callback_free(cb->cb1);
    gutil_inotify_watch_callback_free(cb->cb2);
    gutil_inotify_watch_callback_free(NULL);
    remove(cb->dest);
    g_free(cb->dest);
}

static
void
test_inotify_callback(
    void)
{
    TestInotifyCallback callback;
    memset(&callback, 0, sizeof(callback));
    callback.test.name = "callback";
    test_inotify_common(&callback.test,
        test_inotify_callback_init,
        test_inotify_callback_deinit);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_PREFIX "/inotify/"

int main(int argc, char* argv[])
{
    G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
    g_type_init();
    G_GNUC_END_IGNORE_DEPRECATIONS;
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_PREFIX "basic", test_inotify_basic);
    g_test_add_func(TEST_PREFIX "move", test_inotify_move);
    g_test_add_func(TEST_PREFIX "callback", test_inotify_callback);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000049000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000003200000000libglibutil-1680886706.91f2bff/test/test_intarray0707010000004A000081A400000000000000000000000164304BB200000050000000000000000000000000000000000000003B00000000libglibutil-1680886706.91f2bff/test/test_intarray/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_intarray

include ../common/Makefile
0707010000004B000081A400000000000000000000000164304BB200002B0E000000000000000000000000000000000000004200000000libglibutil-1680886706.91f2bff/test/test_intarray/test_intarray.c/*
 * Copyright (C) 2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_intarray.h"
#include "gutil_ints.h"

static TestOpt test_opt;

/*==========================================================================*
 * NULL tolerance
 *==========================================================================*/

static
void
test_intarray_null(
    void)
{
    gutil_int_array_unref(NULL);
    g_assert(!gutil_int_array_ref(NULL));
    g_assert(!gutil_int_array_free(NULL, FALSE));
    g_assert(!gutil_int_array_free_to_ints(NULL));
    g_assert(!gutil_int_array_append(NULL, 0));
    g_assert(!gutil_int_array_append_vals(NULL, NULL, 0));
    g_assert(!gutil_int_array_prepend(NULL, 0));
    g_assert(!gutil_int_array_prepend_vals(NULL, NULL, 0));
    g_assert(!gutil_int_array_insert(NULL, 0, 0));
    g_assert(!gutil_int_array_insert_vals(NULL, 0, NULL, 0));
    g_assert(gutil_int_array_find(NULL, 0) == -1);
    g_assert(!gutil_int_array_contains(NULL, 0));
    g_assert(!gutil_int_array_remove(NULL, 0));
    g_assert(!gutil_int_array_remove_fast(NULL, 0));
    g_assert(!gutil_int_array_remove_all(NULL, 0));
    g_assert(!gutil_int_array_remove_all_fast(NULL, 0));
    g_assert(!gutil_int_array_set_count(NULL, 0));
    g_assert(!gutil_int_array_remove_index(NULL, 0));
    g_assert(!gutil_int_array_remove_index_fast(NULL, 0));
    g_assert(!gutil_int_array_remove_range(NULL, 0, 0));
    gutil_int_array_sort_ascending(NULL);
    gutil_int_array_sort_descending(NULL);
}

/*==========================================================================*
 * Basic
 *==========================================================================*/

static
void
test_intarray_basic(
    void)
{
    static const int vals[] = { 0, 1, 2 };
    GUtilIntArray* a = gutil_int_array_new();
    GUtilInts* ints;

g_assert(gutil_int_array_append(a, 0) == a);
    g_assert(a->count == 1);
    g_assert(a->data[0] == 0);

g_assert(gutil_int_array_append(a, 1) == a);
    g_assert(a->count == 2);
    g_assert(a->data[0] == 0);
    g_assert(a->data[1] == 1);

g_assert(gutil_int_array_prepend(a, 2) == a);
    g_assert(a->count == 3);
    g_assert(a->data[0] == 2);
    g_assert(a->data[1] == 0);
    g_assert(a->data[2] == 1);

gutil_int_array_sort_ascending(a);
    g_assert(a->data[0] == 0);
    g_assert(a->data[1] == 1);
    g_assert(a->data[2] == 2);

gutil_int_array_sort_descending(a);
    g_assert(a->data[0] == 2);
    g_assert(a->data[1] == 1);
    g_assert(a->data[2] == 0);

g_assert(gutil_int_array_remove_index_fast(a, 0) == a);
    g_assert(a->count == 2);
    g_assert(a->data[0] == 0);
    g_assert(a->data[1] == 1);

g_assert(gutil_int_array_remove_range(a, 1, 2) == a);
    g_assert(a->count == 1);
    g_assert(a->data[0] == 0);

/* This removes nothing (position out of range) */
    g_assert(gutil_int_array_remove_range(a, 1, 2) == a);
    g_assert(a->count == 1);
    g_assert(a->data[0] == 0);

/* This too (zero count) */
    g_assert(gutil_int_array_remove_range(a, 0, 0) == a);
    g_assert(a->count == 1);
    g_assert(a->data[0] == 0);

g_assert(gutil_int_array_remove_range(a, 0, 1) == a);
    g_assert(a->count == 0);

g_assert(gutil_int_array_insert(a, 0, 0) == a);
    g_assert(gutil_int_array_insert(a, 0, 1) == a);
    g_assert(a->count == 2);
    g_assert(a->data[0] == 1);
    g_assert(a->data[1] == 0);

g_assert(gutil_int_array_insert(a, 2, 2) == a);
    g_assert(a->count == 3);
    g_assert(a->data[0] == 1);
    g_assert(a->data[1] == 0);
    g_assert(a->data[2] == 2);

g_assert(gutil_int_array_set_count(a, 2) == a);
    g_assert(a->count == 2);
    g_assert(a->data[0] == 1);
    g_assert(a->data[1] == 0);

g_assert(gutil_int_array_remove_index(a, 0) == a);
    g_assert(a->count == 1);
    g_assert(a->data[0] == 0);

g_assert(gutil_int_array_remove_index(a, 1) == a);
    g_assert(a->count == 1);
    g_assert(a->data[0] == 0);

gutil_int_array_ref(a);
    gutil_int_array_free(a, TRUE);
    g_assert(!a->data);
    g_assert(!a->count);
    gutil_int_array_unref(a);

a = gutil_int_array_sized_new(0);
    g_assert(!gutil_int_array_free(a, FALSE));

a = gutil_int_array_sized_new(0);
    g_assert(!gutil_int_array_free_to_ints(a));

a = gutil_int_array_sized_new(G_N_ELEMENTS(vals));
    g_assert(gutil_int_array_append_vals(a, vals, G_N_ELEMENTS(vals)) == a);
    g_assert(a->count == G_N_ELEMENTS(vals));
    g_assert(!memcmp(a->data, vals, sizeof(vals)));
    ints = gutil_int_array_free_to_ints(a);
    g_assert(gutil_ints_get_count(ints) == G_N_ELEMENTS(vals));
    g_assert(!memcmp(gutil_ints_get_data(ints, NULL), vals, sizeof(vals)));
    gutil_ints_unref(ints);
}

/*==========================================================================*
 * Find
 *==========================================================================*/

static
void
test_intarray_find(
    void)
{
    static const int vals[] = { 0, 1, 2 };
    GUtilIntArray* a = gutil_int_array_new();

g_assert(gutil_int_array_append_vals(a, vals, G_N_ELEMENTS(vals)) == a);
    g_assert(gutil_int_array_find(a, -1) == -1);
    g_assert(gutil_int_array_find(a, 0) == 0);
    g_assert(gutil_int_array_find(a, 1) == 1);
    g_assert(gutil_int_array_find(a, 2) == 2);
    g_assert(gutil_int_array_find(a, 3) == -1);
    g_assert(gutil_int_array_contains(a, 2));
    g_assert(!gutil_int_array_contains(a, 3));
    gutil_int_array_unref(a);
}

/*==========================================================================*
 * Remove
 *==========================================================================*/

static
void
test_intarray_remove_1(
    const int* vals,
    guint n,
    gboolean (*f)(GUtilIntArray* array, int value),
    int value,
    const int* result)
{
    GUtilIntArray* a = gutil_int_array_new_from_vals(vals, n);
    g_assert(f(a, value));
    g_assert(a->count == n - 1);
    g_assert(!memcmp(a->data, result, sizeof(a->data[0]) * a->count));
    gutil_int_array_unref(a);
}

static
void
test_intarray_remove(
    void)
{
    static const int v[] = { 0, 1, 2, 4 };
    static const int v0[] = { 1, 2, 4 };
    static const int v1[] = { 0, 2, 4 };
    static const int v4[] = { 0, 1, 2 };
    static const int v0_fast[] = { 4, 1, 2 };
    static const int v1_fast[] = { 0, 4, 2 };
    const guint n = G_N_ELEMENTS(v);
    GUtilIntArray* a = gutil_int_array_new_from_value(-1);

g_assert(a->count == 1);
    g_assert(!gutil_int_array_remove(a, 0));
    g_assert(!gutil_int_array_remove_fast(a, 0));
    gutil_int_array_unref(a);

test_intarray_remove_1(v, n, gutil_int_array_remove, 0, v0);
    test_intarray_remove_1(v, n, gutil_int_array_remove, 1, v1);
    test_intarray_remove_1(v, n, gutil_int_array_remove, 4, v4);

test_intarray_remove_1(v, n, gutil_int_array_remove_fast, 0, v0_fast);
    test_intarray_remove_1(v, n, gutil_int_array_remove_fast, 1, v1_fast);
    test_intarray_remove_1(v, n, gutil_int_array_remove_fast, 4, v4);
}

/*==========================================================================*
 * RemoveAll
 *==========================================================================*/

static
void
test_intarray_remove_all_1(
    const int* vals,
    guint n,
    guint (*f)(GUtilIntArray* array, int value),
    int value,
    guint removed,
    const int* result)
{
    GUtilIntArray* a = gutil_int_array_new_from_vals(vals, n);
    g_assert(f(a, value) == removed);
    g_assert(a->count == n - removed);
    g_assert(!memcmp(a->data, result, sizeof(a->data[0]) * a->count));
    gutil_int_array_unref(a);
}

static
void
test_intarray_remove_all(
    void)
{
    static const int v[] = { 0, 1, 2, 1, 0 };
    static const int v0[] = { 1, 2, 1 };
    static const int v1[] = { 0, 2, 0 };
    static const int v2[] = { 0, 1, 1, 0 };
    static const int v0f[] = { 1, 1, 2 };
    static const int v1f[] = { 0, 0, 2 };
    static const int v2f[] = { 0, 1, 0, 1 };
    const guint n = G_N_ELEMENTS(v);
    GUtilIntArray* a = gutil_int_array_new_from_value(-1);

g_assert(a->count == 1);
    g_assert(!gutil_int_array_remove_all(a, 0));
    g_assert(!gutil_int_array_remove_all_fast(a, 0));
    gutil_int_array_unref(a);

test_intarray_remove_all_1(v,n,gutil_int_array_remove_all,0,2,v0);
    test_intarray_remove_all_1(v,n,gutil_int_array_remove_all,1,2,v1);
    test_intarray_remove_all_1(v,n,gutil_int_array_remove_all,2,1,v2);

test_intarray_remove_all_1(v,n,gutil_int_array_remove_all_fast,0,2,v0f);
    test_intarray_remove_all_1(v,n,gutil_int_array_remove_all_fast,1,2,v1f);
    test_intarray_remove_all_1(v,n,gutil_int_array_remove_all_fast,2,1,v2f);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_PREFIX "/intarray/"

int main(int argc, char* argv[])
{
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_PREFIX "null", test_intarray_null);
    g_test_add_func(TEST_PREFIX "basic", test_intarray_basic);
    g_test_add_func(TEST_PREFIX "find", test_intarray_find);
    g_test_add_func(TEST_PREFIX "remove", test_intarray_remove);
    g_test_add_func(TEST_PREFIX "remove_all", test_intarray_remove_all);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000004C000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002E00000000libglibutil-1680886706.91f2bff/test/test_ints0707010000004D000081A400000000000000000000000164304BB20000004C000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/test/test_ints/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_ints

include ../common/Makefile
0707010000004E000081A400000000000000000000000164304BB200001E64000000000000000000000000000000000000003A00000000libglibutil-1680886706.91f2bff/test/test_ints/test_ints.c/*
 * Copyright (C) 2017-2022 Jolla Ltd.
 * Copyright (C) 2017-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_ints.h"
#include "gutil_misc.h"

static TestOpt test_opt;

/*==========================================================================*
 * NULL tolerance
 *==========================================================================*/

static
void
test_ints_null(
    void)
{
    int val = 0;
    guint count;
    gutil_ints_unref(NULL);
    g_assert(!gutil_ints_ref(NULL));
    g_assert(!gutil_ints_new(NULL, 0));
    g_assert(!gutil_ints_new(NULL, 1));
    g_assert(!gutil_ints_new(&val, 0));
    g_assert(!gutil_ints_new_take(NULL, 0));
    g_assert(!gutil_ints_new_take(NULL, 1));
    g_assert(!gutil_ints_new_take(&val, 0));
    g_assert(!gutil_ints_new_static(NULL, 0));
    g_assert(!gutil_ints_new_static(NULL, 1));
    g_assert(!gutil_ints_new_static(&val, 0));
    g_assert(!gutil_ints_new_with_free_func(NULL, 0, NULL, NULL));
    g_assert(!gutil_ints_new_with_free_func(NULL, 1, NULL, NULL));
    g_assert(!gutil_ints_new_with_free_func(&val, 0, NULL, NULL));
    g_assert(!gutil_ints_new_from_ints(NULL, 0, 0));
    g_assert(!gutil_ints_hash(NULL));
    g_assert(!gutil_ints_get_count(NULL));
    g_assert(!gutil_ints_contains(NULL, 0));
    g_assert(gutil_ints_find(NULL, 0) < 0);
    count = 1;
    g_assert(!gutil_ints_get_data(NULL, NULL));
    g_assert(!gutil_ints_get_data(NULL, &count));
    g_assert(!count);
    count = 1;
    g_assert(!gutil_ints_unref_to_data(NULL, NULL));
    g_assert(!gutil_ints_unref_to_data(NULL, &count));
    g_assert(!count);
}

/*==========================================================================*
 * Basic
 *==========================================================================*/

static
void
test_custom_free(
    gpointer data)
{
    g_free(data);
}

static
void
test_ints_basic(
    void)
{
    /* First 3 elements match */
    const int a1[] = { 1, 2, 3 };
    const int a2[] = { 1, 2, 3, 4 };
    int* data;
    guint count;
    GUtilInts* i1 = gutil_ints_new(a1, G_N_ELEMENTS(a1));
    GUtilInts* i2 = gutil_ints_new_static(a2, G_N_ELEMENTS(a2));
    GUtilInts* i3;
    GUtilInts* i4;
    g_assert(gutil_ints_get_count(i1) == G_N_ELEMENTS(a1));
    g_assert(gutil_ints_get_count(i2) == G_N_ELEMENTS(a2));
    g_assert(gutil_ints_get_data(i1, NULL) != a2);
    g_assert(gutil_ints_get_data(i2, &count) == a2);
    g_assert(count == G_N_ELEMENTS(a2));
    g_assert(!gutil_ints_new_from_ints(i1, G_N_ELEMENTS(a2), 1));
    i3 = gutil_ints_new_from_ints(i1, 0, G_N_ELEMENTS(a1) + 1);
    i4 = gutil_ints_new_from_ints(i2, 0, G_N_ELEMENTS(a1));

g_assert(gutil_ints_equal(i1, i1));
    g_assert(!gutil_ints_equal(i1, i2));
    g_assert(gutil_ints_equal(i1, i3));
    g_assert(gutil_ints_equal(i1, i3));

g_assert(!gutil_ints_contains(i1, 0));
    g_assert(gutil_ints_contains(i1, 1));

g_assert(gutil_ints_find(i1, 0) < 0);
    g_assert(gutil_ints_find(i1, 1) == 0);
    g_assert(gutil_ints_find(i1, 2) == 1);

/* This gutil_ints_unref_to_data doesn't actually free i1 because
     * a reference to it is held by i3: */
    data = gutil_ints_unref_to_data(i1, &count);
    g_assert(count == G_N_ELEMENTS(a1));
    g_assert(!memcmp(a1, data, count*sizeof(int)));
    g_free(data);

gutil_ints_unref(i2);
    gutil_ints_unref(i3);
    gutil_ints_unref(i4);

/* This gutil_ints_unref_to_data actually does free i1: */
    i1 = gutil_ints_new(a1, G_N_ELEMENTS(a1));
    data = gutil_ints_unref_to_data(i1, NULL);
    g_assert(!memcmp(a1, data, G_N_ELEMENTS(a1)*sizeof(int)));
    g_free(data);

/* And this one duplicates the data because we use test_custom_free: */
    data = gutil_memdup(a1, sizeof(a1));
    i1 = gutil_ints_new_with_free_func(data, G_N_ELEMENTS(a1),
        test_custom_free, data);
    data = gutil_ints_unref_to_data(i1, &count);
    g_assert(count == G_N_ELEMENTS(a1));
    g_assert(!memcmp(a1, data, count*sizeof(int)));
    g_free(data);
}

/*==========================================================================*
 * Compare
 *==========================================================================*/

static
void
test_ints_compare(
    void)
{
    const int a1[] = { 1 };
    const int a2[] = { 1, 2 };
    const int a3[] = { 2 };
    GUtilInts* i1 = gutil_ints_new_static(a1, G_N_ELEMENTS(a1));
    GUtilInts* i2 = gutil_ints_new_static(a2, G_N_ELEMENTS(a2));
    GUtilInts* i3 = gutil_ints_new_static(a3, G_N_ELEMENTS(a3));
    GUtilInts* i4 = gutil_ints_new_from_ints(i1, 0, G_N_ELEMENTS(a1));

g_assert(gutil_ints_hash(i1) == 1235);
    g_assert(gutil_ints_hash(i2) == 1239);

g_assert(gutil_ints_equal(NULL, NULL));
    g_assert(!gutil_ints_equal(NULL, i1));
    g_assert(!gutil_ints_equal(i1, NULL));
    g_assert(!gutil_ints_equal(i1, i2));
    g_assert(!gutil_ints_equal(i2, i1));
    g_assert(!gutil_ints_equal(i1, i3));
    g_assert(!gutil_ints_equal(i3, i1));
    g_assert(gutil_ints_equal(i1, i4));
    g_assert(gutil_ints_equal(i4, i1));

g_assert(gutil_ints_compare(NULL, NULL) == 0);
    g_assert(gutil_ints_compare(NULL, i1) < 0);
    g_assert(gutil_ints_compare(i1, NULL) > 0);
    g_assert(gutil_ints_compare(i1, i2) < 0);
    g_assert(gutil_ints_compare(i2, i1) > 0);
    g_assert(gutil_ints_compare(i1, i3) < 0);
    g_assert(gutil_ints_compare(i3, i1) > 0);
    g_assert(gutil_ints_compare(i1, i4) == 0);
    g_assert(gutil_ints_compare(i4, i1) == 0);

gutil_ints_unref(i1);
    gutil_ints_unref(i2);
    gutil_ints_unref(i3);
    gutil_ints_unref(i4);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_PREFIX "/ints/"

int main(int argc, char* argv[])
{
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_PREFIX "null", test_ints_null);
    g_test_add_func(TEST_PREFIX "basic", test_ints_basic);
    g_test_add_func(TEST_PREFIX "compare", test_ints_compare);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000004F000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002D00000000libglibutil-1680886706.91f2bff/test/test_log07070100000050000081A400000000000000000000000164304BB20000009F000000000000000000000000000000000000003600000000libglibutil-1680886706.91f2bff/test/test_log/Makefile# -*- Mode: makefile-gmake -*-

CFLAGS += -DGLOG_LEVEL_MAX=GLOG_LEVEL_VERBOSE -DGLOG_LEVEL_ASSERT=GLOG_LEVEL_ALWAYS
EXE = test_log

include ../common/Makefile
07070100000051000081A400000000000000000000000164304BB200003164000000000000000000000000000000000000003800000000libglibutil-1680886706.91f2bff/test/test_log/test_log.c/*
 * Copyright (C) 2017-2022 Jolla Ltd.
 * Copyright (C) 2017-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#define _GNU_SOURCE /* for fopencookie */

#include "test_common.h"

#include "gutil_strv.h"
#include "gutil_log.h"

#ifdef __GLIBC__
/* glibc has writeable stdout */
#  define HAVE_TEST_LOG_FILE
#endif

static TestOpt test_opt;
static GString* test_log_buf;

static
void
test_log_fn(
    const char* name,
    int level,
    const char* format,
    va_list va)
{
    g_string_append_vprintf(test_log_buf, format, va);
    g_string_append_c(test_log_buf, '\n');
}

/*==========================================================================*
 * Basic
 *==========================================================================*/

static
void
test_log_basic(
    void)
{
    const GLogProc fn = gutil_log_func;
    const GLogProc2 fn2 = gutil_log_func2;
    const int level = gutil_log_default.level;
    GLOG_MODULE_DEFINE2_(module, "test", gutil_log_default);
    test_log_buf = g_string_new(NULL);
    gutil_log_func = test_log_fn;

module.level = GLOG_LEVEL_INHERIT;
    gutil_log_default.level = GLOG_LEVEL_ERR;
    gutil_log(NULL, GLOG_LEVEL_NONE, "Debug!");
    gutil_log(NULL, GLOG_LEVEL_DEBUG, "Debug!");
    gutil_log(&module, GLOG_LEVEL_DEBUG, "Debug!");
    gutil_log_assert(NULL, GLOG_LEVEL_WARN, "Test!", __FILE__, __LINE__);
    g_assert(!test_log_buf->len);
    gutil_log(&module, GLOG_LEVEL_ERR, "Err!");
    g_assert(test_log_buf->len);
    g_string_set_size(test_log_buf, 0);

/* With NULL parent, still gutil_log_default is going to be checked */
    module.parent = NULL;
    gutil_log(NULL, GLOG_LEVEL_NONE, "Debug!");
    gutil_log(NULL, GLOG_LEVEL_DEBUG, "Debug!");
    gutil_log(&module, GLOG_LEVEL_DEBUG, "Debug!");
    gutil_log_assert(NULL, GLOG_LEVEL_WARN, "Test!", __FILE__, __LINE__);
    g_assert(!test_log_buf->len);
    gutil_log(&module, GLOG_LEVEL_ERR, "Err!");
    g_assert(test_log_buf->len);
    g_string_set_size(test_log_buf, 0);

gutil_log(&module, GLOG_LEVEL_ALWAYS, "Always!");
    g_assert(test_log_buf->len);
    g_string_set_size(test_log_buf, 0);

/* Test GLOG_FLAG_DISABLE */
    module.flags |= GLOG_FLAG_DISABLE;
    gutil_log(&module, GLOG_LEVEL_ALWAYS, "Always!");
    g_assert(!test_log_buf->len);
    module.flags &= ~GLOG_FLAG_DISABLE;

/* Without log functions these calls have no effect */
    gutil_log_func = NULL;
    gutil_log(NULL, GLOG_LEVEL_ALWAYS, "Always!");
    gutil_log_func2 = NULL;
    gutil_log(NULL, GLOG_LEVEL_ALWAYS, "Always!");

g_string_free(test_log_buf, TRUE);
    test_log_buf = NULL;
    gutil_log_default.level = level;
    gutil_log_func = fn;
    gutil_log_func2 = fn2;
}

/*==========================================================================*
 * File
 *==========================================================================*/

#ifdef HAVE_TEST_LOG_FILE

static
ssize_t
test_log_file_write(
    void* buf,
    const char* chars,
    size_t size)
{
    g_string_append_len(buf, chars, size);
    return size;
}

static
void
test_log_drop(
    const GLogModule* module,
    int level,
    const char* format,
    va_list va)
{
}

static
void
test_log_file(
    void)
{
    static const cookie_io_functions_t funcs = {
        .write = test_log_file_write
    };
    GString* buf = g_string_new(NULL);
    FILE* out = fopencookie(buf, "w", funcs);
    FILE* default_stdout = stdout;
    const int level = gutil_log_default.level;
    GLogProc2 log_proc;

g_assert(out);
    g_assert(gutil_log_set_type(GLOG_TYPE_STDOUT, NULL));
    g_assert(gutil_log_func == gutil_log_stdout);
    gutil_log_timestamp = FALSE;
    gutil_log_default.level = GLOG_LEVEL_WARN;

/* Warning pefix */
    stdout = out;
    gutil_log(NULL, GLOG_LEVEL_WARN, "Test");
    stdout = default_stdout;
    g_assert(fflush(out) == 0);
    GDEBUG("%s", buf->str);
    g_assert_cmpstr(buf->str, == ,"WARNING: Test\n");
    g_string_set_size(buf, 0);

/* Error prefix */
    stdout = out;
    gutil_log(NULL, GLOG_LEVEL_ERR, "Test");
    stdout = default_stdout;
    g_assert(fflush(out) == 0);
    GDEBUG("%s", buf->str);
    g_assert_cmpstr(buf->str, == ,"ERROR: Test\n");
    g_string_set_size(buf, 0);

/* Empty name (dropped) */
    gutil_log_default.name = "";
    stdout = out;
    gutil_log(NULL, GLOG_LEVEL_ALWAYS, "Test");
    stdout = default_stdout;
    g_assert(fflush(out) == 0);
    GDEBUG("%s", buf->str);
    g_assert_cmpstr(buf->str, == ,"Test\n");
    g_string_set_size(buf, 0);

/* Non-empty name */
    gutil_log_default.name = "test";
    stdout = out;
    gutil_log(NULL, GLOG_LEVEL_ALWAYS, "Test");
    stdout = default_stdout;
    g_assert(fflush(out) == 0);
    GDEBUG("%s", buf->str);
    g_assert_cmpstr(buf->str, == ,"[test] Test\n");
    g_string_set_size(buf, 0);

/* Hide the name */
    gutil_log_default.flags |= GLOG_FLAG_HIDE_NAME;
    stdout = out;
    gutil_log(NULL, GLOG_LEVEL_ALWAYS, "Test");
    stdout = default_stdout;
    g_assert(fflush(out) == 0);
    GDEBUG("%s", buf->str);
    g_assert_cmpstr(buf->str, == ,"Test\n");
    g_string_set_size(buf, 0);

/* Forward output to test_log_drop */
    log_proc = gutil_log_default.log_proc;
    gutil_log_default.log_proc = test_log_drop;
    gutil_log(&gutil_log_default, GLOG_LEVEL_ALWAYS, "Test");
    g_assert(!buf->len);  /* Dropped by test_log_drop */
    gutil_log_default.log_proc = log_proc;

fclose(out);
    gutil_log_default.level = level;
    g_string_free(buf, TRUE);
}

#endif /* HAVE_TEST_LOG_FILE */

/*==========================================================================*
 * Enabled
 *==========================================================================*/

static
void
test_log_enabled(
    void)
{
    const GLogProc2 fn = gutil_log_func2;
    const int level = gutil_log_default.level;
    GLOG_MODULE_DEFINE2_(module, "test", gutil_log_default);

gutil_log_default.level = GLOG_LEVEL_NONE;
    g_assert(gutil_log_enabled(NULL, GLOG_LEVEL_ALWAYS));
    g_assert(!gutil_log_enabled(NULL, GLOG_LEVEL_ERR));
    g_assert(!gutil_log_enabled(NULL, GLOG_LEVEL_NONE));

gutil_log_default.level = GLOG_LEVEL_INFO;
    g_assert(gutil_log_enabled(&gutil_log_default, GLOG_LEVEL_ALWAYS));
    g_assert(gutil_log_enabled(&gutil_log_default, GLOG_LEVEL_INFO));
    gutil_log_default.flags |= GLOG_FLAG_DISABLE;
    g_assert(!gutil_log_enabled(&gutil_log_default, GLOG_LEVEL_INFO));
    gutil_log_default.flags &= ~GLOG_FLAG_DISABLE;
    g_assert(!gutil_log_enabled(&gutil_log_default, GLOG_LEVEL_DEBUG));

/* It makes no sense to have default as INHERIT so it's treated as NONE */
    gutil_log_default.level = GLOG_LEVEL_INHERIT;
    g_assert(!gutil_log_enabled(&module, GLOG_LEVEL_ERR));
    g_assert(gutil_log_enabled(&module, GLOG_LEVEL_ALWAYS));

/* Test parenting */
    module.level = GLOG_LEVEL_INHERIT;
    gutil_log_default.level = GLOG_LEVEL_INFO;
    g_assert(gutil_log_enabled(&module, GLOG_LEVEL_ALWAYS));
    g_assert(gutil_log_enabled(&module, GLOG_LEVEL_INFO));
    g_assert(!gutil_log_enabled(&module, GLOG_LEVEL_DEBUG));

/* No handler = no logging */
    gutil_log_func2 = NULL;
    gutil_log_default.level = GLOG_LEVEL_VERBOSE;
    g_assert(!gutil_log_enabled(NULL, GLOG_LEVEL_ALWAYS));

gutil_log_default.level = level;
    gutil_log_func2 = fn;
}

/*==========================================================================*
 * Misc
 *==========================================================================*/

static
void
test_log_misc(
    void)
{
    const GLogProc fn = gutil_log_func;
    g_assert(gutil_log_set_type(GLOG_TYPE_STDOUT, "test"));
    g_assert(gutil_log_func == gutil_log_stdout);
    g_assert_cmpstr(gutil_log_get_type(), == ,GLOG_TYPE_STDOUT);
    g_assert(gutil_log_set_type(GLOG_TYPE_STDERR, "test"));
    g_assert(gutil_log_func == gutil_log_stderr);
    g_assert_cmpstr(gutil_log_get_type(), == ,GLOG_TYPE_STDERR);
    g_assert(!gutil_log_set_type("whatever", "test"));
    gutil_log_func = NULL;
    g_assert_cmpstr(gutil_log_get_type(), == ,GLOG_TYPE_CUSTOM);
    gutil_log_func = fn;
}

/*==========================================================================*
 * Dump
 *==========================================================================*/

static
void
test_log_dump(
    void)
{
    static const guint8 short_data[] = { 0x01, 0x02, 0x03, 0x04 };
    static const char short_data_dump[] =
        "  0000: 01 02 03 04                                         ....\n";
    static const guint8 long_data[] = {
        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
        0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
        0x00
    };
    static const char long_data_dump[] =
        "0000: 30 31 32 33 34 35 36 37  38 39 3a 3b 3c 3d 3e 3f    "
        "01234567 89:;<=>?\n"
        "0010: 00                                                  "
        ".\n";

const GLogProc fn = gutil_log_func;
    const GLogModule* log = &gutil_log_default;
    GBytes* bytes;

test_log_buf = g_string_new(NULL);
    gutil_log_func = test_log_fn;

gutil_log_dump_bytes(log, GLOG_LEVEL_NONE, "  ", NULL);
    gutil_log_dump(log,GLOG_LEVEL_NONE,"  ",TEST_ARRAY_AND_SIZE(short_data));
    g_assert_cmpuint(test_log_buf->len, == ,0);

gutil_log_dump(log,GLOG_LEVEL_ALWAYS,"  ",TEST_ARRAY_AND_SIZE(short_data));
    g_assert_cmpstr(test_log_buf->str, == ,short_data_dump);

g_string_set_size(test_log_buf, 0);
    bytes = g_bytes_new_static(TEST_ARRAY_AND_SIZE(short_data));
    gutil_log_dump_bytes(log, GLOG_LEVEL_NONE, "  ", bytes);
    g_assert_cmpuint(test_log_buf->len, == ,0);
    gutil_log_dump_bytes(log, GLOG_LEVEL_ALWAYS, "  ", bytes);
    g_assert_cmpstr(test_log_buf->str, == ,short_data_dump);
    g_bytes_unref(bytes);

g_string_set_size(test_log_buf, 0);
    gutil_log_dump(log,GLOG_LEVEL_ALWAYS,NULL,TEST_ARRAY_AND_SIZE(long_data));
    g_assert_cmpstr(test_log_buf->str, == ,long_data_dump);

g_string_set_size(test_log_buf, 0);
    bytes = g_bytes_new_static(TEST_ARRAY_AND_SIZE(long_data));
    gutil_log_dump_bytes(log, GLOG_LEVEL_ALWAYS, NULL, bytes);
    g_assert_cmpstr(test_log_buf->str, == ,long_data_dump);
    g_bytes_unref(bytes);

g_string_free(test_log_buf, TRUE);
    test_log_buf = NULL;
    gutil_log_func = fn;
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_PREFIX "/log/"

int main(int argc, char* argv[])
{
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_PREFIX "basic", test_log_basic);
#ifdef HAVE_TEST_LOG_FILE
    g_test_add_func(TEST_PREFIX "file", test_log_file);
#endif
    g_test_add_func(TEST_PREFIX "enabled", test_log_enabled);
    g_test_add_func(TEST_PREFIX "misc", test_log_misc);
    g_test_add_func(TEST_PREFIX "dump", test_log_dump);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000052000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002E00000000libglibutil-1680886706.91f2bff/test/test_misc07070100000053000081A400000000000000000000000164304BB20000004C000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/test/test_misc/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_misc

include ../common/Makefile
07070100000054000081A400000000000000000000000164304BB2000077EF000000000000000000000000000000000000003A00000000libglibutil-1680886706.91f2bff/test/test_misc/test_misc.c/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 * Copyright (C) 2016-2022 Jolla Ltd.
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_misc.h"
#include "gutil_idlepool.h"
#include "gutil_log.h"
#include "gutil_version.h"

static TestOpt test_opt;

/*==========================================================================*
 * version
 *==========================================================================*/

static
void
test_version(
    void)
{
    g_assert_cmpuint(gutil_version(), == ,GUTIL_VERSION);
}

/*==========================================================================*
 * disconnect
 *==========================================================================*/

static
void
test_notify(
    GObject* object,
    GParamSpec* spec,
    gpointer data)
{
}

static
void
test_disconnect(
    void)
{
    gulong id[2];
    GObject* obj = g_object_new(TEST_OBJECT_TYPE, NULL);

/* These have no effect */
    gutil_disconnect_handlers(NULL, id, G_N_ELEMENTS(id));
    gutil_disconnect_handlers(obj, NULL, 0);

id[0] = g_signal_connect(obj, "notify", G_CALLBACK(test_notify), NULL);
    id[1] = g_signal_connect(obj, "notify", G_CALLBACK(test_notify), NULL);
    GASSERT(id[0] && id[1]);

/* gutil_disconnect_handlers zeros the ids */
    gutil_disconnect_handlers(obj, id, G_N_ELEMENTS(id));
    g_assert(!id[0]);
    g_assert(!id[1]);

/* Second time has no effect */
    gutil_disconnect_handlers(obj, id, G_N_ELEMENTS(id));
    g_assert(!id[0]);
    g_assert(!id[1]);

g_object_unref(obj);
}

/*==========================================================================*
 * hex2bin
 *==========================================================================*/

static
void
test_hex2bin(
    void)
{
    guint8 buf[4];
    GBytes* bytes;
    gsize size;
    const void* data;
    static const guint8 buf1[4] = { 0x01, 0x23, 0x45, 0x67 };
    static const guint8 buf2[4] = { 0x89, 0xab, 0xcd, 0xef };

g_assert(!gutil_hex2bin(NULL, 0, NULL));
    g_assert(!gutil_hex2bin("x", 0, NULL));
    g_assert(!gutil_hex2bin("x", 0, buf));
    g_assert(!gutil_hex2bin("x", -1, buf));
    g_assert(!gutil_hex2bin("x", 1, buf));
    g_assert(!gutil_hex2bin("xy", 2, buf));
    g_assert(!gutil_hex2bin(" 1", 2, buf));
    g_assert(!gutil_hex2bin("1 ", 2, buf));
    g_assert(!gutil_hex2bin("1234FG", 6, buf));
    g_assert(gutil_hex2bin("01234567", 8, buf));
    g_assert(!memcmp(buf, buf1, sizeof(buf)));
    g_assert(gutil_hex2bin("89abcdef", 8, buf));
    g_assert(!memcmp(buf, buf2, sizeof(buf)));
    g_assert(gutil_hex2bin("89ABCDEF", 8, buf));
    g_assert(!memcmp(buf, buf2, sizeof(buf)));

g_assert(!gutil_hex2bytes(NULL, 0));
    g_assert(!gutil_hex2bytes("x", 0));
    g_assert(!gutil_hex2bytes("x", 1));
    g_assert(!gutil_hex2bytes("x", -1));
    g_assert(!gutil_hex2bytes("xy", -1));
    bytes = gutil_hex2bytes("01234567", -1);
    g_assert(bytes);
    data = g_bytes_get_data(bytes, &size);
    g_assert(data);
    g_assert(size == 4);
    g_assert(!memcmp(data, buf1, sizeof(buf1)));
    g_bytes_unref(bytes);
}

/*==========================================================================*
 * hexdump
 *==========================================================================*/

static
void
test_hexdump(
    void)
{
    char buf[GUTIL_HEXDUMP_BUFSIZE];
    static const guchar data[] = {
        0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
        0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x00
    };

g_assert(gutil_hexdump(buf, data, sizeof(data)) == GUTIL_HEXDUMP_MAXBYTES);
    g_assert(strlen(buf) == GUTIL_HEXDUMP_BUFSIZE - 1);
    GDEBUG("%s", buf);
    g_assert(!strcmp(buf,
        "30 31 32 33 34 35 36 37  "
        "38 39 3a 3b 3c 3d 3e 3f    "
        "01234567 89:;<=>?"));

g_assert(gutil_hexdump(buf, data + GUTIL_HEXDUMP_MAXBYTES, 1) == 1);
    g_assert(strlen(buf) == 53);
    GDEBUG("%s", buf);
    g_assert(!strcmp(buf,
        "00                       "
        "                           "
        "."));
}

/*==========================================================================*
 * parse_int
 *==========================================================================*/

static
void
test_parse_int(
    void)
{
    int value;

g_assert(!gutil_parse_int(NULL, 0, NULL));
    g_assert(!gutil_parse_int("", 0, NULL));
    g_assert(!gutil_parse_int("garbage", 0, NULL));
    g_assert(!gutil_parse_int("0 trailing garbage", 0, NULL));
    g_assert(!gutil_parse_int("0", -1, NULL));
    g_assert(!gutil_parse_int("0", 1, NULL));
    g_assert(gutil_parse_int("0", 0, NULL));
    g_assert(gutil_parse_int("0", 0, &value));
    g_assert_cmpint(value, == ,0);
    g_assert(gutil_parse_int("-1", 0, &value));
    g_assert_cmpint(value, == ,-1);
    g_assert(gutil_parse_int("42", 0, &value));
    g_assert_cmpint(value, == ,42);
    g_assert(!gutil_parse_int("0x10000000000000000", 0, &value));
    g_assert(!gutil_parse_int("-2147483649", 0, &value));
    g_assert(!gutil_parse_int("4294967295", 0, &value));
    g_assert(gutil_parse_int(" 0x7fffffff ", 0, &value));
    g_assert_cmpint(value, == ,0x7fffffff);
    g_assert(gutil_parse_int(" 7fffffff ", 16, &value));
    g_assert_cmpint(value, == ,0x7fffffff);
    g_assert(gutil_parse_int("7ffffffe ", 16, &value));
    g_assert_cmpint(value, == ,0x7ffffffe);
    g_assert(!gutil_parse_int("0xffffffff", 0, &value));
}

/*==========================================================================*
 * parse_uint
 *==========================================================================*/

static
void
test_parse_uint(
    void)
{
    unsigned int value;

g_assert(!gutil_parse_uint(NULL, 0, NULL));
    g_assert(!gutil_parse_uint("", 0, NULL));
    g_assert(!gutil_parse_uint("garbage", 0, NULL));
    g_assert(!gutil_parse_uint("0 trailing garbage", 0, NULL));
    g_assert(!gutil_parse_uint("0", -1, NULL));
    g_assert(!gutil_parse_uint("0", 1, NULL));
    g_assert(gutil_parse_uint("0", 0, NULL));
    g_assert(gutil_parse_uint("0", 0, &value));
    g_assert_cmpuint(value, == ,0);
    g_assert(gutil_parse_uint("42", 0, &value));
    g_assert_cmpuint(value, == ,42);
    g_assert(!gutil_parse_uint("0x10000000000000000", 0, &value));
#if defined __SIZEOF_INT__ && __SIZEOF_INT__ == 4
    g_assert(!gutil_parse_uint("0x100000000", 0, &value));
#endif
    g_assert(!gutil_parse_uint("-2147483649", 0, &value));
    g_assert(!gutil_parse_uint("-1", 0, &value));
    g_assert(!gutil_parse_uint(" -1 ", 0, &value));
    g_assert(gutil_parse_uint("4294967295", 0, &value));
    g_assert_cmpuint(value, == ,4294967295U);
    g_assert(gutil_parse_uint(" 0x7fffffff ", 0, &value));
    g_assert_cmpuint(value, == ,0x7fffffff);
    g_assert(gutil_parse_uint(" 7fffffff ", 16, &value));
    g_assert_cmpuint(value, == ,0x7fffffff);
    g_assert(gutil_parse_uint("7ffffffe ", 16, &value));
    g_assert_cmpuint(value, == ,0x7ffffffe);
    g_assert(gutil_parse_uint("0xffffffff", 0, &value));
    g_assert_cmpuint(value, == ,0xffffffff);
}

/*==========================================================================*
 * parse_int64
 *==========================================================================*/

static
void
test_parse_int64(
    void)
{
    gint64 value;

g_assert(!gutil_parse_int64(NULL, 0, NULL));
    g_assert(!gutil_parse_int64("", 0, NULL));
    g_assert(!gutil_parse_int64("garbage", 0, NULL));
    g_assert(!gutil_parse_int64("0 trailing garbage", 0, NULL));
    g_assert(!gutil_parse_int64("0", -1, NULL));
    g_assert(!gutil_parse_int64("0", 1, NULL));
    g_assert(gutil_parse_int64("0", 0, NULL));
    g_assert(gutil_parse_int64("0", 0, &value));
    g_assert_cmpint(value, == ,0);
    g_assert(gutil_parse_int64("-1", 0, &value));
    g_assert_cmpint(value, == ,-1);
    g_assert(gutil_parse_int64("42", 0, &value));
    g_assert_cmpint(value, == ,42);
    g_assert(gutil_parse_int64("-2147483649", 0, &value));
    g_assert_cmpint(value, == ,G_GINT64_CONSTANT(-2147483649));
    g_assert(gutil_parse_int64("4294967295", 0, &value));
    g_assert_cmpint(value, == ,G_GINT64_CONSTANT(4294967295));
    g_assert(gutil_parse_int64(" 0x7fffffff ", 0, &value));
    g_assert_cmpint(value, == ,0x7fffffff);
    g_assert(gutil_parse_int64(" 7fffffff ", 16, &value));
    g_assert_cmpint(value, == ,0x7fffffff);
    g_assert(gutil_parse_int64("7ffffffe ", 16, &value));
    g_assert_cmpint(value, == ,0x7ffffffe);
    g_assert(gutil_parse_int64("0xffffffff", 0, &value));
    g_assert_cmpint(value, == ,0xffffffff);
    g_assert(gutil_parse_int64("-9223372036854775808", 0, &value));
    g_assert_cmpint(value, == ,0x8000000000000000);
    g_assert(gutil_parse_int64("9223372036854775807", 0, &value));
    g_assert_cmpint(value, == ,0x7fffffffffffffff);
#ifndef _WIN32
    g_assert(!gutil_parse_int64("0x10000000000000000", 0, &value));
    g_assert(!gutil_parse_int64("-9223372036854775809", 0, &value));
    g_assert(!gutil_parse_int64("9223372036854775808", 0, &value));
#endif
}

/*==========================================================================*
 * parse_uint64
 *==========================================================================*/

static
void
test_parse_uint64(
    void)
{
    guint64 value;

g_assert(!gutil_parse_uint64(NULL, 0, NULL));
    g_assert(!gutil_parse_uint64("", 0, NULL));
    g_assert(!gutil_parse_uint64("garbage", 0, NULL));
    g_assert(!gutil_parse_uint64("0 trailing garbage", 0, NULL));
    g_assert(!gutil_parse_uint64("0", -1, NULL));
    g_assert(!gutil_parse_uint64("0", 1, NULL));
    g_assert(gutil_parse_uint64("0", 0, NULL));
    g_assert(gutil_parse_uint64("0", 0, &value));
    g_assert_cmpuint(value, == ,0);
    g_assert(gutil_parse_uint64("42", 0, &value));
    g_assert_cmpuint(value, == ,42);
    g_assert(!gutil_parse_uint64("-2147483649", 0, &value));
    g_assert(!gutil_parse_uint64("-1", 0, &value));
    g_assert(!gutil_parse_uint64(" -1 ", 0, &value));
    g_assert(gutil_parse_uint64("4294967295", 0, &value));
    g_assert_cmpuint(value, == ,4294967295U);
    g_assert(!gutil_parse_uint64(" 0x7fffffff ffffffff ", 0, &value));
    g_assert(gutil_parse_uint64(" 0x7fffffffffffffff ", 0, &value));
    g_assert_cmpuint(value, == ,0x7fffffffffffffff);
    g_assert(!gutil_parse_uint64(" 7fffffff ffffffff", 16, &value));
    g_assert(gutil_parse_uint64(" 7fffffffffffffff ", 16, &value));
    g_assert_cmpuint(value, == ,0x7fffffffffffffff);
    g_assert(gutil_parse_uint64("0x100000000", 0, &value));
    g_assert_cmpuint(value, == ,0x100000000);
    g_assert(gutil_parse_uint64("0xffffffffffffffff", 0, &value));
    g_assert_cmpuint(value, == ,0xffffffffffffffff);
#ifndef _WIN32
    g_assert(!gutil_parse_uint64("0x10000000000000000", 0, &value));
#endif
}

/*==========================================================================*
 * data_equal
 *==========================================================================*/

static
void
test_data_equal(
    void)
{
    static const guint8 val_123[] = { '1', '2', '3' };
    static const guint8 val_1234[] = { '1', '2', '3', '4' };
    static const guint8 val_321[] = { '3', '2', '1' };

GUtilData data_123, data_123a, data_1234, data_321;

TEST_INIT_DATA(data_123, val_123);
    TEST_INIT_DATA(data_123a, val_123);
    TEST_INIT_DATA(data_1234, val_1234);
    TEST_INIT_DATA(data_321, val_321);

g_assert(gutil_data_equal(NULL, NULL));
    g_assert(gutil_data_equal(&data_123, &data_123));
    g_assert(gutil_data_equal(&data_123, &data_123a));
    g_assert(!gutil_data_equal(&data_123, &data_1234));
    g_assert(!gutil_data_equal(&data_123, &data_321));
    g_assert(!gutil_data_equal(&data_123, NULL));
    g_assert(!gutil_data_equal(NULL, &data_123));
}

/*==========================================================================*
 * data_prefix
 *==========================================================================*/

static
void
test_data_prefix(
    void)
{
    static const guint8 val_123[] = { '1', '2', '3' };
    static const guint8 val_1234[] = { '1', '2', '3', '4' };
    static const guint8 val_234[] = { '2', '3', '4' };

GUtilData data_empty, data_123, data_1234, data_234;

memset(&data_empty, 0, sizeof(data_empty));
    TEST_INIT_DATA(data_123, val_123);
    TEST_INIT_DATA(data_1234, val_1234);
    TEST_INIT_DATA(data_234, val_234);

g_assert(gutil_data_has_prefix(NULL, NULL));
    g_assert(!gutil_data_has_prefix(&data_empty, NULL));
    g_assert(!gutil_data_has_prefix(NULL, &data_empty));
    g_assert(gutil_data_has_prefix(&data_empty, &data_empty));
    g_assert(gutil_data_has_prefix(&data_123, &data_empty));
    g_assert(gutil_data_has_prefix(&data_1234, &data_123));
    g_assert(!gutil_data_has_prefix(&data_123, &data_1234));
    g_assert(!gutil_data_has_prefix(&data_1234, &data_234));
}

/*==========================================================================*
 * data_suffix
 *==========================================================================*/

static
void
test_data_suffix(
    void)
{
    static const guint8 val_123[] = { '1', '2', '3' };
    static const guint8 val_1234[] = { '1', '2', '3', '4' };
    static const guint8 val_234[] = { '2', '3', '4' };

GUtilData data_empty, data_123, data_1234, data_234;

memset(&data_empty, 0, sizeof(data_empty));
    TEST_INIT_DATA(data_123, val_123);
    TEST_INIT_DATA(data_1234, val_1234);
    TEST_INIT_DATA(data_234, val_234);

g_assert(gutil_data_has_suffix(NULL, NULL));
    g_assert(!gutil_data_has_suffix(&data_empty, NULL));
    g_assert(!gutil_data_has_suffix(NULL, &data_empty));
    g_assert(gutil_data_has_suffix(&data_empty, &data_empty));
    g_assert(gutil_data_has_suffix(&data_123, &data_empty));
    g_assert(gutil_data_has_suffix(&data_1234, &data_234));
    g_assert(!gutil_data_has_suffix(&data_234, &data_1234));
    g_assert(!gutil_data_has_suffix(&data_1234, &data_123));
}

/*==========================================================================*
 * data_from_bytes
 *==========================================================================*/

static
void
test_data_from_bytes(
    void)
{
    static const guint8 val_123[] = { '1', '2', '3' };
    GBytes* bytes_123 = g_bytes_new_static(val_123, sizeof(val_123));
    GUtilData data_123, data;

TEST_INIT_DATA(data_123, val_123);
    TEST_INIT_DATA(data, val_123);

g_assert(!gutil_data_from_bytes(NULL, NULL));

g_assert(gutil_data_from_bytes(&data, NULL) == &data);
    g_assert(!data.bytes);
    g_assert(!data.size);

g_assert(gutil_data_from_bytes(&data, bytes_123) == &data);
    g_assert(gutil_data_equal(&data_123, &data));
    g_bytes_unref(bytes_123);
}

/*==========================================================================*
 * data_from_string
 *==========================================================================*/

static
void
test_data_from_string(
    void)
{
    static const guint8 val_123[] = { '1', '2', '3' };
    GUtilData data_123, data;

TEST_INIT_DATA(data_123, val_123);
    TEST_INIT_DATA(data, val_123);

g_assert(!gutil_data_from_string(NULL, NULL));

g_assert(gutil_data_from_string(&data, NULL) == &data);
    g_assert(!data.bytes);
    g_assert(!data.size);

g_assert(gutil_data_from_string(&data, "123") == &data);
    g_assert(gutil_data_equal(&data_123, &data));
}

/*==========================================================================*
 * bytes_concat
 *==========================================================================*/

static
void
test_bytes_concat(
    void)
{
    static const guint8 val1[] = {0x01,0x02,0x03,0x04,0x05};
    static const guint8 val2[] = {0x06,0x07,0x08,0x09};
    static const guint8 val3[] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09};
    GBytes* b1 = g_bytes_new_static(val1, sizeof(val1));
    GBytes* b2 = g_bytes_new_static(val2, sizeof(val2));
    GBytes* b3 = g_bytes_new_static(val3, sizeof(val3));
    GBytes* empty = g_bytes_new(NULL, 0);
    GBytes* b;

g_assert(!gutil_bytes_concat(NULL, NULL));

b = gutil_bytes_concat(b1, NULL);
    g_assert(b == b1);
    g_bytes_unref(b);

b = gutil_bytes_concat(empty, NULL);
    g_assert(b == empty);
    g_bytes_unref(b);

b = gutil_bytes_concat(b1, empty, NULL);
    g_assert(b == b1);
    g_bytes_unref(b);

b = gutil_bytes_concat(empty, b1, NULL);
    g_assert(b == b1);
    g_bytes_unref(b);

b = gutil_bytes_concat(b1, empty, b2, NULL);
    g_assert(g_bytes_equal(b, b3));
    g_bytes_unref(b);

g_bytes_unref(b1);
    g_bytes_unref(b2);
    g_bytes_unref(b3);
    g_bytes_unref(empty);
}

/*==========================================================================*
 * bytes_xor
 *==========================================================================*/

static
void
test_bytes_xor(
    void)
{
    static const guint8 val1[] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09};
    static const guint8 val2[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08};
    static const guint8 val3[] = {0x01,0x03,0x01,0x07,0x01,0x03,0x01,0x0F,0x01};
    static const guint8 val4[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
    static const guint8 val5[] = {0x05,0x06,0x07,0x08};
    static const guint8 val6[] = {0x04,0x04,0x04,0x0C};
    GBytes* b1 = g_bytes_new_static(val1, sizeof(val1));
    GBytes* b2 = g_bytes_new_static(val2, sizeof(val2));
    GBytes* b3 = g_bytes_new_static(val3, sizeof(val3));
    GBytes* b4 = g_bytes_new_static(val4, sizeof(val4));
    GBytes* b5 = g_bytes_new_static(val5, sizeof(val5));
    GBytes* b6 = g_bytes_new_static(val6, sizeof(val6));
    GBytes* empty = g_bytes_new(NULL, 0);
    GBytes* b;

g_assert(!gutil_bytes_xor(b1, NULL));
    g_assert(!gutil_bytes_xor(NULL, b1));
    g_assert(!gutil_bytes_xor(NULL, NULL));

b = gutil_bytes_xor(empty, b1);
    g_assert(b == empty);
    g_bytes_unref(b);

b = gutil_bytes_xor(b1, empty);
    g_assert(b == empty);
    g_bytes_unref(b);

b = gutil_bytes_xor(b1, b1);    /* 010203040506070809^010203040506070809 */
    g_assert(g_bytes_equal(b, b4));                   /* =000000000000000000 */
    g_bytes_unref(b);

b = gutil_bytes_xor(b1, b2);    /* 010203040506070809^000102030405060708 */
    g_assert(g_bytes_equal(b, b3));                   /* =010301070103010F01 */
    g_bytes_unref(b);

b = gutil_bytes_xor(b1, b5);    /* 010203040506070809^05060708 */
    g_assert(g_bytes_equal(b, b6));                   /* =0404040C */
    g_bytes_unref(b);

g_bytes_unref(b1);
    g_bytes_unref(b2);
    g_bytes_unref(b3);
    g_bytes_unref(b4);
    g_bytes_unref(b5);
    g_bytes_unref(b6);
    g_bytes_unref(empty);
}

/*==========================================================================*
 * bytes_equal
 *==========================================================================*/

static
void
test_bytes_equal(
    void)
{
    static const guint8 data1[] =  { 0x01 };
    static const guint8 data11[] =  { 0x01, 0x01 };
    static const guint8 data2[] =  { 0x02 };
    GUtilData data;
    GBytes* bytes = g_bytes_new(NULL, 0);

memset(&data, 0, sizeof(data));
    g_assert(gutil_bytes_equal(NULL, NULL, 0));
    g_assert(gutil_bytes_equal_data(NULL, NULL));

/* One of the arguments is not NULL => not equal */
    g_assert(!gutil_bytes_equal(NULL, &data, 0));
    g_assert(!gutil_bytes_equal(bytes, NULL, 0));
    g_assert(!gutil_bytes_equal_data(bytes, NULL));
    g_assert(!gutil_bytes_equal_data(NULL, &data));

/* Empty blocks of data are equal */
    g_assert(gutil_bytes_equal(bytes, &data, 0));
    g_assert(gutil_bytes_equal_data(bytes, &data));

/* Different sizes */
    data.bytes = data11;
    data.size = sizeof(data11);
    g_assert(!gutil_bytes_equal(bytes, data.bytes, data.size));
    g_assert(!gutil_bytes_equal_data(bytes, &data));

g_bytes_unref(bytes);
    bytes = g_bytes_new_static(data1, sizeof(data1));
    g_assert(!gutil_bytes_equal(bytes, data.bytes, data.size));
    g_assert(!gutil_bytes_equal_data(bytes, &data));

/* Different contents */
    data.bytes = data2;
    data.size = sizeof(data2);
    g_assert(!gutil_bytes_equal(bytes, data.bytes, data.size));
    g_assert(!gutil_bytes_equal_data(bytes, &data));

/* Match */
    data.bytes = data1;
    data.size = sizeof(data1);
    g_assert(gutil_bytes_equal(bytes, data.bytes, data.size));
    g_assert(gutil_bytes_equal_data(bytes, &data));
    g_bytes_unref(bytes);
}

/*==========================================================================*
 * ptrv_length
 *==========================================================================*/

static
void
test_ptrv_length(
    void)
{
    static const gconstpointer ptrv0[] = { NULL };
    static const gconstpointer ptrv1[] = { ptrv0, NULL };

g_assert_cmpuint(gutil_ptrv_length(NULL), == ,0);
    g_assert_cmpuint(gutil_ptrv_length(ptrv0), == ,0);
    g_assert_cmpuint(gutil_ptrv_length(ptrv1), == ,1);
}

/*==========================================================================*
 * ptrv_free
 *==========================================================================*/

static
void
test_ptrv_free(
    void)
{
    void** ptrv0 = g_new0(void*, 1);
    void** ptrv1 = g_new0(void*, 2);

ptrv1[0] = g_new0(int, 1);
    gutil_ptrv_free(NULL);
    gutil_ptrv_free(ptrv0);
    gutil_ptrv_free(ptrv1);
}

/*==========================================================================*
 * memdup
 *==========================================================================*/

static
void
test_memdup(
    void)
{
    static const guint8 data[] = { 0x01, 0x02, 0x03 };
    void* copy = gutil_memdup(data, sizeof(data));

g_assert(copy);
    g_assert(!memcmp(copy, data, sizeof(data)));
    g_free(copy);

g_assert(!gutil_memdup(data, 0));
    g_assert(!gutil_memdup(NULL, 0));
    g_assert(!gutil_memdup(NULL, 1));
}

/*==========================================================================*
 * strlen
 *==========================================================================*/

static
void
test_strlen(
    void)
{
    g_assert(!gutil_strlen0(NULL));
    g_assert_cmpuint(gutil_strlen0(""), == ,0);
    g_assert_cmpuint(gutil_strlen0("1"), == ,1);
}

/*==========================================================================*
 * range_init
 *==========================================================================*/

static
void
test_range_init(
    void)
{
    static const guint8 data[] = { 0x01, 0x02, 0x03 };
    GBytes* bytes = g_bytes_new_static(data, sizeof(data));
    GUtilRange range;

g_assert(!gutil_range_init_with_bytes(NULL, NULL));
    g_assert(!gutil_range_init_with_bytes(&range, NULL));
    g_assert(!range.ptr);
    g_assert(!range.end);

g_assert(gutil_range_init_with_bytes(&range, bytes) == sizeof(data));
    g_assert(range.ptr == data);
    g_assert(range.end == (data + sizeof(data)));
    g_bytes_unref(bytes);
}

/*==========================================================================*
 * range_prefix
 *==========================================================================*/

static
void
test_range_prefix(
    void)
{
    static const guint8 data[] = { 0x01, 0x02, 0x03, 0x04 };
    static const guint8 prefix[] = { 0x01, 0x02 };
    static const guint8 not_prefix[] = { 0x03, 0x04 };
    static const guint8 too_long[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
    GUtilData prefix_data, not_prefix_data, too_long_data;
    GUtilRange range;

memset(&range, 0, sizeof(range));
    g_assert(!gutil_range_has_prefix(NULL, NULL));
    g_assert(!gutil_range_has_prefix(&range, NULL));

not_prefix_data.bytes = not_prefix;
    not_prefix_data.size = sizeof(not_prefix);
    too_long_data.bytes = too_long;
    too_long_data.size = sizeof(too_long);

range.end = range.ptr = data; /* Empty range */
    memset(&prefix_data, 0, sizeof(prefix_data)); /* Empty prefix */
    /* Empty range doesn't have NULL prefix */
    g_assert(!gutil_range_has_prefix(&range, NULL));
    /* But does have empty prefix */
    g_assert(gutil_range_has_prefix(&range, &prefix_data));

/* And doesn't have non-empty prefix */
    g_assert(!gutil_range_has_prefix(&range, &not_prefix_data));
    prefix_data.bytes = prefix;
    prefix_data.size = sizeof(prefix);
    g_assert(!gutil_range_has_prefix(&range, &prefix_data));

range.end = range.ptr + sizeof(data);

g_assert(gutil_range_has_prefix(&range, &prefix_data));
    g_assert(!gutil_range_has_prefix(&range, &not_prefix_data));
    g_assert(!gutil_range_has_prefix(&range, &too_long_data));

/* Test skipping */
    g_assert(!gutil_range_skip_prefix(&range, &not_prefix_data));
    g_assert(range.ptr == data);

g_assert(gutil_range_skip_prefix(&range, &prefix_data));
    g_assert(range.ptr == (data + prefix_data.size));
}

/*==========================================================================*
 * bytes_prefix
 *==========================================================================*/

static
void
test_bytes_prefix(
    void)
{
    static const guint8 data[] = { 0x01, 0x02, 0x03, 0x04 };
    static const guint8 prefix[] = { 0x01, 0x02 };
    static const guint8 not_prefix[] = { 0x03, 0x04 };
    static const guint8 too_long[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
    GBytes* empty = g_bytes_new_static(NULL, 0);
    GBytes* bytes = g_bytes_new_static(TEST_ARRAY_AND_SIZE(data));

/* NULL GBytes doesn't have any prefix, even an empty one */
    g_assert(!gutil_bytes_has_prefix(NULL, NULL, 0));

/* Anything has an empty prefix */
    g_assert(gutil_bytes_has_prefix(empty, NULL, 0));
    g_assert(gutil_bytes_has_prefix(bytes, prefix, 0));

/* Test the matching */
    g_assert(gutil_bytes_has_prefix(bytes, TEST_ARRAY_AND_SIZE(prefix)));
    g_assert(!gutil_bytes_has_prefix(bytes, TEST_ARRAY_AND_SIZE(not_prefix)));
    g_assert(!gutil_bytes_has_prefix(bytes, TEST_ARRAY_AND_SIZE(too_long)));

g_bytes_unref(empty);
    g_bytes_unref(bytes);
}

/*==========================================================================*
 * bytes_suffix
 *==========================================================================*/

static
void
test_bytes_suffix(
    void)
{
    static const guint8 data[] = { 0x01, 0x02, 0x03, 0x04 };
    static const guint8 suffix[] = { 0x03, 0x04 };
    static const guint8 not_suffix[] = { 0x02, 0x03 };
    static const guint8 too_long[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
    GBytes* empty = g_bytes_new_static(NULL, 0);
    GBytes* bytes = g_bytes_new_static(TEST_ARRAY_AND_SIZE(data));

/* NULL GBytes doesn't have any suffix, even an empty one */
    g_assert(!gutil_bytes_has_suffix(NULL, NULL, 0));

/* Anything has an empty suffix */
    g_assert(gutil_bytes_has_suffix(empty, NULL, 0));
    g_assert(gutil_bytes_has_suffix(bytes, suffix, 0));

/* Test the matching */
    g_assert(gutil_bytes_has_suffix(bytes, TEST_ARRAY_AND_SIZE(suffix)));
    g_assert(!gutil_bytes_has_suffix(bytes, TEST_ARRAY_AND_SIZE(not_suffix)));
    g_assert(!gutil_bytes_has_suffix(bytes, TEST_ARRAY_AND_SIZE(too_long)));

g_bytes_unref(empty);
    g_bytes_unref(bytes);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_(x) "/misc/" x

int main(int argc, char* argv[])
{
    G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
    g_type_init();
    G_GNUC_END_IGNORE_DEPRECATIONS;
    g_test_init(&argc, &argv, NULL);

gutil_log_timestamp = FALSE;
    gutil_log_default.level = g_test_verbose() ?
        GLOG_LEVEL_VERBOSE : GLOG_LEVEL_NONE;

g_test_add_func(TEST_("version"), test_version);
    g_test_add_func(TEST_("disconnect"), test_disconnect);
    g_test_add_func(TEST_("hex2bin"), test_hex2bin);
    g_test_add_func(TEST_("hexdump"), test_hexdump);
    g_test_add_func(TEST_("parse_int"), test_parse_int);
    g_test_add_func(TEST_("parse_uint"), test_parse_uint);
    g_test_add_func(TEST_("parse_int64"), test_parse_int64);
    g_test_add_func(TEST_("parse_uint64"), test_parse_uint64);
    g_test_add_func(TEST_("data_equal"), test_data_equal);
    g_test_add_func(TEST_("data_prefix"), test_data_prefix);
    g_test_add_func(TEST_("data_suffix"), test_data_suffix);
    g_test_add_func(TEST_("data_from_bytes"), test_data_from_bytes);
    g_test_add_func(TEST_("data_from_string"), test_data_from_string);
    g_test_add_func(TEST_("bytes_concat"), test_bytes_concat);
    g_test_add_func(TEST_("bytes_xor"), test_bytes_xor);
    g_test_add_func(TEST_("bytes_equal"), test_bytes_equal);
    g_test_add_func(TEST_("ptrv_lenght"), test_ptrv_length);
    g_test_add_func(TEST_("ptrv_free"), test_ptrv_free);
    g_test_add_func(TEST_("memdup"), test_memdup);
    g_test_add_func(TEST_("strlen"), test_strlen);
    g_test_add_func(TEST_("range_init"), test_range_init);
    g_test_add_func(TEST_("range_prefix"), test_range_prefix);
    g_test_add_func(TEST_("bytes_prefix"), test_bytes_prefix);
    g_test_add_func(TEST_("bytes_suffix"), test_bytes_suffix);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000055000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002E00000000libglibutil-1680886706.91f2bff/test/test_ring07070100000056000081A400000000000000000000000164304BB20000004C000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/test/test_ring/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_ring

include ../common/Makefile
07070100000057000081A400000000000000000000000164304BB200003208000000000000000000000000000000000000003A00000000libglibutil-1680886706.91f2bff/test/test_ring/test_ring.c/*
 * Copyright (C) 2016-2017 Jolla Ltd.
 * Contact: Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the name of Jolla Ltd nor the names of its contributors may
 *      be used to endorse or promote products derived from this software
 *      without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_ring.h"

static TestOpt test_opt;

/*==========================================================================*
 * Basic
 *==========================================================================*/

static
void
test_basic(
    void)
{
    int i, n = 5;
    GUtilRing* r = gutil_ring_new();

/* Test NULL tolerance */
    g_assert(!gutil_ring_ref(NULL));
    gutil_ring_unref(NULL);
    gutil_ring_set_free_func(NULL, NULL);
    gutil_ring_set_free_func(r, NULL);
    gutil_ring_set_free_func(NULL, g_free);
    gutil_ring_clear(NULL);
    gutil_ring_compact(NULL);
    gutil_ring_reserve(NULL, 0);
    g_assert(!gutil_ring_size(NULL));
    g_assert(!gutil_ring_can_put(NULL, 1));
    g_assert(!gutil_ring_put(NULL, NULL));
    g_assert(!gutil_ring_put_front(NULL, NULL));
    g_assert(!gutil_ring_get(NULL));
    g_assert(!gutil_ring_data_at(NULL, 0));
    g_assert(!gutil_ring_get_last(NULL));
    g_assert(!gutil_ring_drop(NULL, 1));
    g_assert(!gutil_ring_drop_last(NULL, 1));
    g_assert(!gutil_ring_flatten(NULL, NULL));

g_assert(gutil_ring_ref(r) == r);
    gutil_ring_unref(r);

/* Put some data in */
    for (i=0; i<n; i++) {
        g_assert(gutil_ring_can_put(r, 1));
        g_assert(gutil_ring_put(r, GINT_TO_POINTER(i)));
    }

/* Access at invalid index */
    g_assert(!gutil_ring_data_at(r, -1));
    g_assert(!gutil_ring_data_at(r, n));

/* Peek the data */
    for (i=0; i<n; i++) {
        g_assert(gutil_ring_data_at(r, i) == GINT_TO_POINTER(i));
    }

/* Get the data */
    for (i=0; i<n; i++) {
        gutil_ring_flatten(r, NULL);
        gutil_ring_compact(r);
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(i));
    }

/* There should be nothing left */
    g_assert(!gutil_ring_get(r));

gutil_ring_compact(r);
    gutil_ring_compact(r);
    gutil_ring_clear(r);
    g_assert(!gutil_ring_flatten(r, &i));
    g_assert(!i);

gutil_ring_unref(r);
}

/*==========================================================================*
 * PutFront
 *==========================================================================*/

static
void
test_put_front(
    void)
{
    int i, n = 5;
    GUtilRing* r = gutil_ring_new();

for (i=0; i<n; i++) {
        g_assert(gutil_ring_can_put(r, 1));
        g_assert(gutil_ring_put_front(r, GINT_TO_POINTER(n-i-1)));
    }

for (i=0; i<n; i++) {
        gutil_ring_compact(r);
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(i));
    }

/* The same but take it out with get_last */
    for (i=0; i<n; i++) {
        g_assert(gutil_ring_can_put(r, 1));
        g_assert(gutil_ring_put_front(r, GINT_TO_POINTER(n-i-1)));
    }

for (i=0; i<n; i++) {
        gutil_ring_compact(r);
        g_assert(gutil_ring_get_last(r) == GINT_TO_POINTER(n-i-1));
    }

g_assert(!gutil_ring_get_last(r));
    gutil_ring_unref(r);
}

/*==========================================================================*
 * Drop
 *==========================================================================*/

static
void
test_drop(
    void)
{
    int i, n = 5, get = 3, drop = 3;
    GUtilRing* r = gutil_ring_sized_new(0,n);

/* [01234] */
    for (i=0; i<n; i++) {
        gutil_ring_put(r, GINT_TO_POINTER(i));
    }

/* ...[34] */
    for (i=0; i<get; i++) {
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(i));
    }

/* 567][34 */
    for (i=0; i<get; i++) {
        gutil_ring_put(r, GINT_TO_POINTER(n+i));
    }

/* ..[67].. */
    g_assert(gutil_ring_drop(r, drop) == drop);
    for (i=0; i<(n-drop); i++) {
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(get+drop+i));
    }

/* Drop more than the size of the buffer (i.e. clear it) */
    for (i=0; i<n; i++) {
        gutil_ring_put(r, GINT_TO_POINTER(i));
    }

g_assert(!gutil_ring_drop(r, 0));
    g_assert(gutil_ring_drop(r, n+1) == n);
    g_assert(!gutil_ring_drop(r, 1));
    g_assert(!gutil_ring_size(r));

gutil_ring_unref(r);
}

/*==========================================================================*
 * DropLast
 *==========================================================================*/

static
void
test_drop_last(
    void)
{
    int i, n = 5, get = 2, drop = 3;
    GUtilRing* r = gutil_ring_sized_new(0,n);

/* [01234] */
    for (i=0; i<n; i++) {
        gutil_ring_put(r, GINT_TO_POINTER(i));
    }

/* ..[234] */
    for (i=0; i<get; i++) {
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(i));
    }

/* 56][234 */
    for (i=0; i<get; i++) {
        gutil_ring_put(r, GINT_TO_POINTER(n+i));
    }

/* ..[23]. */
    g_assert(gutil_ring_drop_last(r, drop) == drop);
    gutil_ring_flatten(r, NULL);
    for (i=0; i<(n-drop); i++) {
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(get+i));
    }

/* Drop more than the size of the buffer (i.e. clear it) */
    for (i=0; i<n; i++) {
        gutil_ring_put(r, GINT_TO_POINTER(i));
    }

g_assert(!gutil_ring_drop_last(r, 0));
    g_assert(gutil_ring_drop_last(r, n+1) == n);
    g_assert(!gutil_ring_drop_last(r, 1));
    g_assert(!gutil_ring_size(r));

gutil_ring_unref(r);
}

/*==========================================================================*
 * Limit
 *==========================================================================*/

static
void
test_limit(
    void)
{
    int i, limit = 5, extra = 2;
    gint size;
    gpointer* data;
    GUtilRing* r = gutil_ring_sized_new(2, limit);

g_assert(gutil_ring_reserve(r, limit));
    g_assert(!gutil_ring_reserve(r, limit+1));

for (i=0; i<limit; i++) {
        g_assert(gutil_ring_can_put(r, 1));
        g_assert(gutil_ring_put(r, GINT_TO_POINTER(i)));
    }

g_assert(!gutil_ring_can_put(r, 1));
    g_assert(gutil_ring_get_last(r) == GINT_TO_POINTER(limit-1));
    g_assert(gutil_ring_get_last(r) == GINT_TO_POINTER(limit-2));
    g_assert(gutil_ring_put(r, GINT_TO_POINTER(limit-2)));
    g_assert(gutil_ring_put(r, GINT_TO_POINTER(limit-1)));

for (i=0; i<extra; i++) {
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(i));
        g_assert(gutil_ring_can_put(r, 1));
        g_assert(gutil_ring_put(r, GINT_TO_POINTER(i+limit)));
    }

g_assert(gutil_ring_size(r) == limit);
    data = gutil_ring_flatten(r, &size);
    g_assert(data);
    g_assert(size == limit);

for (i=0; i<size; i++) {
        g_assert(data[i] == GINT_TO_POINTER(i+extra));
    }

g_assert(gutil_ring_get_last(r) == GINT_TO_POINTER(size+extra-1));
    gutil_ring_compact(r);
    data = gutil_ring_flatten(r, &size);
    g_assert(data);
    g_assert(size == limit-1);
    for (i=0; i<size; i++) {
        g_assert(data[i] == GINT_TO_POINTER(i+extra));
    }

gutil_ring_clear(r);

for (i=0; i<limit; i++) {
        gutil_ring_put(r, GINT_TO_POINTER(i));
    }
    
    for (i=0; i<limit; i++) {
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(i));
    }

gutil_ring_unref(r);
}

/*==========================================================================*
 * MaxSize
 *==========================================================================*/

static
void
test_max_size(
    void)
{
    int i;
    const int n = 5;
    GUtilRing* r = gutil_ring_sized_new(0, -2);

g_assert(!gutil_ring_max_size(NULL));
    g_assert(gutil_ring_max_size(r) == GUTIL_RING_UNLIMITED_SIZE);

gutil_ring_set_max_size(NULL, n); /* This one shouldn't crash */
    gutil_ring_set_max_size(r, n);
    for (i=0; i<n; i++) {
        g_assert(gutil_ring_put(r, GINT_TO_POINTER(i)));
    }

/* The buffer is full, the next put should fail */
    g_assert(!gutil_ring_put(r, GINT_TO_POINTER(i)));
    g_assert(gutil_ring_size(r) == n);
    gutil_ring_set_max_size(r, n);
    g_assert(gutil_ring_size(r) == n);

/* Allow more space */
    gutil_ring_set_max_size(r, 2*n);
    for (i=0; i<n; i++) {
        g_assert(gutil_ring_put(r, GINT_TO_POINTER(i+n)));
    }

/* The buffer is full again */
    g_assert(!gutil_ring_put(r, GINT_TO_POINTER(i)));
    g_assert(gutil_ring_size(r) == 2*n);

/* Shrink it */
    gutil_ring_set_max_size(r, n);
    g_assert(gutil_ring_size(r) == n);
    for (i=0; i<n; i++) {
        g_assert(gutil_ring_get(r) == GINT_TO_POINTER(i+n));
    }
    g_assert(!gutil_ring_size(r));

/* Negative == unlimited */
    gutil_ring_set_max_size(r, -2);
    g_assert(gutil_ring_max_size(r) == GUTIL_RING_UNLIMITED_SIZE);
    gutil_ring_unref(r);
}

/*==========================================================================*
 * Free
 *==========================================================================*/

static
void
test_free_func(
    gpointer ptr)
{
    int* data = ptr;
    (*data)++;
}

static
void
test_free(
    void)
{
    int data[5];
    const int n = G_N_ELEMENTS(data);
    const int drop = 2;
    int i;
    GUtilRing* r = gutil_ring_new();

gutil_ring_set_free_func(r, test_free_func);
    memset(data, 0, sizeof(data));
    for (i=0; i<n; i++) {
        gutil_ring_put(r, data + i);
    }

/* Clear it twice */
    gutil_ring_clear(r);
    gutil_ring_clear(r);

/* Make sure that test_free_func has been called */
    for (i=0; i<n; i++) {
        g_assert(data[i] == 1);
    }

for (i=0; i<n; i++) {
        gutil_ring_put(r, data + i);
    }
    gutil_ring_get(r);
    gutil_ring_unref(r);

/* test_free_func shouldn't be invoked for the element we retreived */
    g_assert(data[0] == 1);
    for (i=1; i<n; i++) {
        g_assert(data[i] == 2);
    }

r = gutil_ring_new();
    gutil_ring_set_free_func(r, test_free_func);

memset(data, 0, sizeof(data));
    for (i=0; i<n; i++) {
        gutil_ring_put(r, data + i);
    }

g_assert(gutil_ring_drop(r, drop) == drop);
    g_assert(gutil_ring_drop_last(r, drop) == drop);
    g_assert(gutil_ring_size(r) == (n - 2*drop));

for (i=drop; i<(n-drop); i++) {
        g_assert(gutil_ring_get(r) == data + i);
    }

for (i=0; i<n; i++) {
        if (i < drop) {
            /* Invoked by drop */
            g_assert(data[i] == 1);
        } else if (i >= (n-drop)) {
            /* Invoked by drop last */
            g_assert(data[i] == 1);
        } else {
            /* Not invoked for those we have retreived */
            g_assert(data[i] == 0);
        }
    }

gutil_ring_unref(r);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_PREFIX "/ring/"

int main(int argc, char* argv[])
{
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_PREFIX "basic", test_basic);
    g_test_add_func(TEST_PREFIX "put_front", test_put_front);
    g_test_add_func(TEST_PREFIX "drop", test_drop);
    g_test_add_func(TEST_PREFIX "drop_last", test_drop_last);
    g_test_add_func(TEST_PREFIX "max_size", test_max_size);
    g_test_add_func(TEST_PREFIX "limit", test_limit);
    g_test_add_func(TEST_PREFIX "free", test_free);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000058000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000002E00000000libglibutil-1680886706.91f2bff/test/test_strv07070100000059000081A400000000000000000000000164304BB20000004C000000000000000000000000000000000000003700000000libglibutil-1680886706.91f2bff/test/test_strv/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_strv

include ../common/Makefile
0707010000005A000081A400000000000000000000000164304BB200002B60000000000000000000000000000000000000003A00000000libglibutil-1680886706.91f2bff/test/test_strv/test_strv.c/*
 * Copyright (C) 2015-2022 Jolla Ltd.
 * Copyright (C) 2015-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_strv.h"
#include "gutil_log.h"

static TestOpt test_opt;

/*==========================================================================*
 * Basic
 *==========================================================================*/

static
void
test_basic(
    void)
{
    char** sv = g_strsplit("a,b", ",", 0);

g_assert(gutil_strv_length(NULL) == 0);
    g_assert(gutil_strv_length(sv) == 2);
    g_assert(!g_strcmp0(gutil_strv_at(sv, 0), "a"));
    g_assert(!g_strcmp0(gutil_strv_at(sv, 1), "b"));
    g_assert(!gutil_strv_at(sv, 2));
    g_assert(!gutil_strv_at(sv, 3));
    g_assert(!gutil_strv_at(NULL, 0));
    g_assert(!gutil_strv_strip(NULL));

g_strfreev(sv);
}

/*==========================================================================*
 * Last
 *==========================================================================*/

static
void
test_last(
    void)
{
    char** empty = g_new0(char*, 1);
    char** a = g_strsplit("a", ",", 0);
    char** ab = g_strsplit("a,b", ",", 0);

g_assert(!gutil_strv_last(NULL));
    g_assert(!gutil_strv_last(empty));
    g_assert(!g_strcmp0(gutil_strv_last(a), "a"));
    g_assert(!g_strcmp0(gutil_strv_last(ab), "b"));

g_strfreev(empty);
    g_strfreev(a);
    g_strfreev(ab);
}

/*==========================================================================*
 * Add
 *==========================================================================*/

static
void
test_addv(
    void)
{
    char** sv1;
    char** sv2;

g_assert(!gutil_strv_add(NULL, NULL));
    g_assert(!gutil_strv_addv(NULL, NULL, NULL));

sv1 = gutil_strv_add(NULL, "a");
    g_assert(gutil_strv_addv(sv1, NULL, NULL) == sv1);
    sv2 = gutil_strv_addv(NULL, "a", NULL);
    g_assert(gutil_strv_equal(sv1, sv2));

g_strfreev(sv1);
    sv1 = g_strsplit("a,bb,ccc", ",", 0);
    sv2 = gutil_strv_addv(sv2, "bb", "ccc", NULL);
    g_assert(gutil_strv_equal(sv1, sv2));

g_strfreev(sv1);
    g_strfreev(sv2);
}

/*==========================================================================*
 * Equal
 *==========================================================================*/

static
void
test_equal(
    void)
{
    char** sv1 = gutil_strv_addv(NULL, "a", "b", "c", " ", "", NULL);
    char** sv2 = g_strsplit("a,b,c, ,", ",", 0);
    char** sv3 = g_strsplit("a,a,a, ,", ",", 0);
    char** sv4 = g_strsplit("a,b,c,,", ",", 0);
    char** sv5 = g_strsplit("a,b,c,", ",", 0);
    char* empty = NULL;

g_assert(!gutil_strv_add(NULL, NULL));
    g_assert(gutil_strv_equal(NULL, NULL));
    g_assert(gutil_strv_equal(NULL, &empty));
    g_assert(gutil_strv_equal(&empty, NULL));
    g_assert(!gutil_strv_equal(sv1, NULL));
    g_assert(!gutil_strv_equal(NULL, sv2));
    g_assert(gutil_strv_equal(sv1, sv1));
    g_assert(gutil_strv_equal(sv1, sv2));
    g_assert(!gutil_strv_equal(sv1, sv3));
    g_assert(!gutil_strv_equal(sv1, sv4));
    g_assert(!gutil_strv_equal(sv1, sv5));
    g_assert(!gutil_strv_equal(sv5, sv1));

g_strfreev(sv1);
    g_strfreev(sv2);
    g_strfreev(sv3);
    g_strfreev(sv4);
    g_strfreev(sv5);
}

/*==========================================================================*
 * Find
 *==========================================================================*/

static
void
test_find(
    void)
{
    char** sv = g_strsplit("a,b,b,c", ",", 0);

g_assert(gutil_strv_contains(sv, "a"));
    g_assert(gutil_strv_contains(sv, "b"));
    g_assert(gutil_strv_contains(sv, "c"));
    g_assert(!gutil_strv_contains(sv, "d"));
    g_assert_cmpint(gutil_strv_find(sv, "b"), == ,1);
    g_assert_cmpint(gutil_strv_find_last(sv, "a"), == ,0);
    g_assert_cmpint(gutil_strv_find_last(sv, "b"), == ,2);
    g_assert_cmpint(gutil_strv_find_last(sv, "c"), == ,3);
    g_assert_cmpint(gutil_strv_find_last(sv, "d"), == ,-1);
    g_assert_cmpint(gutil_strv_find_last(NULL, NULL), == ,-1);
    g_assert(!gutil_strv_contains(sv, NULL));
    g_assert(!gutil_strv_contains(NULL, "a"));
    g_assert(!gutil_strv_contains(NULL, NULL));
    g_strfreev(sv);
}

/*==========================================================================*
 * Remove
 *==========================================================================*/

static
void
test_remove(
    void)
{
    guint orig_len = 8;
    char** sv = g_strsplit("a,b,c,b,c,c,d,b", ",", 0); /* 8 elements */
    char** sv1 = g_strsplit("a,b,b,c,c,d,b", ",", 0); /* Minus one c */
    char** sv2 = g_strsplit("a,c,c,d", ",", 0); /* Minus all b's */
    char** sv3 = g_strsplit("a,c,c", ",", 0); /* Minus all (actually one) d */

g_assert(!gutil_strv_remove_all(NULL, NULL));
    g_assert(gutil_strv_remove_all(sv, NULL) == sv);
    g_assert_cmpuint(gutil_strv_length(sv), == ,orig_len);

g_assert(sv == gutil_strv_remove_all(sv, "e")); /* "e" is not there */
    g_assert_cmpuint(gutil_strv_length(sv), == ,orig_len);
    g_assert(gutil_strv_equal(sv = gutil_strv_remove_one(sv, "c"), sv1));
    g_assert(gutil_strv_equal(sv = gutil_strv_remove_all(sv, "b"), sv2));
    g_assert(gutil_strv_equal(sv = gutil_strv_remove_all(sv, "d"), sv3));

g_strfreev(sv);
    g_strfreev(sv1);
    g_strfreev(sv2);
    g_strfreev(sv3);
}

/*==========================================================================*
 * RemoveAt
 *==========================================================================*/

static
void
test_remove_at(
    void)
{
    char** sv = g_strsplit("a,b,c", ",", 0);
    char* c = sv[2];

g_assert(!gutil_strv_remove_at(NULL, 0, FALSE));
    g_assert(gutil_strv_remove_at(sv, 3, FALSE) == sv);
    g_assert(gutil_strv_remove_at(sv, -1, FALSE) == sv);

sv = gutil_strv_remove_at(sv, 2, FALSE);
    g_assert(!gutil_strv_contains(sv, "c"));

sv = gutil_strv_remove_at(sv, 0, TRUE);
    g_assert(!gutil_strv_contains(sv, "a"));
    g_assert(gutil_strv_length(sv) == 1);

g_free(c);
    g_strfreev(sv);
}

/*==========================================================================*
 * RemoveDups
 *==========================================================================*/

static
void
test_remove_dups(
    void)
{
    char** sv = g_strsplit("a,b,c,b,c,c,d,b", ",", 0); /* 8 elements */
    char** sv1 = g_strsplit("a,b,c,d", ",", 0); /* No dups */

g_assert(!gutil_strv_remove_dups(NULL));
    g_assert(gutil_strv_equal(sv = gutil_strv_remove_dups(sv), sv1));
    g_assert(sv == gutil_strv_remove_dups(sv)); /* Nothing to realloc */
    g_assert(gutil_strv_equal(sv, sv1)); /* Still equal */

g_strfreev(sv);
    g_strfreev(sv1);
}

/*==========================================================================*
 * Sort
 *==========================================================================*/

static
void
test_sort(
    void)
{
    char** in = g_strsplit("c,a,d,b", ",", 0);
    char** a1 = g_strsplit("a,b,c,d", ",", 0);
    char** d1 = g_strsplit("d,c,b,a", ",", 0);
    char** a2 = gutil_strv_sort(g_strdupv(in), TRUE);
    char** d2 = gutil_strv_sort(g_strdupv(in), FALSE);

g_assert(gutil_strv_equal(a1, a2));
    g_assert(gutil_strv_equal(d1, d2));
    g_assert(!gutil_strv_sort(NULL, FALSE));

g_strfreev(a1);
    g_strfreev(a2);
    g_strfreev(d1);
    g_strfreev(d2);
    g_strfreev(in);
}

/*==========================================================================*
 * Bsearch
 *==========================================================================*/

static
void
test_bsearch(
    void)
{
    char** a = g_strsplit("a,b,c,d", ",", 0);
    char** d = g_strsplit("d,c,b,a", ",", 0);

g_assert(gutil_strv_sort(a, TRUE) == a);
    g_assert(gutil_strv_sort(d, FALSE) == d);

g_assert(gutil_strv_bsearch(NULL, "a", TRUE) < 0);
    g_assert(gutil_strv_bsearch(a, NULL, TRUE) < 0);
    g_assert(gutil_strv_bsearch(a, "x", TRUE) < 0);
    g_assert(gutil_strv_bsearch(a, "a", TRUE) == 0);
    g_assert(gutil_strv_bsearch(d, "a", FALSE) == 3);

g_strfreev(a);
    g_strfreev(d);
}

/*==========================================================================*
 * Strip
 *==========================================================================*/

static
void
test_strip(
    void)
{
    char** in = g_strsplit(" a,b , c ,", ",", 0);
    char** expect = g_strsplit("a,b,c,", ",", 0);
    g_assert(gutil_strv_strip(in) == in);
    g_assert(gutil_strv_equal(in, expect));
    g_strfreev(in);
    g_strfreev(expect);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_PREFIX "/strv/"

int main(int argc, char* argv[])
{
    g_test_init(&argc, &argv, NULL);
    g_test_add_func(TEST_PREFIX "basic", test_basic);
    g_test_add_func(TEST_PREFIX "addv", test_addv);
    g_test_add_func(TEST_PREFIX "last", test_last);
    g_test_add_func(TEST_PREFIX "equal", test_equal);
    g_test_add_func(TEST_PREFIX "find", test_find);
    g_test_add_func(TEST_PREFIX "remove", test_remove);
    g_test_add_func(TEST_PREFIX "remove_at", test_remove_at);
    g_test_add_func(TEST_PREFIX "remove_dups", test_remove_dups);
    g_test_add_func(TEST_PREFIX "sort", test_sort);
    g_test_add_func(TEST_PREFIX "bsearch", test_bsearch);
    g_test_add_func(TEST_PREFIX "strip", test_strip);
    test_init(&test_opt, argc, argv);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
0707010000005B000041ED00000000000000000000000264304BB200000000000000000000000000000000000000000000003100000000libglibutil-1680886706.91f2bff/test/test_weakref0707010000005C000081A400000000000000000000000164304BB20000004F000000000000000000000000000000000000003A00000000libglibutil-1680886706.91f2bff/test/test_weakref/Makefile# -*- Mode: makefile-gmake -*-

EXE = test_weakref

include ../common/Makefile
0707010000005D000081A400000000000000000000000164304BB200000DCB000000000000000000000000000000000000004000000000libglibutil-1680886706.91f2bff/test/test_weakref/test_weakref.c/*
 * Copyright (C) 2023 Slava Monich <slava@monich.com>
 *
 * You may use this file under the terms of BSD license as follows:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *   3. Neither the names of the copyright holders nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "test_common.h"

#include "gutil_weakref.h"

#include <glib-object.h>

static TestOpt test_opt;

/*==========================================================================*
 * null
 *==========================================================================*/

static
void
test_null()
{
    gutil_weakref_unref(NULL);
    gutil_weakref_set(NULL, NULL);
    g_assert(!gutil_weakref_ref(NULL));
    g_assert(!gutil_weakref_get(NULL));
}

/*==========================================================================*
 * basic
 *==========================================================================*/

static
void
test_basic()
{
    GObject* obj = g_object_new(TEST_OBJECT_TYPE, NULL);
    GUtilWeakRef* ref = gutil_weakref_new(obj);

g_assert(gutil_weakref_ref(ref) == ref);
    gutil_weakref_unref(ref);
    g_assert(gutil_weakref_get(ref) == obj);
    g_object_unref(obj);
    gutil_weakref_unref(ref);

ref = gutil_weakref_new(NULL);
    g_assert(!gutil_weakref_get(ref));
    gutil_weakref_set(ref, obj);
    g_assert(gutil_weakref_get(ref) == obj);
    g_object_unref(obj);
    g_object_unref(obj); /* This actually deallocates the object */
    g_assert(!gutil_weakref_get(ref));
    gutil_weakref_unref(ref);
}

/*==========================================================================*
 * Common
 *==========================================================================*/

#define TEST_(name) "/weakref/" name

int main(int argc, char* argv[])
{
    G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
    g_type_init();
    G_GNUC_END_IGNORE_DEPRECATIONS;
    g_test_init(&argc, &argv, NULL);
    test_init(&test_opt, argc, argv);
    g_test_add_func(TEST_("null"), test_null);
    g_test_add_func(TEST_("basic"), test_basic);
    return g_test_run();
}

/*
 * Local Variables:
 * mode: C
 * c-basic-offset: 4
 * indent-tabs-mode: nil
 * End:
 */
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!792 blocks

Places

File _service:obs_scm:libglibutil-1680886706.91f2bff.obscpio of Package libglibutil

Places