#include "token.h"
// https://github.com/sheredom/utest.h/blob/master/utest.h
#include "utest.h"
#include <stdio.h>

typedef struct yy_buffer_state *YY_BUFFER_STATE;
extern void yyrestart(FILE * input_file);
extern YY_BUFFER_STATE yy_scan_buffer(char *str, int i);
extern void yy_delete_buffer(YY_BUFFER_STATE buffer);
extern FILE *yyin;
extern int yylex();
extern char *yytext;

UTEST_MAIN();

struct token_st {
  yytoken_kind_t t;
  char *p;
};

UTEST(scanner, hello) {
  struct token_st tokens[] = {
    {TOKEN_KEYWORD_IDENTIFICATION, "IDENTIFICATION"},
    {TOKEN_KEYWORD_DIVISION, "DIVISION"},
    {TOKEN_DOT, "."},
    {TOKEN_PROGRAM_ID, "PROGRAM-ID"},
    {TOKEN_DOT, "."}, 
    {TOKEN_IDENT, "HELLO-WORLD"},
    {TOKEN_DOT, "."},
    {TOKEN_PROCEDURE, "PROCEDURE"},
    {TOKEN_KEYWORD_DIVISION, "DIVISION"},
    {TOKEN_DOT, "."},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "Hello World!"},
    {TOKEN_STOP, "STOP"},
    {TOKEN_RUN, "RUN"},
    {TOKEN_DOT, "."},
    {TOKEN_EOF, ""},
  };


  yyin = fopen("samples/hello-world.cbl", "r");
  ASSERT_TRUE(yyin);
  int index = 0;
  yytoken_kind_t t;
  do {
    printf("index: %d token: %d text: %s\n", index, t, yytext);
    ASSERT_EQ(tokens[index].t, (t = yylex()));
    ASSERT_STREQ(tokens[index].p, yytext);
    ++index;
  } while (t != TOKEN_EOF);
}

