github.com/Konstantin8105/c4go@v0.0.0-20240505174241-768bb1c65a51/tests/enum.c (about)

     1  #include "tests.h"
     2  #include <stdio.h>
     3  
     4  /* Text */
     5  enum number { zero,
     6      one,
     7      two,
     8      three };
     9  
    10  /**
    11   * Text
    12   */
    13  /** <b> Text </b> */
    14  enum year { Jan,
    15      Feb,
    16      Mar,
    17      Apr,
    18      May,
    19      Jun,
    20      Jul,
    21      Aug,
    22      Sep,
    23      Oct,
    24      Nov,
    25      Dec };
    26  
    27  // Text
    28  enum State { Working = 1,
    29      Failed = 0,
    30      Freezed = 0 };
    31  
    32  // Text
    33  // Text
    34  enum day { sunday = 1,
    35      monday,
    36      tuesday = 5,
    37      wednesday,
    38      thursday = 10,
    39      friday,
    40      saturday };
    41  
    42  enum state { WORKING = 0,
    43      FAILED,
    44      FREEZED };
    45  enum state currState = 2;
    46  enum state FindState() { return currState; }
    47  
    48  enum { FLY,
    49      JUMP };
    50  
    51  /// TYPEDEF
    52  typedef enum {
    53      a,
    54      b,
    55      c
    56  } T_ENUM;
    57  
    58  /**
    59   * Text 
    60   */
    61  typedef enum e_strategy { RANDOM,
    62      IMMEDIATE = 5,
    63      SEARCH } strategy;
    64  
    65  typedef struct StructWithEnum {
    66      enum {
    67          SWE_ENUM_ONE = 1
    68      };
    69      enum EnumTwo {
    70          SWE_ENUM_TWO = 2
    71      };
    72      enum {
    73          SWE_ENUM_THREE = 3
    74      } EnumThree;
    75      enum EnumFourBase {
    76          SWE_ENUM_FOUR = 4
    77      } EnumFour;
    78      struct StructFourBase {
    79          int y;
    80      } StructFour;
    81      union UnionFourBase {
    82          int y;
    83      } UnionFour;
    84  } SWE;
    85  void test_enum_inside_struct()
    86  {
    87      is_eq(SWE_ENUM_ONE, 1);
    88      is_eq(SWE_ENUM_TWO, 2);
    89      is_eq(SWE_ENUM_THREE, 3);
    90      is_eq(SWE_ENUM_FOUR, 4);
    91  }
    92  
    93  enum {
    94      parent = (9),
    95      usually = 10
    96  };
    97  enum nameParent {
    98      parent2 = (9),
    99      usually2 = 10,
   100      unar = (-1)
   101  };
   102  void test_parent()
   103  {
   104      is_eq(parent, 9);
   105      is_eq(usually, 10);
   106      enum nameParent p = parent2;
   107      is_eq(p, parent2);
   108      is_eq(p, 9);
   109      p = usually2;
   110      is_eq(p, usually2);
   111      is_eq(p, 10);
   112      p = unar;
   113      is_eq(p, unar);
   114      is_eq(p, -1);
   115  }
   116  
   117  typedef enum {
   118      IEEE_ = -1, /* According to IEEE 754/IEEE 854.  */
   119      SVID_, /* According to System V, release 4.  */
   120      XOPEN_, /* Nowadays also Unix98.  */
   121      POSIX_,
   122      ISOC_ /* Actually this is ISO C99.  */
   123  } LIB_VERSION_TYPE;
   124  void test_unary()
   125  {
   126      is_eq(IEEE_, -1);
   127      is_eq(XOPEN_, 1);
   128  }
   129  
   130  // test of comments
   131  typedef enum {
   132      PARG_NOARG, /**< No argument */
   133      PARG_REQARG, /**< Required argument */
   134      PARG_OPTARG /**< Optional argument */
   135  } parg_arg_num;
   136  
   137  enum { e1 = 1,
   138      e2 };
   139  
   140  enum {
   141      MBchar = 'U',
   142      Troffchar = 'C',
   143      Number = 'N',
   144      Install = 'i',
   145      Lookup = 'l'
   146  };
   147  
   148  enum Bool { false = 0,
   149      true = 1 };
   150  typedef enum Bool bool;
   151  bool Bool_test()
   152  {
   153      return true;
   154  }
   155  
   156  // main function
   157  int main()
   158  {
   159      plan(48);
   160  
   161      is_eq(MBchar, 'U');
   162  
   163      test_unary();
   164      test_parent();
   165      test_enum_inside_struct();
   166  
   167      // step 0
   168      is_eq(e1, 1);
   169      is_eq(e2, 2);
   170  
   171      // step 1
   172      enum number n;
   173      n = two;
   174      is_eq(two, 2);
   175      is_eq(n, 2);
   176  
   177      // step 3
   178      for (int i = Jan; i < Feb; i++) {
   179          is_eq(i, Jan);
   180      }
   181  
   182      // step 4
   183      is_eq(Working, 1);
   184      is_eq(Failed, 0);
   185      is_eq(Freezed, 0);
   186  
   187      // step 5
   188      enum day d = thursday;
   189      is_eq(d, 10);
   190  
   191      // step 6
   192      is_eq(sunday, 1);
   193      is_eq(monday, 2);
   194      is_eq(tuesday, 5);
   195      is_eq(wednesday, 6);
   196      is_eq(thursday, 10);
   197      is_eq(friday, 11);
   198      is_eq(saturday, 12);
   199  
   200      // step 7
   201      is_eq(FindState(), FREEZED);
   202  
   203      // step
   204      T_ENUM cc = a;
   205      is_eq(cc, a);
   206      cc = c;
   207      is_eq(cc, c);
   208      cc = (T_ENUM)(1);
   209      is_eq(cc, b);
   210  
   211      // step
   212      strategy str = RANDOM;
   213      is_eq(str, RANDOM);
   214      enum e_strategy e_str = RANDOM;
   215      is_eq(e_str, RANDOM);
   216      is_eq(str, e_str);
   217      is_eq(IMMEDIATE, 5);
   218      is_eq(SEARCH, 6);
   219  
   220      // step
   221      is_eq(FLY, 0);
   222      is_eq(JUMP, 1);
   223  
   224      diag("sizeof");
   225      is_eq(sizeof(JUMP), sizeof(int));
   226      is_eq(sizeof(Jan), sizeof(int));
   227  
   228      diag("Bool");
   229      is_eq(true, 1);
   230      is_eq(false, 0);
   231      is_true(Bool_test() == true);
   232      bool isglobal = true;
   233      if (isglobal) {
   234          pass("ok");
   235      }
   236      if (!isglobal) {
   237          fail("ok");
   238      }
   239  
   240      done_testing();
   241  }