Move more logic from main to smlr; handle newlines; add unit tests

Author: Nate Fisher

src/main.c

@@ -71,33 +71,24 @@ int main(int argc, char** argv) {
       return EXIT_FAILURE;
     }
 
-    while (1) {
-      char c = getc(stdin);
-
-      if (c == EOF) {
-        if (smlr_get_buf(smlr, buf, size + 1)) {
-          fprintf(stderr, "Error: Could not populate output buffer\n");
-          free(buf);
-          return EXIT_FAILURE;
-        }
-        printf("%s\n", buf);
-        break;
-      } else if (c == '\n') {
-        continue;
-      }
-
-      if (smlr_push(smlr, c)) {
+    uint8_t is_end = 0;
+    while(!is_end) {
+      if (smlr_push(smlr, getc(stdin), &is_end)) {
+        fprintf(stderr, "Error: Could not push character\n");
+        smlr_delete(smlr);
         free(buf);
         return EXIT_FAILURE;
       }
     }
 
-    if (smlr_delete(smlr)) {
-      fprintf(stderr, "Error: Could not delete smlr_t\n");
-      free(buf);
+    if (!smlr_get_buf(smlr, buf, size + 1)) {
+      fprintf(stdout, "%s\n", buf);
+    } else {
+      fprintf(stderr, "Error: Could not populate output buffer\n");
       return EXIT_FAILURE;
     }
 
+    smlr_delete(smlr);
     free(buf);
 
   } else {

src/smlr.c

@@ -18,8 +18,9 @@ const char ellipsis_str[ELLIPSIS_LEN + 1] = "...";
 smlr_t* smlr_new(size_t output_size, smlr_alignment_t alignment) {
 
   // check input preconditions
-  if (!output_size)
+  if (!output_size) {
     return NULL;
+  }
 
   smlr_t* smlr  = NULL;
   char*   p_buf = NULL;
@@ -72,9 +73,17 @@ int8_t smlr_delete(smlr_t* self) {
   return EXIT_SUCCESS;
 }
 
-int8_t smlr_push(smlr_t* self, const char c) {
-  if (!self)
+int8_t smlr_push(smlr_t* self, const char c, uint8_t* p_is_end) {
+  if (!self || !p_is_end) {
     return EXIT_FAILURE;
+  }
+
+  if (c == EOF) {
+    *p_is_end = 1;
+    return EXIT_SUCCESS;
+  } else if (c == '\n') {
+    return EXIT_SUCCESS;
+  }
 
   if ((self->align == ALIGN_LEFT) && (self->input_bytes >= self->buf_bytes)) {
     self->input_bytes++;

src/smlr.h

@@ -22,8 +22,8 @@ typedef enum { ALIGN_MIDDLE, ALIGN_LEFT, ALIGN_RIGHT } smlr_alignment_t;
 
 int8_t smlr_delete(smlr_t* self);
 int8_t smlr_get_buf(smlr_t* self, char* dst, size_t dst_bytes);
-int8_t smlr_push(smlr_t* self, const char c);
-smlr_t *smlr_new(size_t output_size, smlr_alignment_t alignment);
+int8_t smlr_push(smlr_t* self, const char c, uint8_t* p_is_end);
+smlr_t* smlr_new(size_t output_size, smlr_alignment_t alignment);
 
 #ifdef __cplusplus
 }

tests/smlr_ut.cc

@@ -6,79 +6,277 @@
 #include "smlr.h"
 #include "smlr_internal.h"
 
+void dump_smlr(smlr_t* p_smlr) {
+  if (!p_smlr) return;
+  char buf[p_smlr->buf_bytes + 1];
+  memcpy(buf, p_smlr->p_buf, p_smlr->buf_bytes);
+  buf[p_smlr->buf_bytes] = '\0';
+  printf("\tp_buf:\t\t%s\n", buf);
+  printf("\tindex:\t\t%zu\n", p_smlr->index);
+  printf("\tinput_bytes:\t%zu\n", p_smlr->input_bytes);
+  printf("\tbuf_bytes:\t%zu\n", p_smlr->buf_bytes);
+  printf("\tleft_bytes:\t%zu\n", p_smlr->left_bytes);
+  printf("\tright_bytes:\t%zu\n", p_smlr->right_bytes);
+  printf("\tbuf_base:\t%zu\n", p_smlr->buf_base);
+  printf("\talign:\t\t%u\n", p_smlr->align);
+}
+
 TEST(SmlrTest, valid_new_delete_test) {
   smlr_t *p_smlr;
   EXPECT_NE(nullptr, p_smlr = smlr_new(20, ALIGN_LEFT));
+  if (HasFailure()) dump_smlr(p_smlr);
   EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
 }
 
 TEST(SmlrTest, invalid_ptr_new_delete_test) {
   smlr_t *p_smlr;
   EXPECT_EQ(nullptr, p_smlr = smlr_new(0, ALIGN_LEFT));
+  if (HasFailure()) dump_smlr(p_smlr);
   EXPECT_NE(EXIT_SUCCESS, smlr_delete(p_smlr));
+
 }
 
 TEST(SmlrTest, invalid_alignment_new_delete_test) {
   smlr_t *p_smlr;
   EXPECT_EQ(nullptr, p_smlr = smlr_new(10, (smlr_alignment_t)10));
+  if (HasFailure()) dump_smlr(p_smlr);
   EXPECT_NE(EXIT_SUCCESS, smlr_delete(p_smlr));
+
 }
 
 TEST(SmlrTest, smlr_push) {
   smlr_t *p_smlr;
-  size_t prefix_sz;
+  uint8_t is_end = 0;
   EXPECT_NE(nullptr, p_smlr = smlr_new(7, ALIGN_LEFT));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '1', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '2', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '3', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '4', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '5', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '6', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '7', &is_end));
+
+  if (HasFailure()) dump_smlr(p_smlr);
+  EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
+}
+
+TEST(SmlrTest, smlr_push_RIGHT) {
+  smlr_t *p_smlr;
+  size_t buf_sz = 5;
+  uint8_t is_end = 0;
+  EXPECT_NE(nullptr, p_smlr = smlr_new(buf_sz, ALIGN_RIGHT));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '1', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '2', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '3', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '4', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '5', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '6', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '7', &is_end));
+  char truth[] = "67345";
 
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '1'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '2'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '3'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '4'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '5'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '6'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '7'));
+  EXPECT_EQ(0, memcmp(p_smlr->p_buf, truth, buf_sz));
 
+  if (HasFailure()) dump_smlr(p_smlr);
   EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
 }
 