UTEST(scanner, quadratic) {
  struct token_st tokens[] = {
    {TOKEN_KEYWORD_IDENTIFICATION, "IDENTIFICATION"},
    {TOKEN_KEYWORD_DIVISION, "DIVISION"},
    {TOKEN_DOT, "."},
    {TOKEN_PROGRAM_ID, "PROGRAM-ID"},
    {TOKEN_DOT, "."}, 
    {TOKEN_IDENT, "QuadraticSolver"},
    {TOKEN_DOT, "."},
    {TOKEN_KEYWORD_DATA, "DATA"},
    {TOKEN_KEYWORD_DIVISION, "DIVISION"},
    {TOKEN_DOT, "."},

    {TOKEN_WORKING_STORAGE, "WORKING-STORAGE"},
    {TOKEN_KEYWORD_SECTION, "SECTION"},
    {TOKEN_DOT, "."},

    {TOKEN_INTEGER, "77"},
    {TOKEN_IDENT, "a"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"}, // Check later
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_IMPLIED_DECIMAL, "V9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_3, "COMP-3"},
    {TOKEN_KEYWORD_VALUE, "VALUE"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_DOT, "."},

    {TOKEN_INTEGER, "77"},
    {TOKEN_IDENT, "b"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_IMPLIED_DECIMAL, "V9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_3, "COMP-3"},
    {TOKEN_KEYWORD_VALUE, "VALUE"},
    {TOKEN_INTEGER, "5"},
    {TOKEN_DOT, "."},

    {TOKEN_INTEGER, "77"},
    {TOKEN_IDENT, "c"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_IMPLIED_DECIMAL, "V9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_3, "COMP-3"},
    {TOKEN_KEYWORD_VALUE, "VALUE"},
    {TOKEN_INTEGER, "6"},
    {TOKEN_DOT, "."},

    {TOKEN_INTEGER, "77"},
    {TOKEN_IDENT, "discriminant"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_IMPLIED_DECIMAL, "V9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_3, "COMP-3"},
    {TOKEN_DOT, "."},

    {TOKEN_INTEGER, "77"},
    {TOKEN_IDENT, "root1"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_IMPLIED_DECIMAL, "V9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_3, "COMP-3"},
    {TOKEN_DOT, "."},

    {TOKEN_INTEGER, "77"},
    {TOKEN_IDENT, "root2"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_IMPLIED_DECIMAL, "V9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_3, "COMP-3"},
    {TOKEN_DOT, "."},

    {TOKEN_INTEGER, "77"},
    {TOKEN_IDENT, "square-root-discriminant"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_IMPLIED_DECIMAL, "V9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_3, "COMP-3"},
    {TOKEN_DOT, "."},

    // {TOKEN_EOF, ""},

    {TOKEN_PROCEDURE, "PROCEDURE"},
    {TOKEN_KEYWORD_DIVISION, "DIVISION"},
    {TOKEN_DOT, "."},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"EQUATION: (1x^2) + 5x + 6 = 0\""},
    {TOKEN_KEYWORD_COMPUTE, "COMPUTE"},
    {TOKEN_IDENT, "discriminant"},
    {TOKEN_EQUAL, "="},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "b"},
    {TOKEN_EXPONENTIAL, "**"},
    {TOKEN_INTEGER, "2"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_SUB, "-"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "4"},
    {TOKEN_MULTIPLY, "*"},
    {TOKEN_IDENT, "a"},
    {TOKEN_MULTIPLY, "*"},
    {TOKEN_IDENT, "c"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},

    // {TOKEN_EOF, ""},

    {TOKEN_IF, "IF"},
    {TOKEN_IDENT, "discriminant"},
    {TOKEN_GREATER_THAN, ">"},
    {TOKEN_INTEGER, "0"},

    {TOKEN_KEYWORD_COMPUTE, "COMPUTE"},
    {TOKEN_IDENT, "square-root-discriminant"},
    {TOKEN_EQUAL, "="},
    {TOKEN_KEYWORD_FUNCTION, "FUNCTION"},
    {TOKEN_IDENT, "SQRT"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "discriminant"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},


    {TOKEN_KEYWORD_COMPUTE, "COMPUTE"},
    {TOKEN_IDENT, "root1"},
    {TOKEN_EQUAL, "="},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_SUB, "-"},
    {TOKEN_IDENT, "b"},
    {TOKEN_ADD, "+"},
    {TOKEN_IDENT, "square-root-discriminant"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_DIVIDE, "/"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "2"},
    {TOKEN_MULTIPLY, "*"},
    {TOKEN_IDENT, "a"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},

    {TOKEN_KEYWORD_COMPUTE, "COMPUTE"},
    {TOKEN_IDENT, "root2"},
    {TOKEN_EQUAL, "="},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_SUB, "-"},
    {TOKEN_IDENT, "b"},
    {TOKEN_SUB, "-"},
    {TOKEN_IDENT, "square-root-discriminant"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_DIVIDE, "/"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "2"},
    {TOKEN_MULTIPLY, "*"},
    {TOKEN_IDENT, "a"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},

    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"The equation has two distinct real roots: \""},

    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"Root 1: \""},
    {TOKEN_IDENT, "root1"},

    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"Root 2: \""},
    {TOKEN_IDENT, "root2"},

    // {TOKEN_EOF, ""},

    {TOKEN_ELSE, "ELSE"},
    {TOKEN_IF, "IF"},
    {TOKEN_IDENT, "discriminant"},
    {TOKEN_EQUAL, "="},
    {TOKEN_INTEGER, "0"},

    {TOKEN_KEYWORD_COMPUTE, "COMPUTE"},
    {TOKEN_IDENT, "root1"},
    {TOKEN_EQUAL, "="},
    {TOKEN_SUB, "-"},
    {TOKEN_IDENT, "b"},
    {TOKEN_DIVIDE, "/"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "2"},
    {TOKEN_MULTIPLY, "*"},
    {TOKEN_IDENT, "a"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},


    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"The equation has one real root: \""},

    {TOKEN_DISPLAY, "DISPLAY"},   
    {TOKEN_STRING, "\"Root: \""},
    {TOKEN_IDENT, "root1"},


    {TOKEN_ELSE, "ELSE"},

    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"The equation has no real roots.\""},
    {TOKEN_END_IF, "END-IF"},

    // {TOKEN_EOF, ""},

    {TOKEN_STOP, "STOP"},
    {TOKEN_RUN, "RUN"},
    {TOKEN_DOT, "."},
    {TOKEN_EOF, ""},
  };

  yyin = fopen("samples/quadratic-snippet.cbl", "r");
  ASSERT_TRUE(yyin);
  int index = 0;
  yytoken_kind_t t;
  do {
    printf("index: %d token: %d text: %s\n", index, t, yytext);
    ASSERT_EQ(tokens[index].t, (t = yylex()));
    ASSERT_STREQ(tokens[index].p, yytext);
    ++index;
  } while (t != TOKEN_EOF);
}

