// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <gfx/gfx.h>
#include <fbl/unique_ptr.h>
#include <sys/param.h>
#include <unittest/unittest.h>

#include "textcon.h"
#include "vc.h"

// This is needed to satisfy a reference from vc_handle_device_control_keys
// in vc-input.cpp but the code path to that reference is dead in this test.
void vc_toggle_framebuffer() {
    __builtin_trap();
}

bool g_vc_owns_display = true;

namespace {

void invalidate_callback(void* cookie, int x, int y, int w, int h) {
}

void movecursor_callback(void* cookie, int x, int y) {
}

void push_scrollback_line_callback(void* cookie, int y) {
}

void copy_lines_callback(void* cookie, int y_dest, int y_src, int line_count) {
    auto* tc = reinterpret_cast<textcon_t*>(cookie);
    tc_copy_lines(tc, y_dest, y_src, line_count);
}

void setparam_callback(void* cookie, int param, uint8_t* arg, size_t arglen) {
}

// Helper for initializing and testing console instances.  This actually
// creates two console instances:
//
//  * A textcon_t (non-graphical), for testing character-level output.
//  * A vc_t (graphical), for testing incremental updates to the
//    gfx_surface.
//
// In principle, we could test the character-level output via the textcon_t
// that the vc_t creates internally.  However, using our own
// separate textcon_t instance helps check that textcon_t can be used on
// its own, outside of vc_t.
class TextconHelper {
public:
    TextconHelper(uint32_t size_x, uint32_t size_y) : size_x(size_x),
                                                      size_y(size_y) {
        // Create a textcon_t.
        textbuf = new vc_char_t[size_x * size_y];
        textcon.cookie = &textcon;
        textcon.invalidate = invalidate_callback;
        textcon.movecursor = movecursor_callback;
        textcon.push_scrollback_line = push_scrollback_line_callback;
        textcon.copy_lines = copy_lines_callback;
        textcon.setparam = setparam_callback;
        tc_init(&textcon, size_x, size_y, textbuf, 0, 0, 0, 0);
        // Initialize buffer contents, since this is currently done
        // outside of textcon.cpp in vc-device.cpp.
        for (size_t i = 0; i < size_x * size_y; ++i)
            textbuf[i] = ' ';

        // Create a vc_t with the same size in characters.
        const gfx_font* font = vc_get_font();
        int pixels_x = font->width * size_x;
        int pixels_y = font->height * (size_y + 1); // Add 1 for status line.
        // Add margins that aren't large enough to fit a whole column or
        // row at the right and bottom.  This tests incremental update of
        // anything that might be displayed in the margins.
        pixels_x += font->width - 1;
        pixels_y += font->height - 1;
        vc_surface = gfx_create_surface(
            nullptr, pixels_x, pixels_y, /* stride= */ pixels_x,
            ZX_PIXEL_FORMAT_RGB_565, 0);
        EXPECT_TRUE(vc_surface, "");
        // This takes ownership of vc_surface.
        EXPECT_EQ(vc_init_gfx(vc_surface), ZX_OK, "");
        EXPECT_EQ(vc_alloc(&vc_dev, false), ZX_OK, "");
        EXPECT_EQ(vc_dev->columns, size_x, "");
        EXPECT_EQ(vc_rows(vc_dev), static_cast<int>(size_y), "");
        // Mark the console as active so that display updates get
        // propagated to vc_surface.
        vc_dev->active = true;
        // Propagate the initial display contents to vc_surface.
        vc_full_repaint(vc_dev);
        vc_gfx_invalidate_all(vc_dev);
    }

    ~TextconHelper() {
        delete[] textbuf;
        vc_free(vc_dev);
    }

    // Takes a snapshot of the vc_t's display.
    class DisplaySnapshot {
    public:
        DisplaySnapshot(TextconHelper* helper)
            : helper_(helper),
              snapshot_(new uint8_t[helper->vc_surface->len]) {
            memcpy(snapshot_.get(), helper->vc_surface->ptr,
                   helper->vc_surface->len);
        }