-TEST(SmlrTest, smlr_push_wrap) {
+TEST(SmlrTest, smlr_push_MIDDLE) {
   smlr_t *p_smlr;
-  size_t prefix_sz;
-  EXPECT_NE(nullptr, p_smlr = smlr_new(5, ALIGN_LEFT));
+  size_t buf_sz = 5;
+  uint8_t is_end = 0;
+  EXPECT_NE(nullptr, p_smlr = smlr_new(buf_sz, ALIGN_MIDDLE));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '1', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '2', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '3', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '4', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '5', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '6', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '7', &is_end));
+  char truth[] = "16745";
+
+  EXPECT_EQ(0, memcmp(p_smlr->p_buf, truth, buf_sz));
+
+  if (HasFailure()) dump_smlr(p_smlr);
+  EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
+}
 
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '1'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '2'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '3'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '4'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '5'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '6'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '7'));
+TEST(SmlrTest, smlr_push_LEFT) {
+  smlr_t *p_smlr;
+  size_t buf_sz = 5;
+  uint8_t is_end = 0;
+  EXPECT_NE(nullptr, p_smlr = smlr_new(buf_sz, ALIGN_LEFT));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '1', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '2', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '3', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '4', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '5', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '6', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, '7', &is_end));
+  char truth[] = "12345";
 
+  EXPECT_EQ(0, memcmp(p_smlr->p_buf, truth, buf_sz));
+  if (HasFailure()) dump_smlr(p_smlr);
   EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
 }
 
 TEST(SmlrTest, smlr_push_invalid) {
+  uint8_t is_end = 0;
+  EXPECT_NE(EXIT_SUCCESS, smlr_push(NULL, '1', &is_end));
+}
+
+TEST(SmlrTest, smlr_push_eof) {
+  smlr_t *p_smlr;
+  uint8_t is_end = 0;
+  EXPECT_NE(nullptr, p_smlr = smlr_new(5, ALIGN_LEFT));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, EOF, &is_end));
+  EXPECT_NE(0, is_end);
+  if (HasFailure()) dump_smlr(p_smlr);
+  EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
+}
+
+TEST(SmlrTest, smlr_push_not_eof) {
   smlr_t *p_smlr;
-  size_t prefix_sz;
+  uint8_t is_end = 0;
   EXPECT_NE(nullptr, p_smlr = smlr_new(5, ALIGN_LEFT));
-  EXPECT_NE(EXIT_SUCCESS, smlr_push(NULL, '1'));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'a', &is_end));
+  EXPECT_EQ(0, is_end);
+  if (HasFailure()) dump_smlr(p_smlr);
   EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
 }
 
 TEST(SmlrTest, smlr_get_buf_left_nominal_short) {
   smlr_t *p_smlr;
   const size_t buf_sz = 10;
+  uint8_t is_end = 0;
   char buf[buf_sz];
-
   EXPECT_NE(nullptr, p_smlr = smlr_new(buf_sz, ALIGN_LEFT));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'a'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'b'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'c'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'd'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'e'));
