LCOV - code coverage report
Current view: top level - journal - test-journal-stream.c (source / functions) Hit Total Coverage
Test: systemd_full.info Lines: 94 97 96.9 %
Date: 2019-08-23 13:36:53 Functions: 2 2 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 63 106 59.4 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: LGPL-2.1+ */
       2                 :            : 
       3                 :            : #include <fcntl.h>
       4                 :            : #include <unistd.h>
       5                 :            : 
       6                 :            : #include "sd-journal.h"
       7                 :            : 
       8                 :            : #include "alloc-util.h"
       9                 :            : #include "chattr-util.h"
      10                 :            : #include "journal-file.h"
      11                 :            : #include "journal-internal.h"
      12                 :            : #include "log.h"
      13                 :            : #include "macro.h"
      14                 :            : #include "parse-util.h"
      15                 :            : #include "rm-rf.h"
      16                 :            : #include "tests.h"
      17                 :            : #include "util.h"
      18                 :            : 
      19                 :            : #define N_ENTRIES 200
      20                 :            : 
      21                 :         12 : static void verify_contents(sd_journal *j, unsigned skip) {
      22                 :            :         unsigned i;
      23                 :            : 
      24         [ -  + ]:         12 :         assert_se(j);
      25                 :            : 
      26                 :         12 :         i = 0;
      27   [ +  -  +  + ]:        980 :         SD_JOURNAL_FOREACH(j) {
      28                 :            :                 const void *d;
      29                 :            :                 char *k, *c;
      30                 :            :                 size_t l;
      31                 :        968 :                 unsigned u = 0;
      32                 :            : 
      33         [ -  + ]:        968 :                 assert_se(sd_journal_get_cursor(j, &k) >= 0);
      34                 :        968 :                 printf("cursor: %s\n", k);
      35                 :        968 :                 free(k);
      36                 :            : 
      37         [ -  + ]:        968 :                 assert_se(sd_journal_get_data(j, "MAGIC", &d, &l) >= 0);
      38                 :        968 :                 printf("\t%.*s\n", (int) l, (const char*) d);
      39                 :            : 
      40         [ -  + ]:        968 :                 assert_se(sd_journal_get_data(j, "NUMBER", &d, &l) >= 0);
      41         [ -  + ]:        968 :                 assert_se(k = strndup(d, l));
      42                 :        968 :                 printf("\t%s\n", k);
      43                 :            : 
      44         [ +  + ]:        968 :                 if (skip > 0) {
      45         [ -  + ]:        960 :                         assert_se(safe_atou(k + 7, &u) >= 0);
      46         [ -  + ]:        960 :                         assert_se(i == u);
      47                 :        960 :                         i += skip;
      48                 :            :                 }
      49                 :            : 
      50                 :        968 :                 free(k);
      51                 :            : 
      52         [ -  + ]:        968 :                 assert_se(sd_journal_get_cursor(j, &c) >= 0);
      53         [ -  + ]:        968 :                 assert_se(sd_journal_test_cursor(j, c) > 0);
      54                 :        968 :                 free(c);
      55                 :            :         }
      56                 :            : 
      57         [ +  + ]:         12 :         if (skip > 0)
      58         [ -  + ]:          8 :                 assert_se(i == N_ENTRIES);
      59                 :         12 : }
      60                 :            : 
      61                 :          4 : int main(int argc, char *argv[]) {
      62                 :            :         JournalFile *one, *two, *three;
      63                 :          4 :         char t[] = "/var/tmp/journal-stream-XXXXXX";
      64                 :            :         unsigned i;
      65                 :          4 :         _cleanup_(sd_journal_closep) sd_journal *j = NULL;
      66                 :            :         char *z;
      67                 :            :         const void *data;
      68                 :            :         size_t l;
      69                 :          4 :         dual_timestamp previous_ts = DUAL_TIMESTAMP_NULL;
      70                 :            : 
      71                 :            :         /* journal_file_open requires a valid machine id */
      72         [ -  + ]:          4 :         if (access("/etc/machine-id", F_OK) != 0)
      73                 :          0 :                 return log_tests_skipped("/etc/machine-id not found");
      74                 :            : 
      75                 :          4 :         test_setup_logging(LOG_DEBUG);
      76                 :            : 
      77         [ -  + ]:          4 :         assert_se(mkdtemp(t));
      78         [ -  + ]:          4 :         assert_se(chdir(t) >= 0);
      79                 :          4 :         (void) chattr_path(t, FS_NOCOW_FL, FS_NOCOW_FL, NULL);
      80                 :            : 
      81         [ -  + ]:          4 :         assert_se(journal_file_open(-1, "one.journal", O_RDWR|O_CREAT, 0666, true, (uint64_t) -1, false, NULL, NULL, NULL, NULL, &one) == 0);
      82         [ -  + ]:          4 :         assert_se(journal_file_open(-1, "two.journal", O_RDWR|O_CREAT, 0666, true, (uint64_t) -1, false, NULL, NULL, NULL, NULL, &two) == 0);
      83         [ -  + ]:          4 :         assert_se(journal_file_open(-1, "three.journal", O_RDWR|O_CREAT, 0666, true, (uint64_t) -1, false, NULL, NULL, NULL, NULL, &three) == 0);
      84                 :            : 
      85         [ +  + ]:        804 :         for (i = 0; i < N_ENTRIES; i++) {
      86                 :            :                 char *p, *q;
      87                 :            :                 dual_timestamp ts;
      88                 :            :                 struct iovec iovec[2];
      89                 :            : 
      90                 :        800 :                 dual_timestamp_get(&ts);
      91                 :            : 
      92         [ -  + ]:        800 :                 if (ts.monotonic <= previous_ts.monotonic)
      93                 :          0 :                         ts.monotonic = previous_ts.monotonic + 1;
      94                 :            : 
      95         [ -  + ]:        800 :                 if (ts.realtime <= previous_ts.realtime)
      96                 :          0 :                         ts.realtime = previous_ts.realtime + 1;
      97                 :            : 
      98                 :        800 :                 previous_ts = ts;
      99                 :            : 
     100         [ -  + ]:        800 :                 assert_se(asprintf(&p, "NUMBER=%u", i) >= 0);
     101                 :        800 :                 iovec[0].iov_base = p;
     102                 :        800 :                 iovec[0].iov_len = strlen(p);
     103                 :            : 
     104   [ +  +  -  + ]:        800 :                 assert_se(asprintf(&q, "MAGIC=%s", i % 5 == 0 ? "quux" : "waldo") >= 0);
     105                 :            : 
     106                 :        800 :                 iovec[1].iov_base = q;
     107                 :        800 :                 iovec[1].iov_len = strlen(q);
     108                 :            : 
     109         [ +  + ]:        800 :                 if (i % 10 == 0)
     110         [ -  + ]:         80 :                         assert_se(journal_file_append_entry(three, &ts, NULL, iovec, 2, NULL, NULL, NULL) == 0);
     111                 :            :                 else {
     112         [ +  + ]:        720 :                         if (i % 3 == 0)
     113         [ -  + ]:        240 :                                 assert_se(journal_file_append_entry(two, &ts, NULL, iovec, 2, NULL, NULL, NULL) == 0);
     114                 :            : 
     115         [ -  + ]:        720 :                         assert_se(journal_file_append_entry(one, &ts, NULL, iovec, 2, NULL, NULL, NULL) == 0);
     116                 :            :                 }
     117                 :            : 
     118                 :        800 :                 free(p);
     119                 :        800 :                 free(q);
     120                 :            :         }
     121                 :            : 
     122                 :          4 :         (void) journal_file_close(one);
     123                 :          4 :         (void) journal_file_close(two);
     124                 :          4 :         (void) journal_file_close(three);
     125                 :            : 
     126         [ -  + ]:          4 :         assert_se(sd_journal_open_directory(&j, t, 0) >= 0);
     127                 :            : 
     128         [ -  + ]:          4 :         assert_se(sd_journal_add_match(j, "MAGIC=quux", 0) >= 0);
     129   [ +  -  +  + ]:        164 :         SD_JOURNAL_FOREACH_BACKWARDS(j) {
     130                 :        160 :                 _cleanup_free_ char *c;
     131                 :            : 
     132         [ -  + ]:        160 :                 assert_se(sd_journal_get_data(j, "NUMBER", &data, &l) >= 0);
     133                 :        160 :                 printf("\t%.*s\n", (int) l, (const char*) data);
     134                 :            : 
     135         [ -  + ]:        160 :                 assert_se(sd_journal_get_cursor(j, &c) >= 0);
     136         [ -  + ]:        160 :                 assert_se(sd_journal_test_cursor(j, c) > 0);
     137                 :            :         }
     138                 :            : 
     139   [ +  -  +  + ]:        164 :         SD_JOURNAL_FOREACH(j) {
     140                 :        160 :                 _cleanup_free_ char *c;
     141                 :            : 
     142         [ -  + ]:        160 :                 assert_se(sd_journal_get_data(j, "NUMBER", &data, &l) >= 0);
     143                 :        160 :                 printf("\t%.*s\n", (int) l, (const char*) data);
     144                 :            : 
     145         [ -  + ]:        160 :                 assert_se(sd_journal_get_cursor(j, &c) >= 0);
     146         [ -  + ]:        160 :                 assert_se(sd_journal_test_cursor(j, c) > 0);
     147                 :            :         }
     148                 :            : 
     149                 :          4 :         sd_journal_flush_matches(j);
     150                 :            : 
     151                 :          4 :         verify_contents(j, 1);
     152                 :            : 
     153                 :          4 :         printf("NEXT TEST\n");
     154         [ -  + ]:          4 :         assert_se(sd_journal_add_match(j, "MAGIC=quux", 0) >= 0);
     155                 :            : 
     156         [ -  + ]:          4 :         assert_se(z = journal_make_match_string(j));
     157                 :          4 :         printf("resulting match expression is: %s\n", z);
     158                 :          4 :         free(z);
     159                 :            : 
     160                 :          4 :         verify_contents(j, 5);
     161                 :            : 
     162                 :          4 :         printf("NEXT TEST\n");
     163                 :          4 :         sd_journal_flush_matches(j);
     164         [ -  + ]:          4 :         assert_se(sd_journal_add_match(j, "MAGIC=waldo", 0) >= 0);
     165         [ -  + ]:          4 :         assert_se(sd_journal_add_match(j, "NUMBER=10", 0) >= 0);
     166         [ -  + ]:          4 :         assert_se(sd_journal_add_match(j, "NUMBER=11", 0) >= 0);
     167         [ -  + ]:          4 :         assert_se(sd_journal_add_match(j, "NUMBER=12", 0) >= 0);
     168                 :            : 
     169         [ -  + ]:          4 :         assert_se(z = journal_make_match_string(j));
     170                 :          4 :         printf("resulting match expression is: %s\n", z);
     171                 :          4 :         free(z);
     172                 :            : 
     173                 :          4 :         verify_contents(j, 0);
     174                 :            : 
     175         [ -  + ]:          4 :         assert_se(sd_journal_query_unique(j, "NUMBER") >= 0);
     176         [ +  + ]:        804 :         SD_JOURNAL_FOREACH_UNIQUE(j, data, l)
     177                 :        800 :                 printf("%.*s\n", (int) l, (const char*) data);
     178                 :            : 
     179         [ -  + ]:          4 :         assert_se(rm_rf(t, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
     180                 :            : 
     181                 :          4 :         return 0;
     182                 :            : }

Generated by: LCOV version 1.14