PR#17: run the automated tests stored in this repository - rpms/libsemanage

rpms / libsemanage

#17 run the automated tests stored in this repository

Merged 2 months ago by plautrba. Opened 2 months ago by mmalik.

rpms/ mmalik/libsemanage run-local-tests into rawhide

remove the automated tests stored in the repository

Milos Malik • 2 months ago

cedff95

tests/semanage-handle-functions/Makefile

file removed

-63

		`@@ -1,63 +0,0 @@`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Makefile of /CoreOS/libsemanage/Sanity/semanage-handle-functions`
		`- # Description: Test functions from handle.h`
		`- # Author: Jan Zarsky <jzarsky@redhat.com>`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Copyright (c) 2017 Red Hat, Inc.`
		`- #`
		`- # This program is free software: you can redistribute it and/or`
		`- # modify it under the terms of the GNU General Public License as`
		`- # published by the Free Software Foundation, either version 2 of`
		`- # the License, or (at your option) any later version.`
		`- #`
		`- # This program is distributed in the hope that it will be`
		`- # useful, but WITHOUT ANY WARRANTY; without even the implied`
		`- # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR`
		`- # PURPOSE. See the GNU General Public License for more details.`
		`- #`
		`- # You should have received a copy of the GNU General Public License`
		`- # along with this program. If not, see http://www.gnu.org/licenses/.`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`-`
		`- export TEST=/CoreOS/libsemanage/Sanity/semanage-handle-functions`
		`- export TESTVERSION=1.0`
		`-`
		`- BUILT_FILES=`
		`-`
		`- FILES=$(METADATA) runtest.sh Makefile PURPOSE functions.c test_*.c`
		`-`
		`- .PHONY: all install download clean`
		`-`
		`- run: $(FILES) build`
		`- ./runtest.sh`
		`-`
		`- build: $(BUILT_FILES)`
		`- test -x runtest.sh \|\| chmod a+x runtest.sh`
		`-`
		`- clean:`
		`- rm -f *~ $(BUILT_FILES)`
		`-`
		`-`
		`- include /usr/share/rhts/lib/rhts-make.include`
		`-`
		`- $(METADATA): Makefile`
		`- @echo "Owner: Jan Zarsky <jzarsky@redhat.com>" > $(METADATA)`
		`- @echo "Name: $(TEST)" >> $(METADATA)`
		`- @echo "TestVersion: $(TESTVERSION)" >> $(METADATA)`
		`- @echo "Path: $(TEST_DIR)" >> $(METADATA)`
		`- @echo "Description: Test functions from handle.h" >> $(METADATA)`
		`- @echo "Type: Sanity" >> $(METADATA)`
		`- @echo "TestTime: 5m" >> $(METADATA)`
		`- @echo "RunFor: libsemanage" >> $(METADATA)`
		`- @echo "Requires: libsemanage libsemanage-devel glibc gcc" >> $(METADATA)`
		`- @echo "Priority: Normal" >> $(METADATA)`
		`- @echo "License: GPLv2+" >> $(METADATA)`
		`- @echo "Confidential: no" >> $(METADATA)`
		`- @echo "Destructive: no" >> $(METADATA)`
		`- @echo "Releases: -RHEL4 -RHELClient5 -RHELServer5" >> $(METADATA)`
		`-`
		`- rhts-lint $(METADATA)`

tests/semanage-handle-functions/PURPOSE

file removed

-3

		`@@ -1,3 +0,0 @@`
		`- PURPOSE of /CoreOS/libsemanage/Sanity/semanage-handle-functions`
		`- Description: Test functions from handle.h`
		`- Author: Jan Zarsky <jzarsky@redhat.com>`

tests/semanage-handle-functions/functions.c

file removed

-132

		`@@ -1,132 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- void check_result_int(const char *expected, int real) {`
		`- int exp = strtol(expected, NULL, 10);`
		`-`
		`- if (exp != real) {`
		`- fprintf(stderr, "Expected %d but got %d\n", exp, real);`
		`- exit(1);`
		`- }`
		`- }`
		`-`
		`- semanage_handle_t *test_handle_create() {`
		`- semanage_handle_t *sh = NULL;`
		`-`
		`- sh = semanage_handle_create();`
		`- printf("semanage_handle_create(): %p\n", (void *) sh);`
		`-`
		`- if (sh == NULL) {`
		`- perror("semanage_handle_create");`
		`- exit(1);`
		`- }`
		`-`
		`- return sh;`
		`- }`
		`-`
		`- int test_connect(semanage_handle_t *sh) {`
		`- int result = semanage_connect(sh);`
		`- printf("semanage_connect(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_connect");`
		`- exit(1);`
		`- }`
		`-`
		`- return result;`
		`- }`
		`-`
		`- int test_disconnect(semanage_handle_t *sh) {`
		`- int result = semanage_disconnect(sh);`
		`- printf("semanage_disconnect(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_disconnect");`
		`- exit(1);`
		`- }`
		`-`
		`- return result;`
		`- }`
		`-`
		`- int test_begin_transaction(semanage_handle_t *sh) {`
		`- int result = semanage_begin_transaction(sh);`
		`- printf("semanage_begin_transaction(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_begin_transaction");`
		`- exit(1);`
		`- }`
		`-`
		`- return result;`
		`- }`
		`-`
		`- int test_commit(semanage_handle_t *sh) {`
		`- int result = semanage_commit(sh);`
		`- printf("semanage_commit(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_commit");`
		`- exit(1);`
		`- }`
		`-`
		`- return result;`
		`- }`
		`-`
		`- #define STATE_INIT 1`
		`- #define STATE_HANDLE 2`
		`- #define STATE_CONN 3`
		`- #define STATE_TRANS 4`
		`-`
		`- int get_state(const char *state_str) {`
		`- if (strcmp(state_str, "init") == 0)`
		`- return STATE_INIT;`
		`- if (strcmp(state_str, "handle") == 0)`
		`- return STATE_HANDLE;`
		`- if (strcmp(state_str, "conn") == 0)`
		`- return STATE_CONN;`
		`- if (strcmp(state_str, "trans") == 0)`
		`- return STATE_TRANS;`
		`-`
		`- return 0;`
		`- }`
		`-`
		`- semanage_handle_t * get_handle(const char *state_str) {`
		`- int state;`
		`- semanage_handle_t *sh = NULL;`
		`-`
		`- state = get_state(state_str);`
		`-`
		`- if (state >= STATE_INIT)`
		`- sh = NULL;`
		`-`
		`- if (state >= STATE_HANDLE)`
		`- sh = test_handle_create();`
		`-`
		`- if (state >= STATE_CONN)`
		`- test_connect(sh);`
		`-`
		`- if (state >= STATE_TRANS)`
		`- test_begin_transaction(sh);`
		`-`
		`- return sh;`
		`- }`
		`-`
		`- void destroy_handle(semanage_handle_t sh, const char state_str) {`
		`- int state;`
		`-`
		`- state = get_state(state_str);`
		`-`
		`- if (state >= STATE_TRANS)`
		`- test_commit(sh);`
		`-`
		`- if (state >= STATE_CONN)`
		`- test_disconnect(sh);`
		`-`
		`- if (state >= STATE_HANDLE) {`
		`- semanage_handle_destroy(sh);`
		`- printf("semanage_handle_destroy(%p)\n", (void *) sh);`
		`- }`
		`- }`

tests/semanage-handle-functions/plan.txt

file removed

-29

		`@@ -1,29 +0,0 @@`
		`- init handle conn trans`
		`- semanage_set_root x ok ok ok -`
		`- semanage_root x ok ok ok -`
		`- semanage_handle_create x ok - - -`
		`- semanage_set_rebuild fail ok ok -`
		`- semanage_set_reload fail ok ok -`
		`- semanage_get_hll_compiler_path fail ? ? -`
		`- semanage_set_create_store fail ok ok - should be called after connect`
		`- semanage_get_disable_dontaudit fail ? ? -`
		`- semanage_set_disable_dontaudit fail ? ? -`
		`- semanage_get_preserve_tunables fail ? ? -`
		`- semanage_set_preserve_tunables fail ? ? -`
		`- semanage_get_ignore_module_cache fail ? ? -`
		`- semanage_set_ignore_module_cache fail ? ? -`
		`- semanage_set_check_contexts fail ok ok -`
		`- semanage_get_default_priority fail ok ok -`
		`- semanage_set_default_priority fail ok ok -`
		`- semanage_is_connected x fail ok ok -`
		`- semanage_select_store fail ok ok - should be called before connect`
		`- semanage_set_store_root fail ok ok -`
		`- semanage_is_managed x fail ok fail -`
		`- semanage_mls_enabled x fail ? ok -`
		`- semanage_connect x fail ok ? -`
		`- semanage_access_check x fail ok ? -`
		`- semanage_disconnect x fail fail ok - ok when disconnected twice`
		`- semanage_handle_destroy x fail ok ok -`
		`- semanage_begin_transaction x fail fail ok ok ok when begin twice`
		`- semanage_commit x fail fail fail ok`
		`- semanage_reload_policy fail ? ? ?`

tests/semanage-handle-functions/runtest.sh

file removed