-  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'f'));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'a', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'b', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'c', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'd', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'e', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'f', &is_end));
   EXPECT_EQ(EXIT_SUCCESS, smlr_get_buf(p_smlr, buf, buf_sz));
 
-  EXPECT_EQ(0, strcmp(buf, "abcdef"));
+  EXPECT_STREQ(buf, "abcdef");
 
+  if (HasFailure()) dump_smlr(p_smlr);
   EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
+}
+
+TEST(SmlrTest, smlr_internals_5) {
+  smlr_t *p_smlr;
+  size_t buf_sz = 5;
+  EXPECT_NE(nullptr, p_smlr = smlr_new(buf_sz, ALIGN_MIDDLE));
+
+  EXPECT_EQ(0, p_smlr->index);
+  EXPECT_EQ(0, p_smlr->input_bytes);
+  EXPECT_EQ(5, p_smlr->buf_bytes);
+  EXPECT_EQ(1, p_smlr->left_bytes);
+  EXPECT_EQ(1, p_smlr->right_bytes);
+  EXPECT_EQ(0, p_smlr->buf_base);
+
+  if (HasFailure()) dump_smlr(p_smlr);
+  EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
+}
+
+TEST(SmlrTest, smlr_internals_10) {
+  smlr_t *p_smlr;
+  size_t buf_sz = 10;
+  EXPECT_NE(nullptr, p_smlr = smlr_new(buf_sz, ALIGN_MIDDLE));
+
+  EXPECT_EQ(0, p_smlr->index);
+  EXPECT_EQ(0, p_smlr->input_bytes);
+  EXPECT_EQ(10, p_smlr->buf_bytes);
+  EXPECT_EQ(4, p_smlr->left_bytes);
+  EXPECT_EQ(3, p_smlr->right_bytes);
+  EXPECT_EQ(0, p_smlr->buf_base);
+
+  if (HasFailure()) dump_smlr(p_smlr);
+  EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
+}
+
+TEST(SmlrTest, smlr_left_alphabet) {
+  smlr_t *p_smlr;
+  const size_t buf_sz = 12;
+  uint8_t is_end = 0;
+  EXPECT_NE(nullptr, p_smlr = smlr_new(buf_sz, ALIGN_MIDDLE));
+
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'a', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'b', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'c', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'd', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'e', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'f', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'g', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'h', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'i', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'j', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'k', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'l', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, EOF, &is_end));
+
+  EXPECT_EQ(12, p_smlr->index);
+  EXPECT_EQ(12, p_smlr->input_bytes);
+  EXPECT_EQ(12, p_smlr->buf_bytes);
+  EXPECT_EQ(5, p_smlr->left_bytes);
+  EXPECT_EQ(4, p_smlr->right_bytes);
+  EXPECT_EQ(0, p_smlr->buf_base);
+  EXPECT_NE(0, is_end);
+
+  char buf_true[buf_sz+1] = "abcdefghijkl";
+  char buf_out[buf_sz+1];
+  EXPECT_EQ(EXIT_SUCCESS, smlr_get_buf(p_smlr, buf_out, buf_sz+1));
+  EXPECT_STREQ(buf_true, buf_out);
+
+  if (HasFailure()) dump_smlr(p_smlr);
+  EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
+}
+
+TEST(SmlrTest, smlr_left_alphabet_trunc) {
+  smlr_t *p_smlr;
+  const size_t buf_sz = 11;
+  uint8_t is_end = 0;
+  EXPECT_NE(nullptr, p_smlr = smlr_new(buf_sz, ALIGN_MIDDLE));
+
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'a', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'b', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'c', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'd', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'e', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'f', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'g', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'h', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'i', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'j', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'k', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, 'l', &is_end));
+  EXPECT_EQ(EXIT_SUCCESS, smlr_push(p_smlr, EOF, &is_end));
+
+  EXPECT_EQ(5, p_smlr->index);
+  EXPECT_EQ(12, p_smlr->input_bytes);
+  EXPECT_EQ(11, p_smlr->buf_bytes);
+  EXPECT_EQ(4, p_smlr->left_bytes);
+  EXPECT_EQ(4, p_smlr->right_bytes);
+  EXPECT_EQ(4, p_smlr->buf_base);
+  EXPECT_NE(0, is_end);
+
+  char buf_true[buf_sz+1] = "abcd...ijkl";
+  char buf_out[buf_sz+1];
+  EXPECT_EQ(EXIT_SUCCESS, smlr_get_buf(p_smlr, buf_out, buf_sz+1));
+  EXPECT_STREQ(buf_true, buf_out);
+
+  if (HasFailure()) dump_smlr(p_smlr);
+  EXPECT_EQ(EXIT_SUCCESS, smlr_delete(p_smlr));
+
 }