        // Returns whether the vc_t's display changed since the
        // snapshot was taken.
        bool ChangedSinceSnapshot() {
            return memcmp(snapshot_.get(), helper_->vc_surface->ptr,
                          helper_->vc_surface->len) != 0;
        }

        fbl::unique_ptr<char[]> ComparisonString() {
            vc_t* vc_dev = helper_->vc_dev;
            gfx_surface* vc_surface = helper_->vc_surface;
            // Add 1 to these sizes to account for the margins.
            uint32_t cmp_size_x = vc_dev->columns + 1;
            uint32_t cmp_size_y = vc_dev->rows + 1;
            uint32_t size_in_chars = cmp_size_x * cmp_size_y;

            fbl::unique_ptr<bool[]> diffs(new bool[size_in_chars]);
            for (uint32_t i = 0; i < size_in_chars; ++i)
                diffs[i] = false;

            for (uint32_t i = 0; i < vc_surface->len; ++i) {
                if (static_cast<uint8_t*>(vc_surface->ptr)[i] != snapshot_[i]) {
                    uint32_t pixel_index = i / vc_surface->pixelsize;
                    uint32_t x_pixels = pixel_index % vc_surface->stride;
                    uint32_t y_pixels = pixel_index / vc_surface->stride;
                    uint32_t x_chars = x_pixels / vc_dev->charw;
                    uint32_t y_chars = y_pixels / vc_dev->charh;
                    EXPECT_LT(x_chars, cmp_size_x, "");
                    EXPECT_LT(y_chars, cmp_size_y, "");
                    diffs[x_chars + y_chars * cmp_size_x] = true;
                }
            }

            // Build a string showing the differences.  If we had
            // std::string or equivalent, we'd use that here.
            size_t string_size = (cmp_size_x + 3) * cmp_size_y + 1;
            fbl::unique_ptr<char[]> string(new char[string_size]);
            char* ptr = string.get();
            for (uint32_t y = 0; y < cmp_size_y; ++y) {
                *ptr++ = '|';
                for (uint32_t x = 0; x < cmp_size_x; ++x) {
                    bool diff = diffs[x + y * cmp_size_x];
                    *ptr++ = diff ? 'D' : '-';
                }
                *ptr++ = '|';
                *ptr++ = '\n';
            }
            *ptr++ = 0;
            EXPECT_EQ(ptr, string.get() + string_size, "");
            return string;
        }

        // Prints a representation of which characters in the vc_t's
        // display changed since the snapshot was taken.
        void PrintComparison() {
            printf("%s", ComparisonString().get());
        }

    private:
        TextconHelper* helper_;
        fbl::unique_ptr<uint8_t[]> snapshot_;
    };

    void InvalidateAllGraphics() {
        vc_full_repaint(vc_dev);
        vc_gfx_invalidate_all(vc_dev);
    }

    void PutString(const char* str) {
        for (const char* ptr = str; *ptr; ++ptr)
            textcon.putc(&textcon, *ptr);

        vc_write(vc_dev, str, strlen(str), 0);
        // Test that the incremental update of the display was correct.  We
        // do that by refreshing the entire display, and checking that
        // there was no change.
        DisplaySnapshot copy(this);
        InvalidateAllGraphics();
        if (copy.ChangedSinceSnapshot()) {
            copy.PrintComparison();
            EXPECT_TRUE(false, "Display contents changed");
        }
    }

    void AssertTextbufLineContains(vc_char_t* buf, int line_num,
                                   const char* str) {
        size_t len = strlen(str);
        EXPECT_LE(len, size_x, "");
        for (size_t i = 0; i < len; ++i)
            EXPECT_EQ(str[i], vc_char_get_char(buf[size_x * line_num + i]), "");
        // The rest of the line should contain spaces.
        for (size_t i = len; i < size_x; ++i)
            EXPECT_EQ(' ', vc_char_get_char(buf[size_x * line_num + i]), "");
    }