UTEST(scanner, sorting) {
  struct token_st tokens[] = {
    {TOKEN_KEYWORD_IDENTIFICATION, "IDENTIFICATION"},
    {TOKEN_KEYWORD_DIVISION, "DIVISION"},
    {TOKEN_DOT, "."},
    {TOKEN_PROGRAM_ID, "PROGRAM-ID"},
    {TOKEN_DOT, "."},
    {TOKEN_IDENT, "sorting"},
    {TOKEN_DOT, "."},
    {TOKEN_KEYWORD_DATA, "DATA"},
    {TOKEN_KEYWORD_DIVISION, "DIVISION"},
    {TOKEN_DOT, "."},
    {TOKEN_WORKING_STORAGE, "WORKING-STORAGE"},
    {TOKEN_KEYWORD_SECTION, "SECTION"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "01"},
    {TOKEN_IDENT, "WS-SORT-AREA"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "05"},
    {TOKEN_IDENT, "WS-SORT-TABLE"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "10"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_ALPHANUMERIC, "X"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "10"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_KEYWORD_OCCURS, "OCCURS"},
    {TOKEN_INTEGER, "100"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "05"},
    {TOKEN_IDENT, "WS-TEMP-ROW"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_ALPHANUMERIC, "X"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "10"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "05"},
    {TOKEN_IDENT, "WS-ROW-MAX"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "4"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_0, "COMP"},
    {TOKEN_KEYWORD_VALUE, "VALUE"},
    {TOKEN_INTEGER, "100"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "05"},
    {TOKEN_IDENT, "WS-SORT-MAX"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "4"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_0, "COMP"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "05"},
    {TOKEN_IDENT, "WS-I"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "4"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_0, "COMP"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "05"},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "4"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_0, "COMP"},
    {TOKEN_DOT, "."},
    {TOKEN_INTEGER, "05"},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_PICTURE, "PIC"},
    {TOKEN_SIGNED_NUMERIC, "S9"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "4"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_COMPUTATION_LEVEL_0, "COMP"},
    {TOKEN_DOT, "."},
    {TOKEN_PROCEDURE, "PROCEDURE"},
    {TOKEN_KEYWORD_DIVISION, "DIVISION"},
    {TOKEN_DOT, "."},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_STRING, "\"30\""},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "1"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_STRING, "\"10\""},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "2"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_STRING, "\"50\""},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},  
    {TOKEN_INTEGER, "3"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_STRING, "\"20\""},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "4"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_STRING, "\"40\""},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_INTEGER, "5"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_INTEGER, "5"},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-SORT-MAX"},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"Original Array Contents:\""},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"---------------------\""},
    {TOKEN_PERFORM, "PERFORM"},
    {TOKEN_VARYING, "VARYING"},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_KEYWORD_FROM, "FROM"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_KEYWORD_BY, "BY"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_UNTIL, "UNTIL"},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_GREATER_THAN, ">"},
    {TOKEN_IDENT, "WS-SORT-MAX"},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"Element \""},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_STRING, "\": \""},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_END_PERFORM, "END-PERFORM"},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_SPACE, "SPACE"},
    {TOKEN_PERFORM, "PERFORM"},
    {TOKEN_VARYING, "VARYING"},
    {TOKEN_IDENT, "WS-I"},
    {TOKEN_KEYWORD_FROM, "FROM"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_KEYWORD_BY, "BY"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_UNTIL, "UNTIL"},
    {TOKEN_IDENT, "WS-I"},
    {TOKEN_GREATER_THAN, ">"},
    {TOKEN_IDENT, "WS-SORT-MAX"},
    {TOKEN_SUB, "-"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_PERFORM, "PERFORM"},
    {TOKEN_VARYING, "VARYING"},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_KEYWORD_FROM, "FROM"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_KEYWORD_BY, "BY"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_UNTIL, "UNTIL"},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_GREATER_THAN, ">"},
    {TOKEN_IDENT, "WS-SORT-MAX"},
    {TOKEN_SUB, "-"},
    {TOKEN_IDENT, "WS-I"},
    {TOKEN_IF, "IF"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_GREATER_THAN, ">"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_ADD, "+"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-TEMP-ROW"},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_ADD, "+"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_MOVE, "MOVE"},
    {TOKEN_IDENT, "WS-TEMP-ROW"},
    {TOKEN_KEYWORD_TO, "TO"},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "WS-J"},
    {TOKEN_ADD, "+"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_END_IF, "END-IF"},
    {TOKEN_END_PERFORM, "END-PERFORM"},
    {TOKEN_END_PERFORM, "END-PERFORM"},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"Sorted Array Contents:\""},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"--------------------\""},
    {TOKEN_PERFORM, "PERFORM"},
    {TOKEN_VARYING, "VARYING"},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_KEYWORD_FROM, "FROM"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_KEYWORD_BY, "BY"},
    {TOKEN_INTEGER, "1"},
    {TOKEN_UNTIL, "UNTIL"},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_GREATER_THAN, ">"},
    {TOKEN_IDENT, "WS-SORT-MAX"},
    {TOKEN_DISPLAY, "DISPLAY"},
    {TOKEN_STRING, "\"Element \""},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_STRING, "\": \""},
    {TOKEN_IDENT, "WS-SORT-ROW"},
    {TOKEN_LEFT_PARENTHESIS, "("},
    {TOKEN_IDENT, "WS-INDEX"},
    {TOKEN_RIGHT_PARENTHESIS, ")"},
    {TOKEN_END_PERFORM, "END-PERFORM"},
    {TOKEN_DOT, "."},
    {TOKEN_STOP, "STOP"},
    {TOKEN_RUN, "RUN"},
    {TOKEN_DOT, "."},
    {TOKEN_EOF, ""},
  };
  yyin = fopen("samples/sorting-snippet.cbl", "r");
  ASSERT_TRUE(yyin);
  int index = 0;
  yytoken_kind_t t;
  do {
    printf("index: %d token: %d text: %s\n", index, t, yytext);
    ASSERT_EQ(tokens[index].t, (t = yylex()));
    ASSERT_STREQ(tokens[index].p, yytext);
    ++index;
  } while (t != TOKEN_EOF);
}