-122

		`@@ -1,122 +0,0 @@`
		`- #!/bin/bash`
		`- # vim: dict+=/usr/share/beakerlib/dictionary.vim cpt=.,w,b,u,t,i,k`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # runtest.sh of /CoreOS/libsemanage/Sanity/semanage-handle-functions`
		`- # Description: Test functions from handle.h`
		`- # Author: Jan Zarsky <jzarsky@redhat.com>`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Copyright (c) 2017 Red Hat, Inc.`
		`- #`
		`- # This program is free software: you can redistribute it and/or`
		`- # modify it under the terms of the GNU General Public License as`
		`- # published by the Free Software Foundation, either version 2 of`
		`- # the License, or (at your option) any later version.`
		`- #`
		`- # This program is distributed in the hope that it will be`
		`- # useful, but WITHOUT ANY WARRANTY; without even the implied`
		`- # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR`
		`- # PURPOSE. See the GNU General Public License for more details.`
		`- #`
		`- # You should have received a copy of the GNU General Public License`
		`- # along with this program. If not, see http://www.gnu.org/licenses/.`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`-`
		`- # Include Beaker environment`
		`- . /usr/bin/rhts-environment.sh \|\| exit 1`
		`- . /usr/share/beakerlib/beakerlib.sh \|\| exit 1`
		`-`
		`- PACKAGE="libsemanage"`
		`-`
		`- rlJournalStart`
		`- rlPhaseStartSetup`
		`- rlAssertRpm ${PACKAGE}`
		`- rlAssertRpm ${PACKAGE}-devel`
		`- rlAssertRpm "glibc"`
		`- rlAssertRpm "gcc"`
		`-`
		`- if rlIsRHEL ">=7" \|\| rlIsFedora; then`
		`- rlRun -l "gcc test_root.c -o test_root -lsemanage -Wall -Wextra -std=c99"`
		`- fi`
		`-`
		`- rlRun -l "gcc test_handle_create.c -o test_handle_create -lsemanage -Wall -Wextra -Wno-unused-parameter -std=c99"`
		`- rlRun -l "gcc test_access_check.c -o test_access_check -lsemanage -Wall -Wextra -std=c99"`
		`- rlRun -l "gcc test_is_managed.c -o test_is_managed -lsemanage -Wall -Wextra -std=c99"`
		`- rlRun -l "gcc test_connect.c -o test_connect -lsemanage -Wall -Wextra -std=c99"`
		`- rlRun -l "gcc test_is_connected.c -o test_is_connected -lsemanage -Wall -Wextra -std=c99"`
		`- rlRun -l "gcc test_mls_enabled.c -o test_mls_enabled -lsemanage -Wall -Wextra -std=c99"`
		`- rlRun -l "gcc test_transaction.c -o test_transaction -lsemanage -Wall -Wextra -std=c99"`
		`-`
		`- ERR_FAIL=1`
		`- ERR_ABORT=134`
		`- rlPhaseEnd`
		`-`
		`- if rlIsRHEL ">=7" \|\| rlIsFedora; then`
		`- rlPhaseStartTest "semanage_root, semanage_test_root"`
		`- rlRun "./test_root init"`
		`- rlRun "./test_root handle"`
		`- rlRun "./test_root conn"`
		`- rlRun "./test_root init /somepath"`
		`- rlRun "./test_root handle /somepath"`
		`- rlRun "./test_root conn /somepath"`
		`- rlPhaseEnd`
		`- fi`
		`-`
		`- rlPhaseStartTest "semanage_handle_create, semanage_handle_destroy"`
		`- rlRun "./test_handle_create init"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_access_check"`
		`- rlRun "./test_access_check init" $ERR_ABORT`
		`- rlRun "./test_access_check handle 2"`
		`- rlRun "./test_access_check conn 2"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_is_managed"`
		`- rlRun "./test_is_managed init" $ERR_ABORT`
		`- rlRun "./test_is_managed handle 1"`
		`- rlRun "./test_is_managed conn" $ERR_FAIL`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_connect, semanage_disconnect"`
		`- rlRun "./test_connect init" $ERR_ABORT`
		`- rlRun "./test_connect init reversed" $ERR_ABORT`
		`- rlRun "./test_connect handle"`
		`- rlRun "./test_connect handle twice"`
		`- rlRun "./test_connect handle reversed" $ERR_ABORT`
		`- # why does it work??`
		`- rlRun "./test_connect conn"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_is_connected"`
		`- rlRun "./test_is_connected init" $ERR_ABORT`
		`- rlRun "./test_is_connected handle 0"`
		`- rlRun "./test_is_connected conn 1"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_mls_enabled"`
		`- rlRun "./test_mls_enabled init" $ERR_ABORT`
		`- rlRun "./test_mls_enabled handle" $ERR_ABORT`
		`- rlRun "./test_mls_enabled conn 1"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_begin_transaction, semanage_commit"`
		`- rlRun "./test_transaction init" $ERR_ABORT`
		`- rlRun "./test_transaction init reversed" $ERR_ABORT`
		`- rlRun "./test_transaction handle" $ERR_ABORT`
		`- rlRun "./test_transaction handle reversed" $ERR_ABORT`
		`- rlRun "./test_transaction conn"`
		`- rlRun "./test_transaction conn twice"`
		`- rlRun "./test_transaction conn reversed" $ERR_FAIL`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartCleanup`
		`- rlRun "rm -f output test_root test_handle_create test_access_check \`
		`- test_is_managed test_connect test_is_connected \`
		`- test_mls_enabled test_transaction"`
		`- rlPhaseEnd`
		`- rlJournalPrintText`
		`- rlJournalEnd`

tests/semanage-handle-functions/test_access_check.c

file removed

