packages/npth
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
npth/add-test-cases.patch
yaowenbin c3ef424080 fix t-socket test case fail 
Signed-off-by: yaowenbin <yaowenbin1@huawei.com>
(cherry picked from commit 5361f26c273f8eb4a123314bf3014dcbd93bd7b3)
2022-09-26 14:37:56 +08:00

785 lines
19 KiB
Diff
Raw Permalink Blame History

From 9ce3797bb45fc360bf0d38a0d28911b1c1ada585 Mon Sep 17 00:00:00 2001
From: yaowenbin <yaowenbin1@huawei.com>
Date: Tue, 1 Mar 2022 08:30:38 +0000
Subject: [PATCH 1/1] add test cases
The following test cases are added to test more interfaces of npth:
t-condlock.c test npth condlock interfaces
t-fork-enhance.c test npth fork interfaces
t-rwlock.c test npth rwlock interfaces
t-signal.c test npth signal interfaces
t-socket.c test npth socket interfaces
Signed-off-by: yaowenbin <yaowenbin1@huawei.com>
---
tests/Makefile.am | 3 +-
tests/t-condlock.c | 106 +++++++++++++++
tests/t-fork-enhance.c | 68 ++++++++++
tests/t-rwlock.c | 196 ++++++++++++++++++++++++++++
tests/t-signal.c | 49 +++++++
tests/t-socket.c | 284 +++++++++++++++++++++++++++++++++++++++++
6 files changed, 705 insertions(+), 1 deletion(-)
create mode 100644 tests/t-condlock.c
create mode 100644 tests/t-fork-enhance.c
create mode 100644 tests/t-rwlock.c
create mode 100644 tests/t-signal.c
create mode 100644 tests/t-socket.c
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 8092a3c..f37e798 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -18,7 +18,7 @@
## Process this file with automake to produce Makefile.in
-TESTS = t-mutex t-thread
+TESTS = t-mutex t-thread t-condlock t-rwlock t-signal t-socket
# We explicitly require POSIX.1-2001 so that pthread_rwlock_t is
# available when build with c99.
@@ -31,6 +31,7 @@ AM_CPPFLAGS = -I../src -D_POSIX_C_SOURCE=200112L
AM_LDFLAGS =
LDADD = ../src/libnpth.la $(LIBSOCKET) $(LIB_CLOCK_GETTIME)
TESTS += t-fork
+TESTS += t-fork-enhance
endif
noinst_HEADERS = t-support.h
diff --git a/tests/t-condlock.c b/tests/t-condlock.c
new file mode 100644
index 0000000..ff7597b
--- /dev/null
+++ b/tests/t-condlock.c
@@ -0,0 +1,106 @@
+/* t-condlock.c
+ *
+ * This file is free software; as a special exception the author gives
+ * unlimited permission to copy and/or distribute it, with or without
+ * modifications, as long as this notice is preserved.
+ *
+ * This file is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include "t-support.h"
+
+
+static int counter;
+static npth_mutex_t cond_mutex;
+static npth_cond_t cond = NPTH_COND_INITIALIZER;
+
+static void *
+thread_one (void *arg)
+{
+ int rc;
+ struct timespec tout;
+
+ rc = npth_mutex_lock (&cond_mutex);
+ fail_if_err (rc);
+ if (counter == 0)
+ npth_cond_wait(&cond, &cond_mutex);
+ counter--;
+ info_msg ("count dec");
+ clock_gettime(CLOCK_REALTIME, &tout);
+ tout.tv_sec += 1;
+ npth_cond_timedwait (&cond, &cond_mutex, &tout);
+ npth_mutex_unlock (&cond_mutex);
+ return (void*)4711;
+}
+
+static void *
+thread_two (void *arg)
+{
+ int rc;
+
+ rc = npth_mutex_lock (&cond_mutex);
+ fail_if_err (rc);
+ counter++;
+ info_msg ("count inc");
+ if (counter != 0)
+ npth_cond_signal(&cond);
+ npth_mutex_unlock (&cond_mutex);
+ return (void*)4722;
+}
+
+int
+main (int argc, char *argv[])
+{
+ int rc;
+ npth_attr_t tattr;
+ int state;
+ npth_t tid1, tid2;
+ void *retval;
+
+ if (argc >= 2 && !strcmp (argv[1], "--verbose"))
+ opt_verbose = 1;
+
+ rc = npth_init ();
+ fail_if_err (rc);
+
+ rc = npth_mutex_init (&cond_mutex, NULL);
+ fail_if_err (rc);
+
+ rc = npth_attr_init (&tattr);
+ fail_if_err (rc);
+ rc = npth_attr_getdetachstate (&tattr, &state);
+ fail_if_err (rc);
+ if ( state != NPTH_CREATE_JOINABLE )
+ fail_msg ("new tattr is not joinable");
+
+ info_msg ("creating thread-one");
+ rc = npth_create (&tid1, &tattr, thread_one, NULL);
+ fail_if_err (rc);
+ npth_setname_np (tid1, "thread-one");
+
+ npth_usleep(100);
+
+ info_msg ("creating thread-two");
+ rc = npth_create (&tid2, &tattr, thread_two, NULL);
+ fail_if_err (rc);
+ npth_setname_np (tid2, "thread-two");
+
+ rc = npth_attr_destroy (&tattr);
+ fail_if_err (rc);
+
+ info_msg ("waiting for thread-one to terminate");
+ rc = npth_join (tid1, &retval);
+ fail_if_err (rc);
+ if (retval != (void*)4711)
+ fail_msg ("thread-one returned an unexpected value");
+
+ info_msg ("waiting for thread-two to terminate");
+ rc = npth_join (tid2, &retval);
+ fail_if_err (rc);
+ if (retval != (void*)4722)
+ fail_msg ("thread-two returned an unexpected value");
+
+ return 0;
+}
diff --git a/tests/t-fork-enhance.c b/tests/t-fork-enhance.c
new file mode 100644
index 0000000..0c0a957
--- /dev/null
+++ b/tests/t-fork-enhance.c
@@ -0,0 +1,68 @@
+/* t-fork-enhance.c
+ *
+ * This file is free software; as a special exception the author gives
+ * unlimited permission to copy and/or distribute it, with or without
+ * modifications, as long as this notice is preserved.
+ *
+ * This file is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include "t-support.h"
+
+/* This is a test if nPth can allow daemon-like applications
+ initializing earlier.
+
+ For daemon-like applications, ideally, it is expected to call
+ npth_init after fork. This condition is not satisfied sometimes.
+
+ Failure of this test means nPth implementation doesn't allow
+ npth_init after fork. In such a case, application should be
+ modified.
+ */
+
+int
+main (int argc, const char *argv[])
+{
+ int rc;
+ pid_t pid;
+ struct timespec ts;
+
+ if (argc >= 2 && !strcmp (argv[1], "--verbose"))
+ opt_verbose = 1;
+
+ rc = npth_init ();
+ fail_if_err (rc);
+
+ rc = npth_system("pwd");
+ fail_if_err (rc);
+
+ npth_clock_gettime (&ts);
+
+ npth_unprotect ();
+ npth_protect ();
+ npth_is_protected ();
+
+ pid = fork ();
+ if (pid == (pid_t)-1)
+ fail_msg ("fork failed");
+ else if (pid)
+ {
+ int status;
+
+ info_msg ("forked");
+ npth_waitpid(pid, &status, 0);
+ fail_if_err (status);
+ }
+ else
+ {
+ info_msg ("child exit");
+ npth_usleep (1000); /* Let NPTH enter, sleep, and leave. */
+ }
+
+ return 0;
+}
diff --git a/tests/t-rwlock.c b/tests/t-rwlock.c
new file mode 100644
index 0000000..6b06e05
--- /dev/null
+++ b/tests/t-rwlock.c
@@ -0,0 +1,196 @@
+/* t-rwlock.c
+ *
+ * This file is free software; as a special exception the author gives
+ * unlimited permission to copy and/or distribute it, with or without
+ * modifications, as long as this notice is preserved.
+ *
+ * This file is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include "t-support.h"
+
+#define BUFLEN 100
+
+static int counter;
+static npth_mutex_t counter_mutex;
+static int thread_twoone_ready;
+static npth_rwlock_t counter_rwlock;
+
+static void *
+thread_one (void *arg)
+{
+ int rc, i;
+ struct timespec tout;
+
+ clock_gettime(CLOCK_REALTIME, &tout);
+ tout.tv_sec += 1;
+ rc = npth_rwlock_timedrdlock (&counter_rwlock, &tout);
+ if (rc == 0)
+ npth_rwlock_unlock(&counter_rwlock);
+
+ clock_gettime(CLOCK_REALTIME, &tout);
+ tout.tv_sec += 1;
+ rc = npth_rwlock_timedwrlock (&counter_rwlock, &tout);
+ if (rc == 0)
+ npth_rwlock_unlock(&counter_rwlock);
+
+ info_msg ("thread-one started");
+ npth_usleep (10); /* Give the other thread some time to start. */
+ for (i=0; i < 10; i++)
+ {
+ /* We would not need the mutex here, but we use it to allow the
+ system to switch to another thread. */
+ rc = npth_mutex_lock (&counter_mutex);
+ fail_if_err (rc);
+
+ counter++;
+
+ rc = npth_mutex_unlock (&counter_mutex);
+ fail_if_err (rc);
+ }
+
+ info_msg ("thread-one terminated");
+
+ return (void*)4711;
+}
+
+
+static void *
+thread_twoone (void *arg)
+{
+ int rc, i;
+
+ npth_setname_np (npth_self (), "thread-twoone");
+ info_msg ("thread-twoone started");
+
+ rc = npth_detach (npth_self ());
+ fail_if_err (rc);
+
+ while (counter < 100)
+ {
+ npth_usleep (1000);
+ counter++;
+ }
+ info_msg ("thread-twoone terminated");
+ thread_twoone_ready = 1;
+
+ npth_exit (&rc);
+ return NULL;
+}
+
+
+static void *
+thread_two (void *arg)
+{
+ int rc, i;
+
+ info_msg ("thread-two started");
+
+ for (i=0; i < 10; i++)
+ {
+ rc = npth_mutex_lock (&counter_mutex);
+ fail_if_err (rc);
+
+ counter--;
+
+ if (i == 5)
+ {
+ npth_t tid;
+
+ info_msg ("creating thread-twoone");
+ rc = npth_create (&tid, NULL, thread_twoone, NULL);
+ fail_if_err (rc);
+ npth_usleep (10); /* Give new thread some time to start. */
+ }
+
+ rc = npth_mutex_unlock (&counter_mutex);
+ fail_if_err (rc);
+ }
+
+ info_msg ("busy waiting for thread twoone");
+ while (!thread_twoone_ready)
+ npth_sleep (0);
+
+ info_msg ("thread-two terminated");
+
+ return (void*)4722;
+}
+
+int
+main (int argc, char *argv[])
+{
+ int rc;
+ npth_attr_t tattr;
+ int state;
+ npth_t tid1, tid2;
+ void *retval;
+ char bufname[BUFLEN];
+ struct timespec tout;
+
+ if (argc >= 2 && !strcmp (argv[1], "--verbose"))
+ opt_verbose = 1;
+
+ rc = npth_init ();
+ fail_if_err (rc);
+
+ rc = npth_mutex_init (&counter_mutex, NULL);
+ fail_if_err (rc);
+
+ clock_gettime(CLOCK_REALTIME, &tout);
+ tout.tv_sec += 1;
+ rc = npth_mutex_timedlock (&counter_mutex, &tout);
+ npth_mutex_unlock (&counter_mutex);
+
+ rc = npth_rwlock_init(&counter_rwlock, NULL);
+ fail_if_err (rc);
+
+ npth_rwlock_rdlock(&counter_rwlock);
+ npth_rwlock_unlock(&counter_rwlock);
+
+ npth_rwlock_wrlock(&counter_rwlock);
+ npth_rwlock_unlock(&counter_rwlock);
+
+ rc = npth_attr_init (&tattr);
+ fail_if_err (rc);
+ rc = npth_attr_getdetachstate (&tattr, &state);
+ fail_if_err (rc);
+ if ( state != NPTH_CREATE_JOINABLE )
+ fail_msg ("new tattr is not joinable");
+
+ info_msg ("creating thread-one");
+ rc = npth_create (&tid1, &tattr, thread_one, NULL);
+ fail_if_err (rc);
+ npth_setname_np (tid1, "thread-one");
+ npth_getname_np (tid1, bufname, BUFLEN);
+
+ npth_rwlock_wrlock(&counter_rwlock);
+ npth_sleep(5);
+ npth_rwlock_unlock(&counter_rwlock);
+
+ info_msg ("creating thread-two");
+ rc = npth_create (&tid2, &tattr, thread_two, NULL);
+ fail_if_err (rc);
+ npth_setname_np (tid2, "thread-two");
+
+ rc = npth_attr_destroy (&tattr);
+ fail_if_err (rc);
+
+ info_msg ("waiting for thread-one to terminate");
+ rc = npth_join (tid1, &retval);
+ fail_if_err (rc);
+ if (retval != (void*)4711)
+ fail_msg ("thread-one returned an unexpected value");
+
+ info_msg ("waiting for thread-two to terminate");
+ rc = npth_join (tid2, &retval);
+ fail_if_err (rc);
+ if (retval != (void*)4722)
+ fail_msg ("thread-two returned an unexpected value");
+
+ if (counter != 100)
+ fail_msg ("counter value not as expected");
+
+ return 0;
+}
diff --git a/tests/t-signal.c b/tests/t-signal.c
new file mode 100644
index 0000000..45c7c97
--- /dev/null
+++ b/tests/t-signal.c
@@ -0,0 +1,49 @@
+/* t-signal.c
+ *
+ * This file is free software; as a special exception the author gives
+ * unlimited permission to copy and/or distribute it, with or without
+ * modifications, as long as this notice is preserved.
+ *
+ * This file is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include "t-support.h"
+
+/* This is a test if nPth can allow daemon-like applications
+ initializing earlier.
+
+ For daemon-like applications, ideally, it is expected to call
+ npth_init after fork. This condition is not satisfied sometimes.
+
+ Failure of this test means nPth implementation doesn't allow
+ npth_init after fork. In such a case, application should be
+ modified.
+ */
+
+int
+main (int argc, const char *argv[])
+{
+ int rc;
+ pid_t pid;
+ int r_signum;
+
+ if (argc >= 2 && !strcmp (argv[1], "--verbose"))
+ opt_verbose = 1;
+
+ rc = npth_init ();
+ fail_if_err (rc);
+
+ npth_sigev_init();
+ npth_sigev_add (5);
+ npth_sigev_add (7);
+ npth_sigev_fini ();
+ npth_sigev_sigmask ();
+ npth_sigev_get_pending (&r_signum);
+
+ return 0;
+}
diff --git a/tests/t-socket.c b/tests/t-socket.c
new file mode 100644
index 0000000..94ad0bb
--- /dev/null
+++ b/tests/t-socket.c
@@ -0,0 +1,284 @@
+/* t-socket.c
+ *
+ * This file is free software; as a special exception the author gives
+ * unlimited permission to copy and/or distribute it, with or without
+ * modifications, as long as this notice is preserved.
+ *
+ * This file is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#include "t-support.h"
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <strings.h>
+
+#define NAME "Socket"
+#define DATA "Hello, little Baby . . ."
+
+static int server1Ready;
+static int server2Ready;
+
+static void *
+thread_one (void *arg)
+{
+ int sock, msgsock, rval;
+ struct sockaddr_un server;
+ char buf[1024];
+ struct timeval tv;
+ struct timespec ts;
+
+ info_msg ("thread-one started");
+ tv.tv_sec = 0;
+ tv.tv_usec = 100;
+ ts.tv_sec = 0;
+ ts.tv_nsec = 1000;
+
+ sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sock < 0) {
+ perror("opening stream socket");
+ goto end;
+ }
+ server.sun_family = AF_UNIX;
+ strcpy(server.sun_path, NAME);
+ if (bind(sock, (struct sockaddr *) &server, sizeof(struct sockaddr_un))) {
+ perror("binding stream socket");
+ goto end;
+ }
+ printf("Socket has name %s\n", server.sun_path);
+ listen(sock, 5);
+ server1Ready = 1;
+ msgsock = npth_accept(sock, 0, 0);
+ if (msgsock == -1)
+ perror("accept");
+ else do {
+ bzero(buf, sizeof(buf));
+ if ((rval = npth_read(msgsock, buf, 1024)) < 0)
+ perror("reading stream message");
+ else if (rval == 0)
+ printf("Ending connection\n");
+ else
+ printf("-->%s\n", buf);
+ } while (rval > 0);
+
+ npth_select(0, NULL, NULL, NULL, &tv);
+ npth_pselect(0, NULL, NULL, NULL, &ts, NULL);
+ close(msgsock);
+ close(sock);
+ unlink(NAME);
+ info_msg ("thread-one terminated");
+end:
+ return (void*)4711;
+}
+
+
+static void *
+thread_two (void *arg)
+{
+
+ int sock;
+ struct sockaddr_un server;
+ char buf[1024];
+
+ info_msg ("thread-two started");
+ if (!server1Ready) {
+ info_msg ("server1 not ready");
+ goto end;
+ }
+ sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sock < 0) {
+ perror("opening stream socket");
+ goto end;
+ }
+ server.sun_family = AF_UNIX;
+ strcpy(server.sun_path, NAME);
+
+ if (npth_connect(sock, (struct sockaddr *) &server, sizeof(struct sockaddr_un)) < 0) {
+ close(sock);
+ perror("connecting stream socket");
+ goto end;
+ }
+ if (npth_write(sock, DATA, sizeof(DATA)) < 0)
+ perror("writing on stream socket");
+ close(sock);
+
+ info_msg ("thread-two terminated");
+
+end:
+ return (void*)4722;
+}
+
+static void *
+thread_three (void *arg)
+{
+ int sock, msgsock, rval;
+ struct sockaddr_un server;
+ char buf[1024];
+ struct msghdr msg;
+ struct iovec io;
+
+ msg.msg_name = NULL;
+ io.iov_base = buf;
+ io.iov_len = 1024;
+ msg.msg_iov = &io;
+ msg.msg_iovlen = 1;
+
+ info_msg ("thread-three started");
+
+ sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sock < 0) {
+ perror("opening stream socket");
+ goto end;
+ }
+ server.sun_family = AF_UNIX;
+ strcpy(server.sun_path, NAME);
+ if (bind(sock, (struct sockaddr *) &server, sizeof(struct sockaddr_un))) {
+ perror("binding stream socket");
+ goto end;
+ }
+ printf("Socket has name %s\n", server.sun_path);
+ listen(sock, 5);
+ server2Ready = 1;
+ msgsock = npth_accept(sock, 0, 0);
+ if (msgsock == -1)
+ perror("accept");
+ else {
+ bzero(buf, sizeof(buf));
+ ssize_t recv_size = npth_recvmsg(msgsock, &msg, 0);
+ char * temp = msg.msg_iov[0].iov_base;
+ temp[recv_size] = '\0';
+ printf("get message:%s", temp);
+ };
+
+ close(msgsock);
+ close(sock);
+ unlink(NAME);
+ info_msg ("thread-three terminated");
+end:
+ return (void*)4711;
+}
+
+
+static void *
+thread_four (void *arg)
+{
+
+ int sock;
+ struct sockaddr_un server;
+ char buf[1024] = "test sendmsg and recvmsg\n";
+ struct msghdr msg;
+ struct iovec io;
+
+ msg.msg_name = NULL;
+ io.iov_base = buf;
+ io.iov_len = sizeof(buf);
+ msg.msg_iov = &io;
+ msg.msg_iovlen = 1;
+
+ info_msg ("thread-four started");
+ if (!server2Ready) {
+ info_msg ("server2 not ready");
+ goto end;
+ }
+ sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sock < 0) {
+ perror("opening stream socket");
+ goto end;
+ }
+ server.sun_family = AF_UNIX;
+ strcpy(server.sun_path, NAME);
+
+ if (npth_connect(sock, (struct sockaddr *) &server, sizeof(struct sockaddr_un)) < 0) {
+ close(sock);
+ perror("connecting stream socket");
+ goto end;
+ }
+ npth_sendmsg(sock, &msg, 0);
+ close(sock);
+
+ info_msg ("thread-four terminated");
+end:
+ return (void*)4722;
+}
+
+int
+main (int argc, char *argv[])
+{
+ int rc;
+ npth_attr_t tattr;
+ int state;
+ npth_t tid1, tid2;
+ npth_t tid3, tid4;
+ void *retval;
+
+ if (argc >= 2 && !strcmp (argv[1], "--verbose"))
+ opt_verbose = 1;
+
+ rc = npth_init ();
+ fail_if_err (rc);
+
+ rc = npth_attr_init (&tattr);
+ fail_if_err (rc);
+ rc = npth_attr_getdetachstate (&tattr, &state);
+ fail_if_err (rc);
+ if ( state != NPTH_CREATE_JOINABLE )
+ fail_msg ("new tattr is not joinable");
+
+ info_msg ("creating thread-one");
+ rc = npth_create (&tid1, &tattr, thread_one, NULL);
+ fail_if_err (rc);
+ npth_setname_np (tid1, "thread-one");
+
+ npth_usleep(100);
+
+ info_msg ("creating thread-two");
+ rc = npth_create (&tid2, &tattr, thread_two, NULL);
+ fail_if_err (rc);
+ npth_setname_np (tid2, "thread-two");
+
+ rc = npth_attr_destroy (&tattr);
+ fail_if_err (rc);
+
+ info_msg ("waiting for thread-one to terminate");
+ rc = npth_join (tid1, &retval);
+ fail_if_err (rc);
+ if (retval != (void*)4711)
+ fail_msg ("thread-one returned an unexpected value");
+
+ info_msg ("waiting for thread-two to terminate");
+ rc = npth_join (tid2, &retval);
+ fail_if_err (rc);
+ if (retval != (void*)4722)
+ fail_msg ("thread-two returned an unexpected value");
+
+ info_msg ("creating thread-three");
+ rc = npth_create (&tid3, NULL, thread_three, NULL);
+ fail_if_err (rc);
+ npth_setname_np (tid3, "thread-three");
+
+ npth_usleep(100);
+
+ info_msg ("creating thread-four");
+ rc = npth_create (&tid4, NULL, thread_four, NULL);
+ fail_if_err (rc);
+ npth_setname_np (tid4, "thread-two");
+
+ info_msg ("waiting for thread-three to terminate");
+ rc = npth_join (tid3, &retval);
+ fail_if_err (rc);
+ if (retval != (void*)4711)
+ fail_msg ("thread-three returned an unexpected value");
+
+ info_msg ("waiting for thread-four to terminate");
+ rc = npth_join (tid4, &retval);
+ fail_if_err (rc);
+ if (retval != (void*)4722)
+ fail_msg ("thread-four returned an unexpected value");
+
+ return 0;
+}
--
2.27.0
Reference in New Issue View Git Blame Copy Permalink