    void AssertLineContains(int line_num, const char* str) {
        AssertTextbufLineContains(textbuf, line_num, str);
        AssertTextbufLineContains(vc_dev->text_buf, line_num, str);
    }

    uint32_t size_x;
    uint32_t size_y;

    vc_char_t* textbuf;
    textcon_t textcon = {};

    gfx_surface* vc_surface;
    vc_t* vc_dev;
};

bool test_simple() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("Hello");
    tc.AssertLineContains(0, "Hello");
    tc.AssertLineContains(1, "");

    END_TEST;
}

// This tests the DisplaySnapshot test helper above.  If we write directly
// to vc_dev's text buffer without invalidating the display, the test
// machinery should detect which characters in the display were not updated
// properly.
bool test_display_update_comparison() {
    BEGIN_TEST;

    TextconHelper tc(10, 3);
    // Write some characters directly into the text buffer.
    auto SetChar = [&](int x, int y, char ch) {
        tc.vc_dev->text_buf[x + y * tc.size_x] =
            vc_char_make(ch, tc.textcon.fg, tc.textcon.bg);
    };
    SetChar(2, 1, 'x');
    SetChar(3, 1, 'y');
    SetChar(6, 1, 'z');

    // Check that these characters in the display are detected as not
    // properly updated.
    TextconHelper::DisplaySnapshot snapshot(&tc);
    tc.InvalidateAllGraphics();
    EXPECT_TRUE(snapshot.ChangedSinceSnapshot(), "");
    const char *expected =
        "|-----------|\n"  // Console status line
        "|-----------|\n"  // Cursor at left was painted during tc init
        "|--DD--D----|\n"  // Chars set by SetChar() above
        "|-----------|\n"
        "|-----------|\n"; // Bottom margin
    EXPECT_EQ(strcmp(snapshot.ComparisonString().get(), expected), 0, "");

    END_TEST;
}

bool test_wrapping() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("Hello world! More text here.");
    tc.AssertLineContains(0, "Hello worl");
    tc.AssertLineContains(1, "d! More te");
    tc.AssertLineContains(2, "xt here.");

    END_TEST;
}

bool test_tabs() {
    BEGIN_TEST;

    TextconHelper tc(80, 40);
    tc.PutString("\tA\n");
    tc.PutString(" \tB\n");
    tc.PutString("       \tC\n"); // 7 spaces
    tc.PutString("        \tD\n"); // 8 spaces
    tc.AssertLineContains(0, "        A");
    tc.AssertLineContains(1, "        B");
    tc.AssertLineContains(2, "        C");
    tc.AssertLineContains(3, "                D");

    END_TEST;
}

bool test_backspace_moves_cursor() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("ABCDEF\b\b\b\bxy");
    // Backspace only moves the cursor and does not erase, so "EF" is left
    // in place.
    tc.AssertLineContains(0, "ABxyEF");

    END_TEST;
}

bool test_backspace_at_start_of_line() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("Foo\n\bBar");
    // When the cursor is at the start of a line, backspace has no effect.
    tc.AssertLineContains(0, "Foo");
    tc.AssertLineContains(1, "Bar");

    END_TEST;
}

bool test_delete_chars() {
    BEGIN_TEST;

    TextconHelper tc(20, 10);

    tc.PutString("123456");
    // Move the cursor to be over the "3".
    tc.PutString("\b\b\b\b");
    // Delete 2 characters to the right of the cursor, using the "DCH"
    // escape sequence.  Any characters beyond that, on the right, are
    // moved to the left by 2 characters.  This escape sequence is a
    // reduced test from a fuzzer-discovered example (see ZX-2936).  This
    // used to trigger an assertion failure.
    tc.PutString("\x1b[2P");
    tc.AssertLineContains(0, "1256");

    END_TEST;
}