-32

		`@@ -1,32 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`-`
		`- if (argc < 2)`
		`- exit(1);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- int result = semanage_access_check(sh);`
		`- printf("semanage_access_check(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result < 0 \|\| (result != 0 && result != SEMANAGE_CAN_READ`
		`- && result != SEMANAGE_CAN_WRITE)) {`
		`- perror("semanage_access_check");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 3)`
		`- check_result_int(argv[2], result);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-handle-functions/test_connect.c

file removed

-33

		`@@ -1,33 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`-`
		`- if (argc < 2)`
		`- exit(1);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- if (argc >= 3 && strcmp(argv[2], "reversed") == 0) {`
		`- test_disconnect(sh);`
		`- test_connect(sh);`
		`- }`
		`- else {`
		`- test_connect(sh);`
		`- test_disconnect(sh);`
		`- }`
		`-`
		`- if (argc >= 3 && strcmp(argv[2], "twice") == 0) {`
		`- test_disconnect(sh);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-handle-functions/test_handle_create.c

file removed

-15

		`@@ -1,15 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh = test_handle_create();`
		`-`
		`- semanage_handle_destroy(sh);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-handle-functions/test_is_connected.c

file removed

-32

		`@@ -1,32 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- int result;`
		`-`
		`- if (argc < 2)`
		`- exit(1);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- result = semanage_is_connected(sh);`
		`- printf("semanage_is_connected(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0 && result != 1) {`
		`- perror("semanage_is_connected");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 3)`
		`- check_result_int(argv[2], result);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-handle-functions/test_is_managed.c

file removed

-32

		`@@ -1,32 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- int result;`
		`-`
		`- if (argc < 2)`
		`- exit(1);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- result = semanage_is_managed(sh);`
		`- printf("semanage_is_managed(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0 && result != 1) {`
		`- perror("semanage_is_managed");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 3)`
		`- check_result_int(argv[2], result);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-handle-functions/test_mls_enabled.c

file removed

-32

		`@@ -1,32 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- int result;`
		`-`
		`- if (argc < 2)`
		`- exit(1);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- result = semanage_mls_enabled(sh);`
		`- printf("semanage_mls_enabled(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0 && result != 1) {`
		`- perror("semanage_mls_enabled");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 4)`
		`- check_result_int(argv[3], result);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-handle-functions/test_root.c

file removed

-53

		`@@ -1,53 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- const char *root;`
		`- int result;`
		`-`
		`- if (argc < 2)`
		`- exit(1);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- root = semanage_root();`
		`- printf("semanage_root(): %s\n", root);`
		`-`
		`- if (root == NULL) {`
		`- perror("semanage_root");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 3) {`
		`- result = semanage_set_root(argv[2]);`
		`- printf("semanage_set_root(\"%s\"): %d\n", argv[2], result);`
		`-`
		`- if (root == NULL) {`
		`- perror("semanage_set_root");`
		`- exit(1);`
		`- }`
		`-`
		`- root = semanage_root();`
		`- printf("semanage_root(): %s\n", root);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_root");`
		`- exit(1);`
		`- }`
		`-`
		`- if (strcmp(root, argv[2]) != 0) {`
		`- fprintf(stderr, "Expected \"%s\" but got \"%s\"\n", argv[2], root);`
		`- exit(1);`
		`- }`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-handle-functions/test_transaction.c

file removed

-34

		`@@ -1,34 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`-`
		`- if (argc < 2)`
		`- exit(1);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- if (argc >= 3 && strcmp(argv[2], "reversed") == 0) {`
		`- test_commit(sh);`
		`- test_begin_transaction(sh);`
		`- }`
		`- else if (argc >= 3 && strcmp(argv[2], "twice") == 0) {`
		`- test_begin_transaction(sh);`
		`- test_begin_transaction(sh);`
		`- test_commit(sh);`
		`- }`
		`- else {`
		`- test_begin_transaction(sh);`
		`- test_commit(sh);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/Makefile

file removed

-63

		`@@ -1,63 +0,0 @@`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Makefile of /CoreOS/libsemanage/Sanity/semanage-seuser-functions`
		`- # Description: Test semanage_seuser_* functions`
		`- # Author: Jan Zarsky <jzarsky@redhat.com>`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Copyright (c) 2017 Red Hat, Inc.`
		`- #`
		`- # This program is free software: you can redistribute it and/or`
		`- # modify it under the terms of the GNU General Public License as`
		`- # published by the Free Software Foundation, either version 2 of`
		`- # the License, or (at your option) any later version.`
		`- #`
		`- # This program is distributed in the hope that it will be`
		`- # useful, but WITHOUT ANY WARRANTY; without even the implied`
		`- # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR`
		`- # PURPOSE. See the GNU General Public License for more details.`
		`- #`
		`- # You should have received a copy of the GNU General Public License`
		`- # along with this program. If not, see http://www.gnu.org/licenses/.`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`-`
		`- export TEST=/CoreOS/libsemanage/Sanity/semanage-seuser-functions`
		`- export TESTVERSION=1.0`
		`-`
		`- BUILT_FILES=`
		`-`
		`- FILES=$(METADATA) runtest.sh Makefile PURPOSE functions.c test_*.c`
		`-`
		`- .PHONY: all install download clean`
		`-`
		`- run: $(FILES) build`
		`- ./runtest.sh`
		`-`
		`- build: $(BUILT_FILES)`
		`- test -x runtest.sh \|\| chmod a+x runtest.sh`
		`-`
		`- clean:`
		`- rm -f *~ $(BUILT_FILES)`
		`-`
		`-`
		`- include /usr/share/rhts/lib/rhts-make.include`
		`-`
		`- $(METADATA): Makefile`
		`- @echo "Owner: Jan Zarsky <jzarsky@redhat.com>" > $(METADATA)`
		`- @echo "Name: $(TEST)" >> $(METADATA)`
		`- @echo "TestVersion: $(TESTVERSION)" >> $(METADATA)`
		`- @echo "Path: $(TEST_DIR)" >> $(METADATA)`
		`- @echo "Description: Test semanage_seuser_* functions" >> $(METADATA)`
		`- @echo "Type: Sanity" >> $(METADATA)`
		`- @echo "TestTime: 5m" >> $(METADATA)`
		`- @echo "RunFor: libsemanage" >> $(METADATA)`
		`- @echo "Requires: libsemanage libsemanage-devel glibc gcc" >> $(METADATA)`
		`- @echo "Priority: Normal" >> $(METADATA)`
		`- @echo "License: GPLv2+" >> $(METADATA)`
		`- @echo "Confidential: no" >> $(METADATA)`
		`- @echo "Destructive: no" >> $(METADATA)`
		`- @echo "Releases: -RHEL4 -RHELClient5 -RHELServer5" >> $(METADATA)`
		`-`
		`- rhts-lint $(METADATA)`

tests/semanage-seuser-functions/PURPOSE

file removed

-3

		`@@ -1,3 +0,0 @@`
		`- PURPOSE of /CoreOS/libsemanage/Sanity/semanage-seuser-functions`
		`- Description: Test semanage_seuser_* functions`
		`- Author: Jan Zarsky <jzarsky@redhat.com>`

tests/semanage-seuser-functions/functions.c

file removed

-263

		`@@ -1,263 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- void check_result_int(const char *expected, int real) {`
		`- int exp = strtol(expected, NULL, 10);`
		`-`
		`- if (exp != real) {`
		`- fprintf(stderr, "Expected %d but got %d\n", exp, real);`
		`- exit(1);`
		`- }`
		`- }`
		`-`
		`- semanage_handle_t *test_handle_create() {`
		`- semanage_handle_t *sh = NULL;`
		`-`
		`- sh = semanage_handle_create();`
		`- printf("semanage_handle_create(): %p\n", (void *) sh);`
		`-`
		`- if (sh == NULL) {`
		`- perror("semanage_handle_create");`
		`- exit(2);`
		`- }`
		`-`
		`- return sh;`
		`- }`
		`-`
		`- int test_connect(semanage_handle_t *sh) {`
		`- int result = semanage_connect(sh);`
		`- printf("semanage_connect(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_connect");`
		`- exit(2);`
		`- }`
		`-`
		`- return result;`
		`- }`
		`-`
		`- int test_disconnect(semanage_handle_t *sh) {`
		`- int result = semanage_disconnect(sh);`
		`- printf("semanage_disconnect(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_disconnect");`
		`- exit(2);`
		`- }`
		`-`
		`- return result;`
		`- }`
		`-`
		`- int test_begin_transaction(semanage_handle_t *sh) {`
		`- int result = semanage_begin_transaction(sh);`
		`- printf("semanage_begin_transaction(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_begin_transaction");`
		`- exit(2);`
		`- }`
		`-`
		`- return result;`
		`- }`
		`-`
		`- int test_commit(semanage_handle_t *sh) {`
		`- int result = semanage_commit(sh);`
		`- printf("semanage_commit(%p): %d\n", (void *) sh, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_commit");`
		`- exit(2);`
		`- }`
		`-`
		`- return result;`
		`- }`
		`-`
		`- semanage_seuser_key_t test_get_key(semanage_handle_t sh, const char *name) {`
		`- semanage_seuser_key_t *key;`
		`- int result = semanage_seuser_key_create(sh, name, &key);`
		`- printf("semanage_seuser_key_create(%p, %s, %p): %d\n",`
		`- (void ) sh, name, (void ) &key, result);`
		`-`
		`- if (key == NULL \|\| result < 0) {`
		`- perror("semanage_seuser_key_create");`
		`- exit(2);`
		`- }`
		`-`
		`- return key;`
		`- }`
		`-`
		`- semanage_seuser_t test_get_seuser_nth(semanage_handle_t sh, unsigned int index) {`
		`- int result;`
		`- semanage_seuser_t **records;`
		`- unsigned int count;`
		`-`
		`- result = semanage_seuser_list(sh, &records, &count);`
		`- printf("semanage_seuser_list(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) &records, (void *) &count, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_list");`
		`- exit(2);`
		`- }`
		`-`
		`- if (count < index + 1)`
		`- exit(2);`
		`-`
		`- return records[index];`
		`- }`
		`-`
		`- semanage_seuser_t test_get_seuser_new(semanage_handle_t sh) {`
		`- int result;`
		`- semanage_seuser_t *seuser;`
		`-`
		`- result = semanage_seuser_create(sh, &seuser);`
		`- printf("semanage_seuser_create(%p, %p): %d\n",`
		`- (void ) sh, (void ) seuser, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_create");`
		`- exit(2);`
		`- }`
		`-`
		`- return seuser;`
		`- }`
		`-`
		`- semanage_seuser_t test_get_seuser(semanage_handle_t sh, const char *param) {`
		`- if (strcmp(param, "new") == 0)`
		`- return test_get_seuser_new(sh);`
		`-`
		`- if (strcmp(param, "first") == 0)`
		`- return test_get_seuser_nth(sh, 0);`
		`-`
		`- if (strcmp(param, "second") == 0)`
		`- return test_get_seuser_nth(sh, 1);`
		`-`
		`- fprintf(stderr, "Unknown seuser \"%s\" specified\n", param);`
		`- exit(2);`
		`- }`
		`-`
		`- void test_add_local_seuser(semanage_handle_t sh, semanage_seuser_t seuser) {`
		`- int result;`
		`- semanage_seuser_key_t *key;`
		`-`
		`- result = semanage_seuser_key_extract(sh, seuser, &key);`
		`- printf("semanage_seuser_key_extract(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) seuser, (void *) &key, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_key_extract");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_modify_local(sh, key, seuser);`
		`- printf("semanage_seuser_modify_local(%p, %p, %p): %d\n",`
		`- (void ) seuser, (void ) key, (void *) seuser, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_modify_local");`
		`- exit(2);`
		`- }`
		`- }`
		`-`
		`- void test_del_local_seuser(semanage_handle_t sh, semanage_seuser_t seuser) {`
		`- int result;`
		`- semanage_seuser_key_t *key;`
		`-`
		`- result = semanage_seuser_key_extract(sh, seuser, &key);`
		`- printf("semanage_seuser_key_extract(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) seuser, (void *) &key, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_key_extract");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_del_local(sh, key);`
		`- printf("semanage_seuser_del_local(%p, %p): %d\n",`
		`- (void ) seuser, (void ) key, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_del_local");`
		`- exit(2);`
		`- }`
		`- }`
		`-`
		`- #define STATE_INIT 1`
		`- #define STATE_HANDLE 2`
		`- #define STATE_CONN 3`
		`- #define STATE_TRANS 4`
		`-`
		`- int get_state(const char *state_str) {`
		`- if (strcmp(state_str, "init") == 0)`
		`- return STATE_INIT;`
		`- if (strcmp(state_str, "handle") == 0)`
		`- return STATE_HANDLE;`
		`- if (strcmp(state_str, "conn") == 0)`
		`- return STATE_CONN;`
		`- if (strcmp(state_str, "trans") == 0)`
		`- return STATE_TRANS;`
		`-`
		`- return 0;`
		`- }`
		`-`
		`- semanage_handle_t * get_handle(const char *state_str) {`
		`- int state;`
		`- semanage_handle_t *sh = NULL;`
		`-`
		`- state = get_state(state_str);`
		`-`
		`- if (state >= STATE_INIT)`
		`- sh = NULL;`
		`-`
		`- if (state >= STATE_HANDLE)`
		`- sh = test_handle_create();`
		`-`
		`- if (state >= STATE_CONN)`
		`- test_connect(sh);`
		`-`
		`- if (state >= STATE_TRANS)`
		`- test_begin_transaction(sh);`
		`-`
		`- return sh;`
		`- }`
		`-`
		`- void destroy_handle(semanage_handle_t sh, const char state_str) {`
		`- int state;`
		`-`
		`- state = get_state(state_str);`
		`-`
		`- if (state >= STATE_TRANS)`
		`- test_commit(sh);`
		`-`
		`- if (state >= STATE_CONN)`
		`- test_disconnect(sh);`
		`-`
		`- if (state >= STATE_HANDLE) {`
		`- semanage_handle_destroy(sh);`
		`- printf("semanage_handle_destroy(%p)\n", (void *) sh);`
		`- }`
		`- }`
		`-`
		`- int strcmp_null(const char str1, const char str2) {`
		`- if (str1 == NULL && str2 == NULL)`
		`- return 0;`
		`-`
		`- if (str1 == NULL) {`
		`- if (strcmp(str2, "NULL") == 0)`
		`- return 0;`
		`- else`
		`- return -1;`
		`- }`
		`-`
		`- if (str2 == NULL) {`
		`- if (strcmp(str1, "NULL") == 0)`
		`- return 0;`
		`- else`
		`- return 1;`
		`- }`
		`-`
		`- return strcmp(str1, str2);`
		`- }`

tests/semanage-seuser-functions/runtest.sh

file removed

-255

		`@@ -1,255 +0,0 @@`
		`- #!/bin/bash`
		`- # vim: dict+=/usr/share/beakerlib/dictionary.vim cpt=.,w,b,u,t,i,k`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # runtest.sh of /CoreOS/libsemanage/Sanity/semanage-seuser-functions`
		`- # Description: Test semanage_seuser_* functions`
		`- # Author: Jan Zarsky <jzarsky@redhat.com>`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Copyright (c) 2017 Red Hat, Inc.`
		`- #`
		`- # This program is free software: you can redistribute it and/or`
		`- # modify it under the terms of the GNU General Public License as`
		`- # published by the Free Software Foundation, either version 2 of`
		`- # the License, or (at your option) any later version.`
		`- #`
		`- # This program is distributed in the hope that it will be`
		`- # useful, but WITHOUT ANY WARRANTY; without even the implied`
		`- # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR`
		`- # PURPOSE. See the GNU General Public License for more details.`
		`- #`
		`- # You should have received a copy of the GNU General Public License`
		`- # along with this program. If not, see http://www.gnu.org/licenses/.`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`-`
		`- # Include Beaker environment`
		`- . /usr/bin/rhts-environment.sh \|\| exit 1`
		`- . /usr/share/beakerlib/beakerlib.sh \|\| exit 1`
		`-`
		`- PACKAGE="libsemanage"`
		`-`
		`- rlJournalStart`
		`- rlPhaseStartSetup`
		`- rlAssertRpm ${PACKAGE}`
		`- rlAssertRpm ${PACKAGE}-devel`
		`- rlAssertRpm "glibc"`
		`- rlAssertRpm "gcc"`
		`-`
		`- for f in test_*.c ; do`
		`- out=$(echo -n $f \| cut -d'.' -f1)`
		`- rlRun "gcc $f -o $out -lsemanage -Wall -Wextra -Werror -std=c99"`
		`- done`
		`-`
		`- POLICY_TYPE="$(grep -E '^SELINUXTYPE=' /etc/selinux/config \| cut -d'=' -f2 \| tr '[:upper:]' '[:lower:]' \| tr -d ' ')"`
		`-`
		`- if rlIsFedora; then`
		`- SEUSERS_PATH="/var/lib/selinux/$POLICY_TYPE/active/seusers"`
		`- elif rlIsRHEL '>=7'; then`
		`- SEUSERS_PATH="/etc/selinux/$POLICY_TYPE/active/seusers"`
		`- else`
		`- SEUSERS_PATH="/etc/selinux/$POLICY_TYPE/seusers"`
		`- fi`
		`-`
		`- rlRun "cat $SEUSERS_PATH"`
		`-`
		`- SEUSERS_COUNT="$(cat $SEUSERS_PATH \| grep -vE '^#\|^$' \| wc -l)"`
		`- rlRun "[[ \"$SEUSERS_COUNT\" -gt 0 ]]"`
		`-`
		`- SEUSERS="$(cat $SEUSERS_PATH \| grep -vE '^#\|^$' \| cut -d':' -f1 \| tr '\n' ' ')"`
		`- rlRun "[[ -n \"$SEUSERS\" ]]"`
		`-`
		`- first_line="$(cat $SEUSERS_PATH \| grep -vE '^#\|^$' \| head -n 1)"`
		`- SEUSER="$(echo -n $first_line \| cut -d':' -f1)"`
		`- rlRun "[[ -n \"$SEUSER\" ]]"`
		`- SEUSER_SENAME="$(echo -n $first_line \| cut -d':' -f2)"`
		`- rlRun "[[ -n \"$SEUSER_SENAME\" ]]"`
		`- SEUSER_MLSRANGE="$(echo -n $first_line \| cut -d':' -f3-4)"`
		`- rlRun "[[ -n \"$SEUSER_MLSRANGE\" ]]"`
		`-`
		`- SEUSER_NONEXISTENT="nonuser"`
		`- SEUSER_DEFAULT="__default__"`
		`-`
		`- ERR_FAIL=1`
		`- ERR_ABORT=134`
		`- ERR_SEGFAULT=139`
		`-`
		`- # note: each test_*.c program takes first argument which specifies setup`
		`- # before executing specified function`
		`- # init semanage handle == NULL`
		`- # handle semanage handle obtained via semanage_handle_create`
		`- # conn connected via semanage_connect`
		`- # trans inside transaction, via semanage_begin_transaction`
		`- # program returns 1 on error in function, 2 on error in setup`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_key_create, semanage_seuser_key_free"`
		`- # FIXME`
		`- # rlRun "./test_key_create init $SEUSER" $ERR_ABORT,$ERR_SEGFAULT`
		`- # rlRun "./test_key_create handle $SEUSER" $ERR_FAIL`
		`- rlRun "./test_key_create conn $SEUSER"`
		`- rlRun "./test_key_create trans $SEUSER"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_key_extract"`
		`- # FIXME`
		`- #rlRun "./test_key_extract conn new"`
		`- rlRun "./test_key_extract conn first"`
		`- # FIXME`
		`- #rlRun "./test_key_extract trans new"`
		`- rlRun "./test_key_extract trans first"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_compare"`
		`- rlRun "./test_compare conn $SEUSER same"`
		`- rlRun "./test_compare conn $SEUSER_NONEXISTENT different"`
		`- rlRun "./test_compare trans $SEUSER same"`
		`- rlRun "./test_compare trans $SEUSER_NONEXISTENT different"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_compare2"`
		`- rlRun "./test_compare2 conn NULL 0" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_compare2 conn 0 NULL" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_compare2 conn NULL NULL" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_compare2 conn 0 0"`
		`- rlRun "./test_compare2 conn 0 1"`
		`- rlRun "./test_compare2 trans NULL 0" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_compare2 trans 0 NULL" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_compare2 trans NULL NULL" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_compare2 trans 0 0"`
		`- rlRun "./test_compare2 trans 0 1"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_count"`
		`- rlRun "./test_count init" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_count handle" $ERR_FAIL`
		`- rlRun "./test_count conn $SEUSERS_COUNT"`
		`- rlRun "./test_count trans $SEUSERS_COUNT"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_list"`
		`- rlRun "./test_list init" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_list handle" $ERR_FAIL`
		`- rlRun "./test_list conn $SEUSERS_COUNT $SEUSERS"`
		`- rlRun "./test_list trans $SEUSERS_COUNT $SEUSERS"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_iterate"`
		`- rlRun "./test_iterate init" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_iterate handle" $ERR_FAIL`
		`- rlRun "./test_iterate conn $SEUSERS"`
		`- rlRun "./test_iterate trans $SEUSERS"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_exists"`
		`- rlRun "./test_exists conn $SEUSER_NONEXISTENT 0"`
		`- rlRun "./test_exists conn $SEUSER_DEFAULT 1"`
		`- rlRun "./test_exists conn $USER 1"`
		`- rlRun "./test_exists trans $SEUSER_NONEXISTENT 0"`
		`- rlRun "./test_exists trans $SEUSER_DEFAULT 1"`
		`- rlRun "./test_exists trans $SEUSER 1"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_query"`
		`- rlRun "./test_query conn $SEUSER_NONEXISTENT" $ERR_FAIL`
		`- rlRun "./test_query conn $SEUSER_DEFAULT"`
		`- rlRun "./test_query conn $SEUSER"`
		`- rlRun "./test_query trans $SEUSER_NONEXISTENT" $ERR_FAIL`
		`- rlRun "./test_query trans $SEUSER_DEFAULT"`
		`- rlRun "./test_query trans $SEUSER"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_get_name"`
		`- rlRun "./test_get_name conn new NULL"`
		`- rlRun "./test_get_name conn first $SEUSER"`
		`- rlRun "./test_get_name trans new NULL"`
		`- rlRun "./test_get_name trans first $SEUSER"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_set_name"`
		`- name="someuser"`
		`- rlRun "./test_set_name conn $name"`
		`- rlRun "./test_set_name trans $name"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_get_sename"`
		`- rlRun "./test_get_sename conn new NULL"`
		`- rlRun "./test_get_sename conn first $SEUSER_SENAME"`
		`- rlRun "./test_get_sename trans new NULL"`
		`- rlRun "./test_get_sename trans first $SEUSER_SENAME"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_set_sename"`
		`- sename="someuser_u"`
		`- rlRun "./test_set_sename conn $sename"`
		`- rlRun "./test_set_sename trans $sename"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_get_mlsrange"`
		`- rlRun "./test_get_mlsrange conn new NULL"`
		`- rlRun "./test_get_mlsrange conn first $SEUSER_MLSRANGE"`
		`- rlRun "./test_get_mlsrange trans new NULL"`
		`- rlRun "./test_get_mlsrange trans first $SEUSER_MLSRANGE"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_set_mlsrange"`
		`- mlsrange="c0-s1:c0.c42"`
		`- rlRun "./test_set_mlsrange conn $mlsrange"`
		`- rlRun "./test_set_mlsrange trans $mlsrange"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_clone"`
		`- # FIXME`
		`- #rlRun "./test_clone conn new"`
		`- rlRun "./test_clone conn first"`
		`- # FIXME`
		`- #rlRun "./test_clone trans new"`
		`- rlRun "./test_clone trans first"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_create"`
		`- # FIXME`
		`- #rlRun "./test_create init" $ERR_ABORT,$ERR_SEGFAULT`
		`- #rlRun "./test_create handle" $ERR_ABORT,$ERR_SEGFAULT`
		`- rlRun "./test_create conn"`
		`- rlRun "./test_create trans"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_modify_local"`
		`- # function requires transaction`
		`- #rlRun "./test_modify_local conn new" $ERR_FAIL`
		`- #rlRun "./test_modify_local conn first" $ERR_FAIL`
		`- #rlRun "./test_modify_local trans new" $ERR_FAIL`
		`- rlRun "./test_modify_local trans first"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_del_local"`
		`- # adding local seuser requires transaction`
		`- # FIXME`
		`- #rlRun "./test_del_local trans first new"`
		`- #rlRun "./test_del_local trans first second"`
		`- rlRun "./test_del_local trans first first"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_exists_local"`
		`- # adding local seuser requires transaction`
		`- rlRun "./test_exists_local trans first first 1"`
		`- rlRun "./test_exists_local trans first second 0"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "semanage_seuser_count_local"`
		`- # adding local seuser requires transaction`
		`- # FIXME`
		`- #rlRun "./test_count_local trans 0"`
		`- rlRun "./test_count_local trans 1"`
		`- rlRun "./test_count_local trans 2"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartCleanup`
		`- testfiles="$(ls -1 test_* \| grep -v '\.c' \| tr '\n' ' ')"`
		`- rlRun "rm -f $testfiles"`
		`- rlPhaseEnd`
		`- rlJournalPrintText`
		`- rlJournalEnd`

tests/semanage-seuser-functions/test_clone.c

file removed

-60

		`@@ -1,60 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- semanage_seuser_t *seuser_clone;`
		`- int result;`
		`- const char *str;`
		`- const char *str_clone;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, argv[2]);`
		`-`
		`- result = semanage_seuser_clone(sh, seuser, &seuser_clone);`
		`- printf("semanage_seuser_clone(%p, %p): %d\n",`
		`- (void ) seuser, (void ) seuser_clone, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_clone");`
		`- exit(1);`
		`- }`
		`-`
		`- str = semanage_seuser_get_name(seuser);`
		`- str_clone = semanage_seuser_get_name(seuser_clone);`
		`-`
		`- if (strcmp(str, str_clone) != 0) {`
		`- fprintf(stderr, "Different in get_name\n");`
		`- exit(1);`
		`- }`
		`-`
		`- str = semanage_seuser_get_sename(seuser);`
		`- str_clone = semanage_seuser_get_sename(seuser_clone);`
		`-`
		`- if (strcmp(str, str_clone) != 0) {`
		`- fprintf(stderr, "Different in get_sename\n");`
		`- exit(1);`
		`- }`
		`-`
		`- str = semanage_seuser_get_mlsrange(seuser);`
		`- str_clone = semanage_seuser_get_mlsrange(seuser_clone);`
		`-`
		`- if (strcmp(str, str_clone) != 0) {`
		`- fprintf(stderr, "Different in get_mlsrange\n");`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_compare.c

file removed

-44

		`@@ -1,44 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- semanage_seuser_key_t *key;`
		`- int result;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, "first");`
		`-`
		`- key = test_get_key(sh, argv[2]);`
		`-`
		`- result = semanage_seuser_compare(seuser, key);`
		`- printf("semanage_seuser_compare(%p, %p): %d\n",`
		`- (void ) seuser, (void ) key, result);`
		`-`
		`- if (argc >= 4) {`
		`- if (strcmp(argv[3], "same") == 0 && result != 0) {`
		`- fprintf(stderr, "Expected same but got different\n");`
		`- exit(1);`
		`- }`
		`- else if (strcmp(argv[3], "different") == 0 && result == 0) {`
		`- fprintf(stderr, "Expected different but got same\n");`
		`- exit(1);`
		`- }`
		`- }`
		`-`
		`- semanage_seuser_key_free(key);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_compare2.c

file removed

-54

		`@@ -1,54 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- semanage_seuser_t *seuser2;`
		`- int result;`
		`- int first = -1;`
		`- int second = -1;`
		`-`
		`- if (argc < 4)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- if (strcmp(argv[2], "NULL") == 0) {`
		`- seuser = NULL;`
		`- }`
		`- else {`
		`- first = strtol(argv[2], NULL, 10);`
		`- seuser = test_get_seuser_nth(sh, first);`
		`- }`
		`-`
		`- if (strcmp(argv[3], "NULL") == 0) {`
		`- seuser2 = NULL;`
		`- }`
		`- else {`
		`- second = strtol(argv[3], NULL, 10);`
		`- seuser2 = test_get_seuser_nth(sh, second);`
		`- }`
		`-`
		`- result = semanage_seuser_compare2(seuser, seuser2);`
		`- printf("semanage_seuser_compare(%p, %p): %d\n",`
		`- (void ) seuser, (void ) seuser2, result);`
		`-`
		`- if (first == second && result != 0) {`
		`- fprintf(stderr, "Expected same but got different\n");`
		`- exit(1);`
		`- }`
		`- else if (first != second && result == 0) {`
		`- fprintf(stderr, "Expected different but got same\n");`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_count.c

file removed

-34

		`@@ -1,34 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- unsigned int response;`
		`- int result;`
		`-`
		`- if (argc < 2)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- result = semanage_seuser_count(sh, &response);`
		`- printf("semanage_seuser_count(%p, %p): %d, response: %u\n",`
		`- (void ) sh, (void ) &response, result, response);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_count");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 3)`
		`- check_result_int(argv[2], response);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_count_local.c

file removed

-46

		`@@ -1,46 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- int result;`
		`- unsigned int response;`
		`- int num;`
		`-`
		`- if (argc < 2)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- num = strtol(argv[2], NULL, 10);`
		`-`
		`- for (int i = 0; i < num; i++) {`
		`- seuser = test_get_seuser_nth(sh, i);`
		`-`
		`- test_add_local_seuser(sh, seuser);`
		`- }`
		`-`
		`- result = semanage_seuser_count_local(sh, &response);`
		`- printf("semanage_seuser_count_local(%p, %p): %d, response: %d\n",`
		`- (void ) sh, (void ) &response, result, response);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_count_local");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 3)`
		`- check_result_int(argv[2], response);`
		`-`
		`- test_del_local_seuser(sh, seuser);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_create.c

file removed

-53

		`@@ -1,53 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- int result;`
		`- const char *str;`
		`-`
		`- if (argc < 2)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- result = semanage_seuser_create(sh, &seuser);`
		`- printf("semanage_seuser_create(%p, %p): %d\n",`
		`- (void ) sh, (void ) seuser, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_create");`
		`- exit(1);`
		`- }`
		`-`
		`- str = semanage_seuser_get_name(seuser);`
		`-`
		`- if (str != NULL) {`
		`- fprintf(stderr, "Expected name == NULL, got %s\n", str);`
		`- exit(1);`
		`- }`
		`-`
		`- str = semanage_seuser_get_sename(seuser);`
		`-`
		`- if (str != NULL) {`
		`- fprintf(stderr, "Expected sename == NULL, got %s\n", str);`
		`- exit(1);`
		`- }`
		`-`
		`- str = semanage_seuser_get_mlsrange(seuser);`
		`-`
		`- if (str != NULL) {`
		`- fprintf(stderr, "Expected mlsrange == NULL, got %s\n", str);`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_del_local.c

file removed

-64

		`@@ -1,64 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- semanage_seuser_t *seuser_del;`
		`- semanage_seuser_key_t *key;`
		`- semanage_seuser_t **records;`
		`- int result;`
		`- unsigned int count;`
		`-`
		`- if (argc < 4)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, argv[2]);`
		`-`
		`- test_add_local_seuser(sh, seuser);`
		`-`
		`- seuser_del = test_get_seuser(sh, argv[3]);`
		`-`
		`- result = semanage_seuser_key_extract(sh, seuser_del, &key);`
		`- printf("semanage_seuser_key_extract(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) seuser_del, (void *) &key, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_key_extract");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_del_local(sh, key);`
		`- printf("semanage_seuser_del_local(%p, %p): %d\n",`
		`- (void ) seuser, (void ) key, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_del_local");`
		`- exit(1);`
		`- }`
		`-`
		`- result = semanage_seuser_list_local(sh, &records, &count);`
		`- printf("semanage_seuser_list_local(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) &records, (void *) &count, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_list_local");`
		`- exit(2);`
		`- }`
		`-`
		`- if (count != 0) {`
		`- fprintf(stderr, "Number of local seusers is not 0!\n");`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_exists.c

file removed

-37

		`@@ -1,37 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_key_t *key;`
		`- int result;`
		`- int response;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- key = test_get_key(sh, argv[2]);`
		`-`
		`- result = semanage_seuser_exists(sh, key, &response);`
		`- printf("semanage_seuser_exists(%p, %p, %p): %d, response: %d\n",`
		`- (void ) sh, (void ) key, (void *) &response, result, response);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_exists");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 4)`
		`- check_result_int(argv[3], response);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_exists_local.c

file removed

-59

		`@@ -1,59 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- semanage_seuser_t *seuser_exists;`
		`- semanage_seuser_key_t *key;`
		`- int result;`
		`- int response;`
		`- int exp;`
		`-`
		`- if (argc < 4)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, argv[2]);`
		`- seuser_exists = test_get_seuser(sh, argv[3]);`
		`-`
		`- test_add_local_seuser(sh, seuser);`
		`-`
		`- result = semanage_seuser_key_extract(sh, seuser_exists, &key);`
		`- printf("semanage_seuser_key_extract(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) seuser_exists, (void *) &key, result);`
		`- if (result < 0) {`
		`- perror("semanage_seuser_key_extract");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_exists_local(sh, key, &response);`
		`- printf("semanage_seuser_exists_local(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) key, (void *) &response, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_exists_local");`
		`- exit(1);`
		`- }`
		`-`
		`- if (argc >= 5) {`
		`- exp = strtol(argv[4], NULL, 10);`
		`-`
		`- if (response != exp) {`
		`- fprintf(stderr, "Expected %d but got %d\n", exp, response);`
		`- exit(1);`
		`- }`
		`- }`
		`-`
		`- test_del_local_seuser(sh, seuser);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_get_mlsrange.c

file removed

-32

		`@@ -1,32 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`-`
		`- if (argc < 4)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, argv[2]);`
		`-`
		`- const char *name = semanage_seuser_get_mlsrange(seuser);`
		`- printf("semanage_seuser_get_mlsrange(%p): %s\n",`
		`- (void *) seuser, name);`
		`-`
		`- if (strcmp_null(argv[3], name) != 0) {`
		`- fprintf(stderr, "Expected %s but got %s\n", argv[2], name);`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_get_name.c

file removed

-32

		`@@ -1,32 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`-`
		`- if (argc < 4)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, argv[2]);`
		`-`
		`- const char *name = semanage_seuser_get_name(seuser);`
		`- printf("semanage_seuser_get_name(%p): %s\n",`
		`- (void *) seuser, name);`
		`-`
		`- if (strcmp_null(argv[3], name) != 0) {`
		`- fprintf(stderr, "Expected %s but got %s\n", argv[2], name);`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_get_sename.c

file removed

-32

		`@@ -1,32 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`-`
		`- if (argc < 4)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, argv[2]);`
		`-`
		`- const char *name = semanage_seuser_get_sename(seuser);`
		`- printf("semanage_seuser_get_sename(%p): %s\n",`
		`- (void *) seuser, name);`
		`-`
		`- if (strcmp_null(argv[3], name) != 0) {`
		`- fprintf(stderr, "Expected %s but got %s\n", argv[2], name);`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_iterate.c

file removed

-49

		`@@ -1,49 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int counter = 0;`
		`-`
		`- int handler(const semanage_seuser_t record, void varg) {`
		`- char args = (char ) varg;`
		`-`
		`- const char *name = semanage_seuser_get_name(record);`
		`-`
		`- if (strcmp(name, args[2 + counter++]) != 0)`
		`- return -1;`
		`-`
		`- return 0;`
		`- }`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- int result;`
		`-`
		`- if (argc < 2)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- char **param = NULL;`
		`-`
		`- if (argc >= 3) {`
		`- param = argv;`
		`- }`
		`-`
		`- result = semanage_seuser_iterate(sh, &handler, (void *) param);`
		`- printf("semanage_seuser_iterate(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) &handler, (void *) param, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_iterate");`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_key_create.c

file removed

-39

		`@@ -1,39 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_key_t *key;`
		`- const char *name;`
		`- int result;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- if (strcmp(argv[2], "NULL") == 0)`
		`- name = NULL;`
		`- else`
		`- name = argv[2];`
		`-`
		`- result = semanage_seuser_key_create(sh, name, &key);`
		`- printf("semanage_seuser_key_create(%p, %s, %p): %d\n",`
		`- (void ) sh, name, (void ) &key, result);`
		`-`
		`- if (result < 0 \|\| key == NULL) {`
		`- perror("semanage_seuser_key_create");`
		`- exit(1);`
		`- }`
		`-`
		`- semanage_seuser_key_free(key);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_key_extract.c

file removed

-45

		`@@ -1,45 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- semanage_seuser_key_t *key;`
		`- int result;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, argv[2]);`
		`-`
		`- result = semanage_seuser_key_extract(sh, seuser, &key);`
		`- printf("semanage_seuser_key_extract(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) seuser, (void *) &key, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_key_extract");`
		`- exit(1);`
		`- }`
		`-`
		`- result = semanage_seuser_compare(seuser, key);`
		`- printf("semanage_seuser_compare(%p, %p): %d\n",`
		`- (void ) seuser, (void ) key, result);`
		`-`
		`- if (result != 0) {`
		`- perror("semanage_seuser_compare");`
		`- exit(1);`
		`- }`
		`-`
		`- semanage_seuser_key_free(key);`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_list.c

file removed

-63

		`@@ -1,63 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t **records;`
		`- unsigned int count;`
		`- int result;`
		`-`
		`- if (argc < 2)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- result = semanage_seuser_list(sh, &records, &count);`
		`- printf("semanage_seuser_list(%p, %p, %p): %d",`
		`- (void ) sh, (void ) &records, (void *) &count, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_list");`
		`- exit(1);`
		`- }`
		`-`
		`- printf(", count: %u, records: ", count);`
		`-`
		`- const char *name;`
		`-`
		`- for (unsigned int i = 0; i < count; i++) {`
		`- name = semanage_seuser_get_name(records[i]);`
		`- printf("%p (%s), ", (void *) records[i], name);`
		`- }`
		`-`
		`- printf("\n");`
		`-`
		`- if (argc >= 3) {`
		`- unsigned int exp_count = strtoul(argv[2], NULL, 10);`
		`-`
		`- if (count != exp_count) {`
		`- printf("Expected %u but got %u\n", exp_count, count);`
		`- exit(1);`
		`- }`
		`-`
		`- const char *name;`
		`-`
		`- for (unsigned int i = 0; i < count; i++) {`
		`- name = semanage_seuser_get_name(records[i]);`
		`-`
		`- if (strcmp(name, argv[3 + i]) != 0) {`
		`- printf("Expected %s but got %s\n", name, argv[3 + i]);`
		`- exit(1);`
		`- }`
		`- }`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_modify_local.c

file removed

-64

		`@@ -1,64 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *seuser;`
		`- semanage_seuser_key_t *key;`
		`- semanage_seuser_t **records;`
		`- int result;`
		`- unsigned int count;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- seuser = test_get_seuser(sh, argv[2]);`
		`-`
		`- result = semanage_seuser_key_extract(sh, seuser, &key);`
		`- printf("semanage_seuser_key_extract(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) seuser, (void *) &key, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_key_extract");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_modify_local(sh, key, seuser);`
		`- printf("semanage_seuser_modify_local(%p, %p, %p): %d\n",`
		`- (void ) seuser, (void ) key, (void *) seuser, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_modify_local");`
		`- exit(1);`
		`- }`
		`-`
		`- result = semanage_seuser_list_local(sh, &records, &count);`
		`- printf("semanage_seuser_list_local(%p, %p, %p): %d\n",`
		`- (void ) sh, (void ) &records, (void *) &count, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_list_local");`
		`- exit(2);`
		`- }`
		`-`
		`- if (count != 1) {`
		`- fprintf(stderr, "Number of local seusers is %u, expected 1!\n", count);`
		`- exit(1);`
		`- }`
		`-`
		`- if (semanage_seuser_compare(records[0], key) != 0) {`
		`- fprintf(stderr, "Local seuser is different!\n");`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_query.c

file removed

-50

		`@@ -1,50 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_key_t *key;`
		`- semanage_seuser_t *response;`
		`- int result;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- result = semanage_seuser_key_create(sh, argv[2], &key);`
		`- printf("semanage_seuser_key_create(%p, %s, %p): %d\n",`
		`- (void ) sh, argv[2], (void ) &key, result);`
		`-`
		`- if (result < 0 \|\| key == NULL) {`
		`- perror("semanage_seuser_key_create");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_query(sh, key, &response);`
		`- printf("semanage_seuser_query(%p, %p, %p): %d, response: %p\n",`
		`- (void ) sh, (void ) key, (void ) &response, result, (void ) response);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_query");`
		`- exit(1);`
		`- }`
		`-`
		`- const char *name = semanage_seuser_get_name(response);`
		`- printf("semanage_seuser_get_name(%p): %s\n",`
		`- (void *) response, name);`
		`-`
		`- if (strcmp(argv[2], name) != 0) {`
		`- perror("semanage_seuser_get_name");`
		`- exit(2);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_set_mlsrange.c

file removed

-62

		`@@ -1,62 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *user;`
		`- int result;`
		`- const char *mlsrange;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- user = test_get_seuser(sh, "first");`
		`-`
		`- if (strcmp(argv[2], "NULL") == 0)`
		`- mlsrange = NULL;`
		`- else`
		`- mlsrange = argv[2];`
		`-`
		`- const char *old_mlsrange = semanage_seuser_get_mlsrange(user);`
		`- printf("semanage_seuser_get_mlsrange(%p): %s\n",`
		`- (void *) user, old_mlsrange);`
		`-`
		`- if (old_mlsrange == NULL) {`
		`- perror("semanage_seuser_get_mlsrange");`
		`- exit(2);`
		`- }`
		`-`
		`- if (strcmp(old_mlsrange, mlsrange) == 0) {`
		`- printf("New mlsrange is the same\n");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_set_mlsrange(sh, user, mlsrange);`
		`- printf("semanage_seuser_set_mlsrange(%p, %p, %s): %d\n",`
		`- (void ) sh, (void ) user, mlsrange, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_set_mlsrange");`
		`- exit(1);`
		`- }`
		`-`
		`- const char *new_mlsrange = semanage_seuser_get_mlsrange(user);`
		`- printf("semanage_seuser_get_mlsrange(%p): %s\n",`
		`- (void *) user, new_mlsrange);`
		`-`
		`- if (strcmp(new_mlsrange, mlsrange) != 0) {`
		`- perror("semanage_seuser_get_mlsrange");`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_set_name.c

file removed

-62

		`@@ -1,62 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *user;`
		`- int result;`
		`- const char *name;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- user = test_get_seuser(sh, "first");`
		`-`
		`- if (strcmp(argv[2], "NULL") == 0)`
		`- name = NULL;`
		`- else`
		`- name = argv[2];`
		`-`
		`- const char *old_name = semanage_seuser_get_name(user);`
		`- printf("semanage_seuser_get_name(%p): %s\n",`
		`- (void *) user, old_name);`
		`-`
		`- if (old_name == NULL) {`
		`- perror("semanage_seuser_get_name");`
		`- exit(2);`
		`- }`
		`-`
		`- if (strcmp(old_name, name) == 0) {`
		`- printf("New name is the same\n");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_set_name(sh, user, name);`
		`- printf("semanage_seuser_set_name(%p, %p, %s): %d\n",`
		`- (void ) sh, (void ) user, name, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_set_name");`
		`- exit(1);`
		`- }`
		`-`
		`- const char *new_name = semanage_seuser_get_name(user);`
		`- printf("semanage_seuser_get_name(%p): %s\n",`
		`- (void *) user, new_name);`
		`-`
		`- if (strcmp(new_name, name) != 0) {`
		`- perror("semanage_seuser_get_name");`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/semanage-seuser-functions/test_set_sename.c

file removed

-62

		`@@ -1,62 +0,0 @@`
		`- #include <stdio.h>`
		`- #include <stdlib.h>`
		`- #include <string.h>`
		`- #include <errno.h>`
		`- #include <semanage/semanage.h>`
		`-`
		`- #include "functions.c"`
		`-`
		`- int main (int argc, char **argv) {`
		`- semanage_handle_t *sh;`
		`- semanage_seuser_t *user;`
		`- int result;`
		`- const char *name;`
		`-`
		`- if (argc < 3)`
		`- exit(2);`
		`-`
		`- sh = get_handle(argv[1]);`
		`-`
		`- user = test_get_seuser(sh, "first");`
		`-`
		`- if (strcmp(argv[2], "NULL") == 0)`
		`- name = NULL;`
		`- else`
		`- name = argv[2];`
		`-`
		`- const char *old_name = semanage_seuser_get_sename(user);`
		`- printf("semanage_seuser_get_sename(%p): %s\n",`
		`- (void *) user, old_name);`
		`-`
		`- if (old_name == NULL) {`
		`- perror("semanage_seuser_get_sename");`
		`- exit(2);`
		`- }`
		`-`
		`- if (strcmp(old_name, name) == 0) {`
		`- printf("New name is the same\n");`
		`- exit(2);`
		`- }`
		`-`
		`- result = semanage_seuser_set_sename(sh, user, name);`
		`- printf("semanage_seuser_set_sename(%p, %p, %s): %d\n",`
		`- (void ) sh, (void ) user, name, result);`
		`-`
		`- if (result < 0) {`
		`- perror("semanage_seuser_set_sename");`
		`- exit(1);`
		`- }`
		`-`
		`- const char *new_name = semanage_seuser_get_sename(user);`
		`- printf("semanage_seuser_get_sename(%p): %s\n",`
		`- (void *) user, new_name);`
		`-`
		`- if (strcmp(new_name, name) != 0) {`
		`- perror("semanage_seuser_get_sename");`
		`- exit(1);`
		`- }`
		`-`
		`- destroy_handle(sh, argv[1]);`
		`-`
		`- exit(0);`
		`- }`

tests/verify-options-in-semanage-conf/Makefile

file removed

-64

		`@@ -1,64 +0,0 @@`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Makefile of /CoreOS/libsemanage/Sanity/verify-options-in-semanage-conf`
		`- # Description: Are the verify options in semanage.conf honored?`
		`- # Author: Milos Malik <mmalik@redhat.com>`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Copyright (c) 2016 Red Hat, Inc.`
		`- #`
		`- # This copyrighted material is made available to anyone wishing`
		`- # to use, modify, copy, or redistribute it subject to the terms`
		`- # and conditions of the GNU General Public License version 2.`
		`- #`
		`- # This program is distributed in the hope that it will be`
		`- # useful, but WITHOUT ANY WARRANTY; without even the implied`
		`- # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR`
		`- # PURPOSE. See the GNU General Public License for more details.`
		`- #`
		`- # You should have received a copy of the GNU General Public`
		`- # License along with this program; if not, write to the Free`
		`- # Software Foundation, Inc., 51 Franklin Street, Fifth Floor,`
		`- # Boston, MA 02110-1301, USA.`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`-`
		`- export TEST=/CoreOS/libsemanage/Sanity/verify-options-in-semanage-conf`
		`- export TESTVERSION=1.0`
		`-`
		`- BUILT_FILES=`
		`-`
		`- FILES=$(METADATA) runtest.sh Makefile PURPOSE empty.te`
		`-`
		`- .PHONY: all install download clean`
		`-`
		`- run: $(FILES) build`
		`- ./runtest.sh`
		`-`
		`- build: $(BUILT_FILES)`
		`- test -x runtest.sh \|\| chmod a+x runtest.sh`
		`-`
		`- clean:`
		`- rm -f *~ $(BUILT_FILES)`
		`-`
		`- include /usr/share/rhts/lib/rhts-make.include`
		`-`
		`- $(METADATA): Makefile`
		`- @echo "Owner: Milos Malik <mmalik@redhat.com>" > $(METADATA)`
		`- @echo "Name: $(TEST)" >> $(METADATA)`
		`- @echo "TestVersion: $(TESTVERSION)" >> $(METADATA)`
		`- @echo "Path: $(TEST_DIR)" >> $(METADATA)`
		`- @echo "Description: Are the verify options in semanage.conf honored?" >> $(METADATA)`
		`- @echo "Type: Sanity" >> $(METADATA)`
		`- @echo "TestTime: 10m" >> $(METADATA)`
		`- @echo "RunFor: libsemanage" >> $(METADATA)`
		`- @echo "Requires: libselinux libselinux-utils libsemanage policycoreutils policycoreutils-python selinux-policy selinux-policy-devel" >> $(METADATA)`
		`- @echo "Priority: Normal" >> $(METADATA)`
		`- @echo "License: GPLv2" >> $(METADATA)`
		`- @echo "Confidential: no" >> $(METADATA)`
		`- @echo "Destructive: no" >> $(METADATA)`
		`- @echo "Releases: -RHEL4 -RHELClient5 -RHELServer5" >> $(METADATA)`
		`-`
		`- rhts-lint $(METADATA)`
		`-`

tests/verify-options-in-semanage-conf/PURPOSE

file removed

-9

		`@@ -1,9 +0,0 @@`
		`- PURPOSE of /CoreOS/libsemanage/Sanity/verify-options-in-semanage-conf`
		`- Author: Milos Malik <mmalik@redhat.com>`
		`-`
		`- Are the verify options in semanage.conf honored?`
		`- Tested options: verify kernel, verify module, verify linked`
		`- Tested tools: semodule, semanage`
		`- Positive and negative cases are tested.`
		`- Original information found at http://selinuxproject.org/page/PolicyValidate`
		`-`

tests/verify-options-in-semanage-conf/empty.te

file removed

-2

		`@@ -1,2 +0,0 @@`
		`- policy_module(empty,1.0)`
		`-`

tests/verify-options-in-semanage-conf/runtest.sh

file removed

-142

		`@@ -1,142 +0,0 @@`
		`- #!/bin/bash`
		`- # vim: dict+=/usr/share/beakerlib/dictionary.vim cpt=.,w,b,u,t,i,k`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # runtest.sh of /CoreOS/libsemanage/Sanity/verify-options-in-semanage-conf`
		`- # Description: Are the verify options in semanage.conf honored?`
		`- # Author: Milos Malik <mmalik@redhat.com>`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`- #`
		`- # Copyright (c) 2016 Red Hat, Inc.`
		`- #`
		`- # This copyrighted material is made available to anyone wishing`
		`- # to use, modify, copy, or redistribute it subject to the terms`
		`- # and conditions of the GNU General Public License version 2.`
		`- #`
		`- # This program is distributed in the hope that it will be`
		`- # useful, but WITHOUT ANY WARRANTY; without even the implied`
		`- # warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR`
		`- # PURPOSE. See the GNU General Public License for more details.`
		`- #`
		`- # You should have received a copy of the GNU General Public`
		`- # License along with this program; if not, write to the Free`
		`- # Software Foundation, Inc., 51 Franklin Street, Fifth Floor,`
		`- # Boston, MA 02110-1301, USA.`
		`- #`
		`- # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
		`-`
		`- # Include Beaker environment`
		`- . /usr/bin/rhts-environment.sh \|\| exit 1`
		`- . /usr/share/beakerlib/beakerlib.sh \|\| exit 1`
		`-`
		`- PACKAGE="libsemanage"`
		`- MODULE_NAME="empty"`
		`- SEMANAGE_CONF="/etc/selinux/semanage.conf"`
		`-`
		`- rlJournalStart`
		`- rlPhaseStartSetup`
		`- rlAssertRpm ${PACKAGE}`
		`- rlAssertRpm policycoreutils`
		`- rlAssertRpm selinux-policy`
		`- rlFileBackup ${SEMANAGE_CONF}`
		`- rlRun "rpm -qf /usr/sbin/semanage"`
		`- rlRun "grep -v -e '^#' -e '^$' ${SEMANAGE_CONF}"`
		- OUTPUT_FILE=`mktemp`
		`-`
		`- rlRun "setenforce 1"`
		`- rlRun "sestatus"`
		`- rlRun "ls -l ${MODULE_NAME}.te"`
		`- rlRun "make -f /usr/share/selinux/devel/Makefile"`
		`- rlRun "ls -l ${MODULE_NAME}.pp"`
		`- rlPhaseEnd`
		`-`
		`- rlLog "positive cases follow"`
		`- # TODO: /bin/true could be replaced a script, which prints the supplied arguments into a file for further inspection`
		`-`
		`- rlPhaseStartTest "verify kernel"`
		`- rlRun "semodule -r ${MODULE_NAME}" 0,1`
		`- rlFileRestore`
		`- rlRun "echo -en '[verify kernel]\npath = /bin/true\nargs = \$@\n[end]\n' >> ${SEMANAGE_CONF}"`
		`- rlRun "semodule -i ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertNotGrep "semodule.*failed" ${OUTPUT_FILE} -i`
		`- rlRun "semodule -l \| grep ${MODULE_NAME}"`
		`- rlRun "semanage module -a ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertNotGrep "could not commit semanage transaction\|no such file or directory" ${OUTPUT_FILE} -Ei`
		`- rlRun "semanage module -l \| grep ${MODULE_NAME}"`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "verify module"`
		`- rlRun "semodule -r ${MODULE_NAME}" 0,1`
		`- rlFileRestore`
		`- rlRun "echo -en '[verify module]\npath = /bin/true\nargs = \$@\n[end]\n' >> ${SEMANAGE_CONF}"`
		`- rlRun "semodule -i ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertNotGrep "semodule.*failed" ${OUTPUT_FILE} -i`
		`- rlRun "semodule -l \| grep ${MODULE_NAME}"`
		`- rlRun "semanage module -a ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertNotGrep "could not commit semanage transaction\|no such file or directory" ${OUTPUT_FILE} -Ei`
		`- rlRun "semanage module -l \| grep ${MODULE_NAME}"`
		`- rlPhaseEnd`
		`-`
		`- if rlIsRHEL '<7.3' ; then # because "[verify linked]" was dropped`
		`- rlPhaseStartTest "verify linked"`
		`- rlRun "semodule -r ${MODULE_NAME}" 0,1`
		`- rlFileRestore`
		`- rlRun "echo -en '[verify linked]\npath = /bin/true\nargs = \$@\n[end]\n' >> ${SEMANAGE_CONF}"`
		`- rlRun "semodule -i ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertNotGrep "semodule.*failed" ${OUTPUT_FILE} -i`
		`- rlRun "semodule -l \| grep ${MODULE_NAME}"`
		`- rlRun "semanage module -a ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertNotGrep "could not commit semanage transaction\|no such file or directory" ${OUTPUT_FILE} -Ei`
		`- rlRun "semanage module -l \| grep ${MODULE_NAME}"`
		`- rlPhaseEnd`
		`- fi`
		`-`
		`- rlLog "negative cases follow"`
		`- # TODO: /bin/false could be replaced a script, which prints the supplied arguments into a file for further inspection`
		`-`
		`- rlPhaseStartTest "verify kernel"`
		`- rlRun "semodule -r ${MODULE_NAME}" 0,1`
		`- rlFileRestore`
		`- rlRun "echo -en '[verify kernel]\npath = /bin/false\nargs = \$@\n[end]\n' >> ${SEMANAGE_CONF}"`
		`- rlRun "semodule -i ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertGrep "semodule.*failed" ${OUTPUT_FILE} -i`
		`- rlRun "semodule -l \| grep ${MODULE_NAME}" 1`
		`- rlRun "semanage module -a ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertGrep "could not commit semanage transaction\|no such file or directory" ${OUTPUT_FILE} -Ei`
		`- rlRun "semanage module -l \| grep ${MODULE_NAME}" 1`
		`- rlPhaseEnd`
		`-`
		`- rlPhaseStartTest "verify module"`
		`- rlRun "semodule -r ${MODULE_NAME}" 0,1`
		`- rlFileRestore`
		`- rlRun "echo -en '[verify module]\npath = /bin/false\nargs = \$@\n[end]\n' >> ${SEMANAGE_CONF}"`
		`- rlRun "semodule -i ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertGrep "semodule.*failed" ${OUTPUT_FILE} -i`
		`- rlRun "semodule -l \| grep ${MODULE_NAME}" 1`
		`- rlRun "semanage module -a ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertGrep "could not commit semanage transaction\|no such file or directory" ${OUTPUT_FILE} -Ei`
		`- rlRun "semanage module -l \| grep ${MODULE_NAME}" 1`
		`- rlPhaseEnd`
		`-`
		`- if rlIsRHEL '<7.3' ; then # because "[verify linked]" was dropped`
		`- rlPhaseStartTest "verify linked"`
		`- rlRun "semodule -r ${MODULE_NAME}" 0,1`
		`- rlFileRestore`
		`- rlRun "echo -en '[verify linked]\npath = /bin/false\nargs = \$@\n[end]\n' >> ${SEMANAGE_CONF}"`
		`- rlRun "semodule -i ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertGrep "semodule.*failed" ${OUTPUT_FILE} -i`
		`- rlRun "semodule -l \| grep ${MODULE_NAME}" 1`
		`- rlRun "semanage module -a ${MODULE_NAME}.pp 2>&1 \| tee ${OUTPUT_FILE}"`
		`- rlAssertGrep "could not commit semanage transaction\|no such file or directory" ${OUTPUT_FILE} -Ei`
		`- rlRun "semanage module -l \| grep ${MODULE_NAME}" 1`
		`- rlPhaseEnd`
		`- fi`
		`-`
		`- rlPhaseStartCleanup`
		`- rlRun "rm -f ${MODULE_NAME}.pp ${OUTPUT_FILE}"`
		`- rlFileRestore`
		`- rlPhaseEnd`
		`- rlJournalPrintText`
		`- rlJournalEnd`
		`-`

mmalik commented 2 months ago

TBA later

zuul commented 2 months ago

Build succeeded.
https://fedora.softwarefactory-project.io/zuul/buildset/26a9531b542547a58a4f8037303895fe

check-for-arches : SUCCESS in 1m 41s
check-for-eln : SUCCESS in 18s
eln-rpm-scratch-build : SUCCESS in 10m 09s
rpm-scratch-build : SUCCESS in 9m 26s
rpm-scratch-build-s390x : SUCCESS in 9m 48s (non-voting)
rpm-scratch-build-ppc64le : SUCCESS in 17m 29s (non-voting)
rpm-scratch-build-i686 : SUCCESS in 10m 40s (non-voting)
rpm-scratch-build-aarch64 : SUCCESS in 10m 15s (non-voting)
rpm-linter : FAILURE in 5m 23s (non-voting)
rpm-rpminspect : SUCCESS in 10m 00s (non-voting)
check-for-sti-tests : SUCCESS in 15s
check-for-fmf-tests : SUCCESS in 16s
rpm-install-test : SUCCESS in 1m 15s
rpm-tmt-test : SUCCESS in 36m 36s
Skipped 1 job

mmalik commented 2 months ago

1 test failed because of the following problem:

:: [ 08:11:20 ] :: [  BEGIN   ] :: Running 'podman build -t localhost/selinux . --no-cache'
STEP 1/2: FROM quay.io/centos/centos:stream9
Trying to pull quay.io/centos/centos:stream9...
Error: creating build container: copying system image from manifest list: parsing image configuration: Get "https://cdn03.quay.io/quayio-production-s3/sha256/45/45689e0cee12aefb5288e0753144918fa625f4086a607f83afa6ab43e5c6ed02?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAI5LUAQGPZRPNKSJA%2F20240417%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20240417T081121Z&X-Amz-Expires=600&X-Amz-SignedHeaders=host&X-Amz-Signature=2fbd3c7b9e300fdf74e92ad6565f66e278c6f6cff87484cb938c0989ce6da45e&cf_sign=UW2btn28oy1vcSmUYGvYRF3eWshDM%2Fd22BpMbXp2p74shJSFhfW%2B6wxM9oUmN8EWXDPOTia3tEARIw7K86%2FDzxTAKyzR2wDHoRYQFHbRAt%2BHhITvFr76eXzedXaRcLGAHRb51%2BB0sTAeSE2%2BJakWrf0t2tE8D1IZJ6%2FBGfFCrSrPR8%2F7asu7hvdExxDvlmCk0s1eL%2BWO%2FjrTECQ1NaiGyyU2P0%2FlxHGsQwkTwrRJewDuXZd3sJIdHGEIIUPZK1NMzB218N642pqATWdi6KL8iJnwSOldQUNS1yPNlBkLEPLnasGjr7MhLsfalVDz1AU91UlVjxa8gcdn6GOJ54mFIg%3D%3D&cf_expiry=1713342081&region=us-east-1&namespace=centos": dial tcp: lookup cdn03.quay.io: no such host
:: [ 08:11:21 ] :: [   FAIL   ] :: Command 'podman build -t localhost/selinux . --no-cache' (Expected 0, got 125)

The rest of automated tests passed as expected.