Rename test/unittests to tests/ and test/ to bin/

tests/test_frame_chop.c

@@ -0,0 +1,218 @@
+/* Copyright (c) 2017 - 2020 LiteSpeed Technologies Inc.  See LICENSE. */
+/*
+ * Write several things to HEADERS stream and check the results.  What
+ * varies is the amount of bytes that are written to stream every time.
+ * This will exercise buffering in frame writer and verify that contents
+ * are written out correctly no matter where frab writing leaves off
+ * and picks up.
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef WIN32
+#include <unistd.h>
+#else
+#include <getopt.h>
+#endif
+#include <sys/queue.h>
+
+#include "lsquic.h"
+#include "lshpack.h"
+#include "lsquic_logger.h"
+#include "lsquic_mm.h"
+#include "lsquic_frame_common.h"
+#include "lsquic_frame_writer.h"
+#include "lsquic_frame_reader.h"
+#if LSQUIC_CONN_STATS
+#include "lsquic_int_types.h"
+#include "lsquic_conn.h"
+#endif
+
+
+struct lsquic_stream
+{
+    size_t          sm_write_off,
+                    sm_buf_sz;      /* Number of bytes allocated */
+    size_t          sm_max_write;
+    size_t          sm_read_off;
+    unsigned char  *sm_buf;
+};
+
+
+static struct lsquic_stream *
+stream_new (size_t max_write)
+{
+    struct lsquic_stream *stream = calloc(1, sizeof(*stream));
+    stream->sm_max_write = max_write;
+    return stream;
+}
+
+
+static void
+stream_destroy (struct lsquic_stream *stream)
+{
+    free(stream->sm_buf);
+    free(stream);
+}
+
+
+#define reset_output(max_) do {         \
+    output.sz = 0;                      \
+    if (max_)                           \
+        output.max = max_;              \
+    else                                \
+        output.max = sizeof(output.buf);\
+} while (0)
+
+
+static ssize_t
+stream_write (struct lsquic_stream *stream, struct lsquic_reader *reader)
+{
+    size_t sz;
+
+    sz = reader->lsqr_size(reader->lsqr_ctx);
+    if (sz > stream->sm_max_write)
+        sz = stream->sm_max_write;
+    if (stream->sm_write_off + sz > stream->sm_buf_sz)
+    {
+        if (stream->sm_write_off + sz < stream->sm_buf_sz * 2)
+            stream->sm_buf_sz *= 2;
+        else
+            stream->sm_buf_sz = stream->sm_write_off + sz;
+        stream->sm_buf = realloc(stream->sm_buf, stream->sm_buf_sz);
+    }
+
+    sz = reader->lsqr_read(reader->lsqr_ctx,
+                                    stream->sm_buf + stream->sm_write_off, sz);
+    stream->sm_write_off += sz;
+
+    return sz;
+}
+
+
+#define XHDR(name_, value_) .buf = value_, .name_ptr = name_, .val_len = sizeof(value_) - 1, .name_len = sizeof(name_) - 1
+
+
+static void
+test_chop (unsigned max_write_sz)
+{
+    struct lsquic_frame_writer *fw;
+    struct lsquic_stream *stream;
+    struct lsquic_mm mm;
+    struct lshpack_enc henc;
+    int s;
+
+#if LSQUIC_CONN_STATS
+    struct conn_stats conn_stats;
+    memset(&conn_stats, 0, sizeof(conn_stats));
+#endif
+
+    lsquic_mm_init(&mm);
+    lshpack_enc_init(&henc);
+    stream = stream_new(max_write_sz);
+
+    fw = lsquic_frame_writer_new(&mm, stream, 0, &henc, stream_write,
+#if LSQUIC_CONN_STATS
+                                 &conn_stats,
+#endif
+                                0);
+
+    struct lsxpack_header header_arr[] =
+    {
+        { XHDR(":status", "302") },
+    };
+
+    struct lsquic_http_headers headers = {
+        .count = 1,
+        .headers = header_arr,
+    };
+
+    s = lsquic_frame_writer_write_headers(fw, 12345, &headers, 0, 100);
+    assert(0 == s);
+
+    struct lsquic_http2_setting settings[] = { { 1, 2, }, { 3, 4, } };
+    s = lsquic_frame_writer_write_settings(fw, settings, 2);
+    assert(0 == s);
+
+    /* TODO: server must not send priority frames, add a check for that
+     * error condition.
+     */
+    s = lsquic_frame_writer_write_priority(fw, 3, 0, 1, 256);
+    assert(0 == s);
+
+    while (lsquic_frame_writer_have_leftovers(fw))
+    {
+        s = lsquic_frame_writer_flush(fw);
+        assert(0 == s);
+    }
+
+    const unsigned char expected_buf[] = {
+        /* Length: */       0x00, 0x00, 0x09,
+        /* Type: */         HTTP_FRAME_HEADERS,
+        /* Flags: */        HFHF_END_HEADERS|HFHF_PRIORITY,
+        /* Stream Id: */    0x00, 0x00, 0x30, 0x39,
+        /* Dep stream id: */0x00, 0x00, 0x00, 0x00,
+        /* Weight: */       100 - 1,
+        /* Block fragment: */
+                            0x48, 0x82, 0x64, 0x02,
+        /* Length: */       0x00, 0x00, 0x0C,
+        /* Type: */         HTTP_FRAME_SETTINGS,
+        /* Flags: */        0x00,
+        /* Stream Id: */    0x00, 0x00, 0x00, 0x00,
+        /* Payload: */      0x00, 0x01, 0x00, 0x00, 0x00, 0x02,
+                            0x00, 0x03, 0x00, 0x00, 0x00, 0x04,
+        /* Length: */       0x00, 0x00, 5,
+        /* Type: */         HTTP_FRAME_PRIORITY,
+        /* Flags: */        0x00,
+        /* Stream Id: */    0x00, 0x00, 0x00, 0x03,
+        /* Dep stream Id: */0x00, 0x00, 0x00, 0x01,
+        /* Weight: */       0xFF,
+    };
+
+    assert(stream->sm_write_off == sizeof(expected_buf));
+    assert(0 == memcmp(stream->sm_buf, expected_buf, sizeof(expected_buf)));
+
+    lsquic_frame_writer_destroy(fw);
+    stream_destroy(stream);
+    lshpack_enc_cleanup(&henc);
+    lsquic_mm_cleanup(&mm);
+}
+
+
+int
+main (int argc, char **argv)
+{
+    const unsigned write_sizes[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 20,
+                                     30, 100, 200, 255, 0xFFF, 0x1000, 0x100D,
+                                     UINT_MAX, };
+    unsigned i;
+    int opt, max_write_sz = -1;
+
+    while (-1 != (opt = getopt(argc, argv, "l:s:")))
+    {
+        switch (opt)
+        {
+        case 'l':
+            lsquic_log_to_fstream(stderr, LLTS_NONE);
+            lsquic_logger_lopt(optarg);
+            break;
+        case 's':
+            max_write_sz = atoi(optarg);
+            break;
+        default:
+            exit(1);
+        }
+    }
+
+    if (-1 == max_write_sz)
+        for (i = 0; i < sizeof(write_sizes) / sizeof(write_sizes[0]); ++i)
+            test_chop(write_sizes[i]);
+    else
+        test_chop(max_write_sz);
+
+    return 0;
+}