bool test_delete_chars_overflow() {
    BEGIN_TEST;

    TextconHelper tc(6, 10);

    // Fill the width of the console, leaving the cursor on the next line.
    tc.PutString("123456");
    // Move the cursor to be over the "3", to position (y+1,x+1) = (1,3).
    tc.PutString("\x1b[1;3H");
    // Request deleting 5 characters to the right of the cursor, using
    // the "DCH" escape sequence.  This tests an overflow case,
    // because there are only 4 characters to the right of the cursor.
    tc.PutString("\x1b[5P");
    tc.AssertLineContains(0, "12");

    END_TEST;
}

bool test_scroll_up() {
    BEGIN_TEST;

    TextconHelper tc(10, 4);
    tc.PutString("AAA\nBBB\nCCC\nDDD\n");
    tc.AssertLineContains(0, "BBB");
    tc.AssertLineContains(1, "CCC");
    tc.AssertLineContains(2, "DDD");
    tc.AssertLineContains(3, "");
    EXPECT_EQ(vc_get_scrollback_lines(tc.vc_dev), 1, "");

    END_TEST;
}

// Same as scroll_up(), but using ESC E (NEL) instead of "\n".
bool test_scroll_up_nel() {
    BEGIN_TEST;

    TextconHelper tc(10, 4);
    tc.PutString("AAA" "\x1b" "E"
                 "BBB" "\x1b" "E"
                 "CCC" "\x1b" "E"
                 "DDD" "\x1b" "E");
    tc.AssertLineContains(0, "BBB");
    tc.AssertLineContains(1, "CCC");
    tc.AssertLineContains(2, "DDD");
    tc.AssertLineContains(3, "");
    EXPECT_EQ(vc_get_scrollback_lines(tc.vc_dev), 1, "");

    END_TEST;
}

bool test_insert_lines() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("AAA\nBBB\nCCC\nDDD\nEEE");
    tc.PutString("\x1b[2A"); // Move the cursor up 2 lines
    tc.PutString("\x1b[2L"); // Insert 2 lines
    tc.PutString("Z"); // Output char to show where the cursor ends up
    tc.AssertLineContains(0, "AAA");
    tc.AssertLineContains(1, "BBB");
    tc.AssertLineContains(2, "   Z");
    tc.AssertLineContains(3, "");
    tc.AssertLineContains(4, "CCC");
    EXPECT_EQ(vc_get_scrollback_lines(tc.vc_dev), 0, "");

    END_TEST;
}

bool test_delete_lines() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("AAA\nBBB\nCCC\nDDD\nEEE");
    tc.PutString("\x1b[2A"); // Move the cursor up 2 lines
    tc.PutString("\x1b[2M"); // Delete 2 lines
    tc.PutString("Z"); // Output char to show where the cursor ends up
    tc.AssertLineContains(0, "AAA");
    tc.AssertLineContains(1, "BBB");
    tc.AssertLineContains(2, "EEEZ");
    tc.AssertLineContains(3, "");
    tc.AssertLineContains(4, "");
    // TODO(mseaborn): We probably don't want to be adding the deleted
    // lines to the scrollback in this case, because they are not from the
    // top of the console.
    EXPECT_EQ(vc_get_scrollback_lines(tc.vc_dev), 2, "");

    END_TEST;
}

// Test for a bug where this would cause an out-of-bounds array access.
bool test_insert_lines_many() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("AAA\nBBB");
    tc.PutString("\x1b[999L"); // Insert 999 lines
    tc.PutString("Z"); // Output char to show where the cursor ends up
    tc.AssertLineContains(0, "AAA");
    tc.AssertLineContains(1, "   Z");

    END_TEST;
}

// Test for a bug where this would cause an out-of-bounds array access.
bool test_delete_lines_many() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("AAA\nBBB");
    tc.PutString("\x1b[999M"); // Delete 999 lines
    tc.PutString("Z"); // Output char to show where the cursor ends up
    tc.AssertLineContains(0, "AAA");
    tc.AssertLineContains(1, "   Z");

    END_TEST;
}


// Check that passing a huge parameter via "insert lines" completes in a
// reasonable amount of time.  (We don't check the time here but we assume
// that someone will notice if this takes a long time.)
bool test_insert_lines_huge() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("AAA\nBBB");
    tc.PutString("\x1b[2000000000L"); // Insert lines
    tc.PutString("Z"); // Output char to show where the cursor ends up
    tc.AssertLineContains(0, "AAA");
    tc.AssertLineContains(1, "   Z");

    END_TEST;
}

// Check that passing a huge parameter via "delete lines" completes in a
// reasonable amount of time.  (We don't check the time here but we assume
// that someone will notice if this takes a long time.)
bool test_delete_lines_huge() {
    BEGIN_TEST;

    TextconHelper tc(10, 5);
    tc.PutString("AAA\nBBB");
    tc.PutString("\x1b[200000000M"); // Delete lines
    tc.PutString("Z"); // Output char to show where the cursor ends up
    tc.AssertLineContains(0, "AAA");
    tc.AssertLineContains(1, "   Z");

    END_TEST;
}

bool test_move_cursor_up_and_scroll() {
    BEGIN_TEST;

    TextconHelper tc(10, 4);
    tc.PutString("AAA\nBBB\nCCC\nDDD");
    tc.PutString("\x1bM" "1"); // Move cursor up; print char
    tc.PutString("\x1bM" "2"); // Move cursor up; print char
    tc.PutString("\x1bM" "3"); // Move cursor up; print char
    tc.PutString("\x1bM" "4"); // Move cursor up; print char
    tc.AssertLineContains(0, "      4");
    tc.AssertLineContains(1, "AAA  3");
    tc.AssertLineContains(2, "BBB 2");
    tc.AssertLineContains(3, "CCC1");

    END_TEST;
}

bool test_move_cursor_down_and_scroll() {
    BEGIN_TEST;

    TextconHelper tc(10, 4);
    tc.PutString("1" "\x1b" "D"); // Print char; move cursor down
    tc.PutString("2" "\x1b" "D"); // Print char; move cursor down
    tc.PutString("3" "\x1b" "D"); // Print char; move cursor down
    tc.PutString("4" "\x1b" "D"); // Print char; move cursor down
    tc.PutString("5");
    tc.AssertLineContains(0, " 2");
    tc.AssertLineContains(1, "  3");
    tc.AssertLineContains(2, "   4");
    tc.AssertLineContains(3, "    5");

    END_TEST;
}

bool test_cursor_hide_and_show() {
    BEGIN_TEST;

    TextconHelper tc(10, 4);
    ASSERT_FALSE(tc.vc_dev->hide_cursor, "");
    tc.PutString("\x1b[?25l"); // Hide cursor
    ASSERT_TRUE(tc.vc_dev->hide_cursor, "");
    tc.PutString("\x1b[?25h"); // Show cursor
    ASSERT_FALSE(tc.vc_dev->hide_cursor, "");

    END_TEST;
}

// This tests for a bug: If the cursor was positioned over a character when
// we scroll up, that character would get erased.
bool test_cursor_scroll_bug() {
    BEGIN_TEST;

    TextconHelper tc(10, 3);
    // Move the cursor to the bottom line.
    tc.PutString("\n\n\n");
    // Scroll down when the cursor is over "C".
    tc.PutString("ABCDE\b\b\b\n");

    END_TEST;
}

// Test for a bug where scrolling the console viewport by a large delta
// (e.g. going from the top to the bottom) can crash due to out-of-bounds
// memory accesses.
bool test_scroll_viewport_by_large_delta() {
    BEGIN_TEST;

    TextconHelper tc(2, 2);
    tc.PutString("\n");
    for (int lines = 1; lines < 100; ++lines) {
        tc.PutString("\n");

        // Scroll up, to show older lines.
        vc_scroll_viewport_top(tc.vc_dev);
        EXPECT_EQ(tc.vc_dev->viewport_y, -lines, "");

        // Scroll down, to show newer lines.
        vc_scroll_viewport_bottom(tc.vc_dev);
        EXPECT_EQ(tc.vc_dev->viewport_y, 0, "");
    }

    END_TEST;
}

// When the console is displaying only the main console region (and no
// scrollback), the console should keep displaying that as new lines are
// outputted.
bool test_viewport_scrolling_follows_bottom() {
    BEGIN_TEST;

    TextconHelper tc(1, 1);
    for (unsigned i = 0; i < tc.vc_dev->scrollback_rows_max * 2; ++i) {
        EXPECT_EQ(tc.vc_dev->viewport_y, 0, "");
        tc.PutString("\n");
    }

    END_TEST;
}

// When the console is displaying some of the scrollback buffer, then as
// new lines are outputted, the console should scroll the viewpoint to keep
// displaying the same point, unless we're at the top of the scrollback
// buffer.
bool test_viewport_scrolling_follows_scrollback() {
    BEGIN_TEST;

    TextconHelper tc(1, 1);
    // Add 3 lines to the scrollback buffer.
    tc.PutString("\n\n\n");
    vc_scroll_viewport(tc.vc_dev, -2);

    EXPECT_EQ(tc.vc_dev->viewport_y, -2, "");
    int limit = tc.vc_dev->scrollback_rows_max;
    for (int line = 3; line < limit * 2; ++line) {
        // Output different strings on each line in order to test that the
        // display is updated consistently when the console starts dropping
        // lines from the scrollback region.
        char str[3] = { static_cast<char>('0' + (line % 10)), '\n', '\0' };
        tc.PutString(str);
        EXPECT_EQ(tc.vc_dev->viewport_y, -MIN(line, limit), "");
    }

    END_TEST;
}

bool test_output_when_viewport_scrolled() {
    BEGIN_TEST;

    TextconHelper tc(10, 3);
    // Line 1 will move into the scrollback region.
    tc.PutString("1\n 2\n  3\n   4");
    EXPECT_EQ(tc.vc_dev->viewport_y, 0, "");
    vc_scroll_viewport_top(tc.vc_dev);

    EXPECT_EQ(tc.vc_dev->viewport_y, -1, "");
    // Check redrawing consistency.
    tc.PutString("");

    // Test that output updates the display correctly when the viewport is
    // scrolled.  Using two separate PutString() calls here was necessary
    // for reproducing an incremental update bug.
    tc.PutString("\x1b[1;1f"); // Move to top left
    tc.PutString("Epilobium");
    tc.AssertLineContains(0, "Epilobium");
    tc.AssertLineContains(1, "  3");
    tc.AssertLineContains(2, "   4");

    // Test that erasing also updates the display correctly.  This
    // changes the console contents without moving the cursor.
    tc.PutString("\b\b\b\b"); // Move cursor left 3 chars
    tc.PutString("\x1b[1K"); // Erase to beginning of line
    tc.AssertLineContains(0, "      ium");
    tc.AssertLineContains(1, "  3");
    tc.AssertLineContains(2, "   4");

    END_TEST;
}

bool test_scrolling_when_viewport_scrolled() {
    BEGIN_TEST;

    TextconHelper tc(10, 3);
    // Line 1 will move into the scrollback region.
    tc.PutString("1\n 2\n  3\n   4");
    EXPECT_EQ(tc.vc_dev->viewport_y, 0, "");
    vc_scroll_viewport_top(tc.vc_dev);
    EXPECT_EQ(tc.vc_dev->viewport_y, -1, "");
    // Check redrawing consistency.
    tc.PutString("");

    // Test that the display is updated correctly when we scroll.
    tc.PutString("\n5");
    tc.AssertLineContains(0, "  3");
    tc.AssertLineContains(1, "   4");
    tc.AssertLineContains(2, "5");

    END_TEST;
}

// Test that vc_get_scrollback_lines() gives the correct results.
bool test_scrollback_lines_count() {
    BEGIN_TEST;

    TextconHelper tc(10, 3);
    tc.PutString("\n\n");

    // Reduce the scrollback limit to make the test faster.
    const int kLimit = 20;
    EXPECT_LE(kLimit, tc.vc_dev->scrollback_rows_max, "");
    tc.vc_dev->scrollback_rows_max = kLimit;

    for (int lines = 1; lines < kLimit * 4; ++lines) {
        tc.PutString("\n");
        EXPECT_EQ(MIN(lines, kLimit),
                  vc_get_scrollback_lines(tc.vc_dev), "");
    }

    END_TEST;
}

// Test that the scrollback lines have the correct contents.
bool test_scrollback_lines_contents() {
    BEGIN_TEST;

    // Use a 1-row-high console, which simplifies this test.
    TextconHelper tc(3, 1);

    // Reduce the scrollback limit to make the test faster.
    const int kLimit = 20;
    EXPECT_LE(kLimit, tc.vc_dev->scrollback_rows_max, "");
    tc.vc_dev->scrollback_rows_max = kLimit;

    vc_char_t test_val = 0;
    for (int lines = 1; lines <= kLimit; ++lines) {
        tc.vc_dev->text_buf[0] = test_val++;
        tc.PutString("\n");

        EXPECT_EQ(lines, vc_get_scrollback_lines(tc.vc_dev), "");
        for (int i = 0; i < lines; ++i)
            EXPECT_EQ(i, vc_get_scrollback_line_ptr(tc.vc_dev, i)[0], "");
    }
    for (int lines = 0; lines < kLimit * 3; ++lines) {
        tc.vc_dev->text_buf[0] = test_val++;
        tc.PutString("\n");

        EXPECT_EQ(kLimit, vc_get_scrollback_lines(tc.vc_dev), "");
        for (int i = 0; i < kLimit; ++i) {
            EXPECT_EQ(test_val + i - kLimit,
                      vc_get_scrollback_line_ptr(tc.vc_dev, i)[0], "");
        }
    }

    END_TEST;
}

BEGIN_TEST_CASE(gfxconsole_textbuf_tests)
RUN_TEST(test_simple)
RUN_TEST(test_display_update_comparison)
RUN_TEST(test_wrapping)
RUN_TEST(test_tabs)
RUN_TEST(test_backspace_moves_cursor)
RUN_TEST(test_backspace_at_start_of_line)
RUN_TEST(test_delete_chars)
RUN_TEST(test_delete_chars_overflow)
RUN_TEST(test_scroll_up)
RUN_TEST(test_scroll_up_nel)
RUN_TEST(test_insert_lines)
RUN_TEST(test_delete_lines)
RUN_TEST(test_insert_lines_many)
RUN_TEST(test_delete_lines_many)
RUN_TEST(test_insert_lines_huge)
RUN_TEST(test_delete_lines_huge)
RUN_TEST(test_move_cursor_up_and_scroll)
RUN_TEST(test_move_cursor_down_and_scroll)
RUN_TEST(test_cursor_hide_and_show)
RUN_TEST(test_cursor_scroll_bug)
RUN_TEST(test_scroll_viewport_by_large_delta)
RUN_TEST(test_viewport_scrolling_follows_bottom)
RUN_TEST(test_viewport_scrolling_follows_scrollback)
RUN_TEST(test_output_when_viewport_scrolled)
RUN_TEST(test_scrolling_when_viewport_scrolled)
RUN_TEST(test_scrollback_lines_count)
RUN_TEST(test_scrollback_lines_contents)
END_TEST_CASE(gfxconsole_textbuf_tests)

}