TestSimplifyTypedef() : TestFixture("TestSimplifyTypedef") {}

const Settings settings0 = settingsBuilder().severity(Severity::style).build();

const Settings settings1 = settingsBuilder().severity(Severity::portability).build();

void run() override {

TEST_CASE(c1);

TEST_CASE(c2);

TEST_CASE(canreplace1);

TEST_CASE(canreplace2);

TEST_CASE(canreplace3);

TEST_CASE(canreplace4);

TEST_CASE(cconst);

TEST_CASE(cstruct1);

TEST_CASE(cstruct2);

TEST_CASE(cstruct3);

TEST_CASE(cstruct3);

TEST_CASE(cstruct4);

TEST_CASE(cenum1);

TEST_CASE(cfunction1);

TEST_CASE(cfunction2);

TEST_CASE(cfunction3);

TEST_CASE(cfp1);

TEST_CASE(cfp2);

TEST_CASE(cfp4);

TEST_CASE(cfp5);

TEST_CASE(cfp6);

TEST_CASE(cfp7);

TEST_CASE(carray1);

TEST_CASE(carray2);

TEST_CASE(carray3);

TEST_CASE(carray4);

TEST_CASE(cdonotreplace1);

TEST_CASE(cppfp1);

TEST_CASE(Generic1);

TEST_CASE(simplifyTypedef1);

TEST_CASE(simplifyTypedef2);

TEST_CASE(simplifyTypedef3);

TEST_CASE(simplifyTypedef4);

TEST_CASE(simplifyTypedef5);

TEST_CASE(simplifyTypedef6);

TEST_CASE(simplifyTypedef7);

TEST_CASE(simplifyTypedef8);

TEST_CASE(simplifyTypedef9);

TEST_CASE(simplifyTypedef10);

TEST_CASE(simplifyTypedef11);

TEST_CASE(simplifyTypedef12);

TEST_CASE(simplifyTypedef13);

TEST_CASE(simplifyTypedef14);

TEST_CASE(simplifyTypedef15);

TEST_CASE(simplifyTypedef16);

TEST_CASE(simplifyTypedef17);

TEST_CASE(simplifyTypedef18); // typedef vector<int[4]> a;

TEST_CASE(simplifyTypedef19);

TEST_CASE(simplifyTypedef20);

TEST_CASE(simplifyTypedef21);

TEST_CASE(simplifyTypedef22);

TEST_CASE(simplifyTypedef23);

TEST_CASE(simplifyTypedef24);

TEST_CASE(simplifyTypedef25);

TEST_CASE(simplifyTypedef26);

TEST_CASE(simplifyTypedef27);

TEST_CASE(simplifyTypedef28);

TEST_CASE(simplifyTypedef29);

TEST_CASE(simplifyTypedef30);

TEST_CASE(simplifyTypedef31);

TEST_CASE(simplifyTypedef32);

TEST_CASE(simplifyTypedef33);

TEST_CASE(simplifyTypedef34); // ticket #1411

TEST_CASE(simplifyTypedef35);

TEST_CASE(simplifyTypedef36); // ticket #1434

TEST_CASE(simplifyTypedef37); // ticket #1449

TEST_CASE(simplifyTypedef38);

TEST_CASE(simplifyTypedef43); // ticket #1588

TEST_CASE(simplifyTypedef44);

TEST_CASE(simplifyTypedef45); // ticket #1613

TEST_CASE(simplifyTypedef46);

TEST_CASE(simplifyTypedef47);

TEST_CASE(simplifyTypedef48); // ticket #1673

TEST_CASE(simplifyTypedef49); // ticket #1691

TEST_CASE(simplifyTypedef50);

TEST_CASE(simplifyTypedef51);

TEST_CASE(simplifyTypedef52); // ticket #1782

TEST_CASE(simplifyTypedef54); // ticket #1814

TEST_CASE(simplifyTypedef55);

TEST_CASE(simplifyTypedef56); // ticket #1829

TEST_CASE(simplifyTypedef57); // ticket #1846

TEST_CASE(simplifyTypedef58); // ticket #1963

TEST_CASE(simplifyTypedef59); // ticket #2011

TEST_CASE(simplifyTypedef60); // ticket #2035

TEST_CASE(simplifyTypedef61); // ticket #2074 and 2075

TEST_CASE(simplifyTypedef62); // ticket #2082

TEST_CASE(simplifyTypedef63); // ticket #2175 'typedef float x[3];'

TEST_CASE(simplifyTypedef64);

TEST_CASE(simplifyTypedef65); // ticket #2314

TEST_CASE(simplifyTypedef66); // ticket #2341

TEST_CASE(simplifyTypedef67); // ticket #2354

TEST_CASE(simplifyTypedef68); // ticket #2355

TEST_CASE(simplifyTypedef69); // ticket #2348

TEST_CASE(simplifyTypedef70); // ticket #2348

TEST_CASE(simplifyTypedef71); // ticket #2348

TEST_CASE(simplifyTypedef72); // ticket #2375

TEST_CASE(simplifyTypedef73); // ticket #2412

TEST_CASE(simplifyTypedef74); // ticket #2414

TEST_CASE(simplifyTypedef75); // ticket #2426

TEST_CASE(simplifyTypedef76); // ticket #2453

TEST_CASE(simplifyTypedef77); // ticket #2554

TEST_CASE(simplifyTypedef78); // ticket #2568

TEST_CASE(simplifyTypedef79); // ticket #2348

TEST_CASE(simplifyTypedef80); // ticket #2587

TEST_CASE(simplifyTypedef81); // ticket #2603

TEST_CASE(simplifyTypedef82); // ticket #2403

TEST_CASE(simplifyTypedef83); // ticket #2620

TEST_CASE(simplifyTypedef84); // ticket #2630

TEST_CASE(simplifyTypedef85); // ticket #2651

TEST_CASE(simplifyTypedef86); // ticket #2581

TEST_CASE(simplifyTypedef87); // ticket #2651

TEST_CASE(simplifyTypedef88); // ticket #2675

TEST_CASE(simplifyTypedef89); // ticket #2717

TEST_CASE(simplifyTypedef90); // ticket #2718

TEST_CASE(simplifyTypedef91); // ticket #2716

TEST_CASE(simplifyTypedef92); // ticket #2736

TEST_CASE(simplifyTypedef93); // ticket #2738

TEST_CASE(simplifyTypedef94); // ticket #1982

TEST_CASE(simplifyTypedef95); // ticket #2844

TEST_CASE(simplifyTypedef96); // ticket #2886

TEST_CASE(simplifyTypedef97); // ticket #2983 (segmentation fault)

TEST_CASE(simplifyTypedef99); // ticket #2999

TEST_CASE(simplifyTypedef100); // ticket #3000

TEST_CASE(simplifyTypedef101); // ticket #3003 (segmentation fault)

TEST_CASE(simplifyTypedef102); // ticket #3004

TEST_CASE(simplifyTypedef103); // ticket #3007

TEST_CASE(simplifyTypedef104); // ticket #3070

TEST_CASE(simplifyTypedef105); // ticket #3616

TEST_CASE(simplifyTypedef106); // ticket #3619

TEST_CASE(simplifyTypedef107); // ticket #3963 - bad code => segmentation fault

TEST_CASE(simplifyTypedef108); // ticket #4777

TEST_CASE(simplifyTypedef109); // ticket #1823 - rvalue reference

TEST_CASE(simplifyTypedef110); // ticket #6268

TEST_CASE(simplifyTypedef111); // ticket #6345

TEST_CASE(simplifyTypedef112); // ticket #6048

TEST_CASE(simplifyTypedef113); // ticket #7030

TEST_CASE(simplifyTypedef114); // ticket #7058 - skip "struct", AB::..

TEST_CASE(simplifyTypedef115); // ticket #6998

TEST_CASE(simplifyTypedef116); // ticket #5624

TEST_CASE(simplifyTypedef117); // ticket #6507

TEST_CASE(simplifyTypedef118); // ticket #5749

TEST_CASE(simplifyTypedef119); // ticket #7541

TEST_CASE(simplifyTypedef120); // ticket #8357

TEST_CASE(simplifyTypedef121); // ticket #5766

TEST_CASE(simplifyTypedef122); // segmentation fault

TEST_CASE(simplifyTypedef123); // ticket #7406

TEST_CASE(simplifyTypedef124); // ticket #7792

TEST_CASE(simplifyTypedef125); // #8749 - typedef char A[10]; p = new A[1];

TEST_CASE(simplifyTypedef126); // ticket #5953

TEST_CASE(simplifyTypedef127); // ticket #8878

TEST_CASE(simplifyTypedef128); // ticket #9053

TEST_CASE(simplifyTypedef129);

TEST_CASE(simplifyTypedef130); // ticket #9446

TEST_CASE(simplifyTypedef131); // ticket #9446

TEST_CASE(simplifyTypedef132); // ticket #9739 - using

TEST_CASE(simplifyTypedef133); // ticket #9812 - using

TEST_CASE(simplifyTypedef134);

TEST_CASE(simplifyTypedef135); // ticket #10068

TEST_CASE(simplifyTypedef136);

TEST_CASE(simplifyTypedef137);

TEST_CASE(simplifyTypedef138);

TEST_CASE(simplifyTypedef139);

TEST_CASE(simplifyTypedef140); // #10798

TEST_CASE(simplifyTypedef141); // #10144

TEST_CASE(simplifyTypedef142); // T() when T is a pointer type

TEST_CASE(simplifyTypedef143); // #11506

TEST_CASE(simplifyTypedef144); // #9353

TEST_CASE(simplifyTypedef145); // #9353

TEST_CASE(simplifyTypedef146);

TEST_CASE(simplifyTypedef147);

TEST_CASE(simplifyTypedef148);

TEST_CASE(simplifyTypedef149);

TEST_CASE(simplifyTypedef150);

TEST_CASE(simplifyTypedef151);

TEST_CASE(simplifyTypedef152);

TEST_CASE(simplifyTypedefFunction1);

TEST_CASE(simplifyTypedefFunction2); // ticket #1685

TEST_CASE(simplifyTypedefFunction3);

TEST_CASE(simplifyTypedefFunction4);

TEST_CASE(simplifyTypedefFunction5);

TEST_CASE(simplifyTypedefFunction6);

TEST_CASE(simplifyTypedefFunction7);

TEST_CASE(simplifyTypedefFunction8);

TEST_CASE(simplifyTypedefFunction9);

TEST_CASE(simplifyTypedefFunction10); // #5191

TEST_CASE(simplifyTypedefStruct); // #12081 - volatile struct

TEST_CASE(simplifyTypedefShadow); // #4445 - shadow variable

TEST_CASE(simplifyTypedefMacro);

TEST_CASE(simplifyTypedefOriginalName);

}

#define tok(...) tok_(__FILE__, __LINE__, __VA_ARGS__)

std::string tok_(const char* file, int line, const char code[], bool simplify = true, Platform::Type type = Platform::Type::Native, bool debugwarnings = true) {

// show warnings about unhandled typedef

const Settings settings = settingsBuilder(settings0).certainty(Certainty::inconclusive).debugwarnings(debugwarnings).platform(type).build();

SimpleTokenizer tokenizer(settings, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

return tokenizer.tokens()->stringifyList(nullptr, !simplify);

}

std::string simplifyTypedef(const char code[]) {

Tokenizer tokenizer(settings1, *this);

std::istringstream istr(code);

if (!tokenizer.list.createTokens(istr, Standards::Language::CPP))

return "";

tokenizer.createLinks();

tokenizer.simplifyTypedef();

return tokenizer.tokens()->stringifyList(nullptr, false);

}

std::string simplifyTypedefP(const char code[]) {

std::vector<std::string> files(1, "test.cpp");

Tokenizer tokenizer(settings0, *this);

PreprocessorHelper::preprocess(code, files, tokenizer, *this);

// Tokenize..

tokenizer.createLinks();

tokenizer.simplifyTypedef();

return tokenizer.tokens()->stringifyList(nullptr, false);

}

#define checkSimplifyTypedef(code) checkSimplifyTypedef_(code, __FILE__, __LINE__)

void checkSimplifyTypedef_(const char code[], const char* file, int line) {

// Tokenize..

// show warnings about unhandled typedef

const Settings settings = settingsBuilder(settings0).certainty(Certainty::inconclusive).debugwarnings().build();

SimpleTokenizer tokenizer(settings, *this);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

}

std::string simplifyTypedefC(const char code[]) {

Tokenizer tokenizer(settings1, *this);

std::istringstream istr(code);

if (!tokenizer.list.createTokens(istr, "file.c"))

return "";

tokenizer.createLinks();

tokenizer.simplifyTypedef();

try {

tokenizer.validate();

} catch (const InternalError&) {

return "";

}

return tokenizer.tokens()->stringifyList(nullptr, false);

}

void c1() {

const char code[] = "typedef int t;\n"

"t x;";

ASSERT_EQUALS("int x ;", simplifyTypedefC(code));

}

void c2() {

const char code[] = "void f1() { typedef int t; t x; }\n"

"void f2() { typedef float t; t x; }\n";

ASSERT_EQUALS("void f1 ( ) { int x ; } void f2 ( ) { float x ; }", simplifyTypedefC(code));

}

void canreplace1() {

const char code[] = "typedef unsigned char u8;\n"

"void f(uint8_t u8) { x = u8 & y; }\n";

ASSERT_EQUALS("void f ( uint8_t u8 ) { x = u8 & y ; }", simplifyTypedefC(code));

}

void canreplace2() {

const char code1[] = "typedef char* entry;\n"

"void f(Y* entry) { for (entry=x->y; entry; entry = entry->next) {} }\n";

ASSERT_EQUALS("void f ( Y * entry ) { for ( entry = x -> y ; entry ; entry = entry -> next ) { } }", simplifyTypedefC(code1));

const char code2[] = "typedef char* entry;\n"

"void f() { dostuff(entry * 2); }\n";

ASSERT_EQUALS("void f ( ) { dostuff ( entry * 2 ) ; }", simplifyTypedefC(code2));

const char code3[] = "typedef char* entry;\n"

"void f() { dostuff(entry * y < z); }\n";

ASSERT_EQUALS("void f ( ) { dostuff ( entry * y < z ) ; }", simplifyTypedefC(code3));

}

void canreplace3() {

const char code1[] = "typedef char* c_str;\n" // #11640

"struct S {\n"

" const char* g() const {\n"

" return s.c_str();\n"

" }\n"

" std::string s;\n"

"};\n";

ASSERT_EQUALS("struct S { const char * g ( ) const { return s . c_str ( ) ; } std :: string s ; } ;", simplifyTypedefC(code1));

}

void canreplace4() {

const char code1[] = "typedef std::vector<int> X;\n" // #12026

"struct S {\n"

" enum E { X };\n"

"};\n";

ASSERT_EQUALS("struct S { enum E { X } ; } ;", simplifyTypedef(code1));

}

void cconst() {

const char code1[] = "typedef void* HWND;\n"

"const HWND x;";

ASSERT_EQUALS("void * const x ;", simplifyTypedef(code1));

const char code2[] = "typedef void (*fp)();\n"

"const fp x;";

ASSERT_EQUALS("void ( * const x ) ( ) ;", simplifyTypedef(code2));

}

void cstruct1() {

const char code[] = "typedef struct { int a; int b; } t;\n"

"t x;";

ASSERT_EQUALS("struct t { int a ; int b ; } ; struct t x ;", simplifyTypedef(code));

ASSERT_EQUALS("struct t { int a ; int b ; } ; struct t x ;", simplifyTypedefC(code));

}

void cstruct2() {

const char code[] = "typedef enum { A, B } t;\n"

"t x;";

ASSERT_EQUALS("enum t { A , B } ; enum t x ;", simplifyTypedef(code));

ASSERT_EQUALS("enum t { A , B } ; enum t x ;", simplifyTypedefC(code));

}

void cstruct3() {

const char code[] = "typedef struct s { int a; int b; } t;\n"

"t x;";

ASSERT_EQUALS("struct s { int a ; int b ; } ; struct s x ;", simplifyTypedefC(code));

}

void cstruct4() {

const char code[] = "typedef struct s { int a; int b; } t;\n"

"struct t x{};";

ASSERT_EQUALS("struct s { int a ; int b ; } ; struct s x { } ;", simplifyTypedefC(code));

}

void cenum1() {

const char code[] = "typedef enum { a, b } E;\n"

"E e;";

ASSERT_EQUALS("enum E { a , b } ; enum E e ;", simplifyTypedefC(code));

}

void cfunction1() {

const char code[] = "typedef int callback(int);\n"

"callback* cb;";

ASSERT_EQUALS("int ( * cb ) ( int ) ;", simplifyTypedefC(code));

}

void cfunction2() {

const char code[] = "typedef int callback(int);\n"

"typedef callback* callbackPtr;\n"

"callbackPtr cb;";

ASSERT_EQUALS("int ( * cb ) ( int ) ;", simplifyTypedefC(code));

}

void cfunction3() {

const char code[] = "typedef int f(int);\n"

"typedef const f cf;\n";

simplifyTypedefC(code);

ASSERT_EQUALS("[file.c:2]: (portability) It is unspecified behavior to const qualify a function type.\n", errout_str());

}

void cfp1() {

const char code[] = "typedef void (*fp)(void * p);\n"

"fp x;";

ASSERT_EQUALS("void ( * x ) ( void * p ) ;", simplifyTypedefC(code));

}

void cfp2() {

const char code[] = "typedef void (*const fp)(void * p);\n"

"fp x;";

ASSERT_EQUALS("void ( * const x ) ( void * p ) ;", simplifyTypedefC(code));

}

void cfp4() {

const char code[] = "typedef struct S Stype ;\n"

"typedef void ( * F ) ( Stype * ) ;\n"

"F func;";

ASSERT_EQUALS("void ( * func ) ( struct S * ) ;", simplifyTypedefC(code));

}

void cfp5() {

const char code[] = "typedef void (*fp)(void);\n"

"typedef fp t;\n"

"void foo(t p);";

ASSERT_EQUALS("void foo ( void ( * p ) ( void ) ) ;", simplifyTypedef(code));

}

void cfp6() {

const char code[] = "typedef void (*fp)(void);\n"

"fp a[10];";

ASSERT_EQUALS("void ( * a [ 10 ] ) ( void ) ;", simplifyTypedef(code));

}

void cfp7() {

const char code[] = "typedef uint32_t ((*fp)(uint32_t n));\n" // #11725

"uint32_t g();\n"

"fp f;\n";

ASSERT_EQUALS("uint32_t g ( ) ; uint32_t ( * f ) ( uint32_t n ) ;", simplifyTypedef(code));

}

void carray1() {

const char code[] = "typedef int t[20];\n"

"t x;";

ASSERT_EQUALS("int x [ 20 ] ;", simplifyTypedefC(code));

}

void carray2() {

const char code[] = "typedef double t[4];\n"

"t x[10];";

ASSERT_EQUALS("double x [ 10 ] [ 4 ] ;", simplifyTypedef(code));

}

void carray3() {

const char* code{};

code = "typedef int a[256];\n" // #11689

"typedef a b[256];\n"

"b* p;\n";

ASSERT_EQUALS("int ( * p ) [ 256 ] [ 256 ] ;", simplifyTypedef(code));

code = "typedef int a[1];\n"

"typedef a b[2];\n"

"typedef b c[3];\n"

"c* p;\n";

ASSERT_EQUALS("int ( * p ) [ 3 ] [ 2 ] [ 1 ] ;", simplifyTypedef(code));

}

void carray4() {

const char* code{};

code = "typedef int arr[12];\n" // #12019

"void foo() { arr temp = {0}; }\n";

ASSERT_EQUALS("void foo ( ) { int temp [ 12 ] = { 0 } ; }", tok(code));

}

void cdonotreplace1() {

const char code[] = "typedef int t;\n"

"int* t;";

ASSERT_EQUALS("int * t ;", simplifyTypedefC(code));

}

void cppfp1() {

const char code[] = "typedef void (*fp)(void);\n"

"typedef fp t;\n"

"void foo(t p);";

ASSERT_EQUALS("void foo ( void ( * p ) ( void ) ) ;", tok(code));

}

void Generic1() {

const char code[] = "typedef void func(void);\n"

"_Generic((x), func: 1, default: 2);";

ASSERT_EQUALS("_Generic ( x , void ( ) : 1 , default : 2 ) ;", tok(code));

}

void simplifyTypedef1() {

const char code[] = "class A\n"

"{\n"

"public:\n"

" typedef wchar_t duplicate;\n"

" void foo() {}\n"

"};\n"

"typedef A duplicate;\n"

"int main()\n"

"{\n"

" duplicate a;\n"

" a.foo();\n"

" A::duplicate c = 0;\n"

"}";

const char expected[] =

"class A "

"{ "

"public: "

""

"void foo ( ) { } "

"} ; "

"int main ( ) "

"{ "

"A a ; "

"a . foo ( ) ; "

"wchar_t c ; c = 0 ; "

"}";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef2() {

const char code[] = "class A;\n"

"typedef A duplicate;\n"

"class A\n"

"{\n"

"public:\n"

"typedef wchar_t duplicate;\n"

"duplicate foo() { wchar_t b; return b; }\n"

"};";

const char expected[] =

"class A ; "

"class A "

"{ "

"public: "

""

"wchar_t foo ( ) { wchar_t b ; return b ; } "

"} ;";

ASSERT_EQUALS(expected, tok(code));

}

void simplifyTypedef3() {

const char code[] = "class A {};\n"

"typedef A duplicate;\n"

"wchar_t foo()\n"

"{\n"

"typedef wchar_t duplicate;\n"

"duplicate b;\n"

"return b;\n"

"}\n"

"int main()\n"

"{\n"

"duplicate b;\n"

"}";

const char expected[] =

"class A { } ; "

"wchar_t foo ( ) "

"{ "

""

"wchar_t b ; "

"return b ; "

"} "

"int main ( ) "

"{ "

"A b ; "

"}";

ASSERT_EQUALS(expected, tok(code));

}

void simplifyTypedef4() {

const char code[] = "typedef int s32;\n"

"typedef unsigned int u32;\n"

"void f()\n"

"{\n"

" s32 ivar = -2;\n"

" u32 uvar = 2;\n"

" return uvar / ivar;\n"

"}";

const char expected[] =

"void f ( ) "

"{ "

"int ivar ; ivar = -2 ; "

"unsigned int uvar ; uvar = 2 ; "

"return uvar / ivar ; "

"}";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef5() {

// ticket #780

const char code[] =

"typedef struct yy_buffer_state *YY_BUFFER_STATE;\n"

"void f()\n"

"{\n"

" YY_BUFFER_STATE state;\n"

"}";

const char expected[] =

"void f ( ) "

"{ "

"struct yy_buffer_state * state ; "

"}";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef6() {

// ticket #983

const char code[] =

"namespace VL {\n"

" typedef float float_t ;\n"

" inline VL::float_t fast_atan2(VL::float_t y, VL::float_t x){}\n"

"}";

const char expected[] =

"namespace VL { "

""

"float fast_atan2 ( float y , float x ) { } "

"}";

ASSERT_EQUALS(expected, tok(code, false));

// ticket #11373

const char code1[] =

"typedef int foo;\n"

"inline foo f();\n";

const char expected1[] = "int f ( ) ;";

ASSERT_EQUALS(expected1, tok(code1, false));

}

void simplifyTypedef7() {

const char code[] = "typedef int abc ; "

"Fred :: abc f ;";

const char expected[] = "Fred :: abc f ;";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef8() {

const char code[] = "typedef int INT;\n"

"typedef unsigned int UINT;\n"

"typedef int * PINT;\n"

"typedef unsigned int * PUINT;\n"

"typedef int & RINT;\n"

"typedef unsigned int & RUINT;\n"

"typedef const int & RCINT;\n"

"typedef const unsigned int & RCUINT;\n"

"INT ti;\n"

"UINT tui;\n"

"PINT tpi;\n"

"PUINT tpui;\n"

"RINT tri;\n"

"RUINT trui;\n"

"RCINT trci;\n"

"RCUINT trcui;";

const char expected[] =

"int ti ; "

"unsigned int tui ; "

"int * tpi ; "

"unsigned int * tpui ; "

"int & tri ; "

"unsigned int & trui ; "

"const int & trci ; "

"const unsigned int & trcui ;";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef9() {

const char code[] = "typedef struct s S, * PS;\n"

"typedef struct t { int a; } T, *TP;\n"

"typedef struct { int a; } U;\n"

"typedef struct { int a; } * V;\n"

"S s;\n"

"PS ps;\n"

"T t;\n"

"TP tp;\n"

"U u;\n"

"V v;";

const char expected[] =

"struct t { int a ; } ; "

"struct U { int a ; } ; "

"struct V { int a ; } ; "

"struct s s ; "

"struct s * ps ; "

"struct t t ; "

"struct t * tp ; "

"struct U u ; "

"struct V * v ;";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef10() {

const char code[] = "typedef union s S, * PS;\n"

"typedef union t { int a; float b ; } T, *TP;\n"

"typedef union { int a; float b; } U;\n"

"typedef union { int a; float b; } * V;\n"

"S s;\n"

"PS ps;\n"

"T t;\n"

"TP tp;\n"

"U u;\n"

"V v;";

const char expected[] =

"union t { int a ; float b ; } ; "

"union U { int a ; float b ; } ; "

"union V { int a ; float b ; } ; "

"union s s ; "

"union s * ps ; "

"union t t ; "

"union t * tp ; "

"union U u ; "

"union V * v ;";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef11() {

const char code[] = "typedef enum { a = 0 , b = 1 , c = 2 } abc;\n"

"typedef enum xyz { x = 0 , y = 1 , z = 2 } XYZ;\n"

"abc e1;\n"

"XYZ e2;";

const char expected[] = "enum abc { a = 0 , b = 1 , c = 2 } ; "

"enum xyz { x = 0 , y = 1 , z = 2 } ; "

"enum abc e1 ; "

"enum xyz e2 ;";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef12() {

const char code[] = "typedef vector<int> V1;\n"

"typedef std::vector<int> V2;\n"

"typedef std::vector<std::vector<int> > V3;\n"

"typedef std::list<int>::iterator IntListIterator;\n"

"V1 v1;\n"

"V2 v2;\n"

"V3 v3;\n"

"IntListIterator iter;";

const char expected[] =

"vector < int > v1 ; "

"std :: vector < int > v2 ; "

"std :: vector < std :: vector < int > > v3 ; "

"std :: list < int > :: iterator iter ;";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef13() {

// ticket # 1167

const char code[] = "typedef std::pair<int(*)(void*), void*> Func;"

"typedef std::vector<Func> CallQueue;"

"int main() {}";

// Tokenize and check output..

tok(code);

ASSERT_EQUALS("", errout_str());

}

void simplifyTypedef14() {

// ticket # 1232

const char code[] = "template <typename F, unsigned int N> struct E"

"{"

" typedef E<F,(N>0)?(N-1):0> v;"

" typedef typename add<v,v>::val val;"

" FP_M(val);"

"};"

"template <typename F> struct E <F,0>"

"{"

" typedef typename D<1>::val val;"

" FP_M(val);"

"};";

// Tokenize and check output..

TODO_ASSERT_THROW(tok(code, true, Platform::Type::Native, false), InternalError); // TODO: Do not throw exception

//ASSERT_EQUALS("", errout_str());

}

void simplifyTypedef15() {

{

const char code[] = "typedef char frame[10];\n"

"frame f;";

const char expected[] = "char f [ 10 ] ;";

ASSERT_EQUALS(expected, tok(code, false));

}

{

const char code[] = "typedef unsigned char frame[10];\n"

"frame f;";

const char expected[] = "unsigned char f [ 10 ] ;";

ASSERT_EQUALS(expected, tok(code, false));

}

}

void simplifyTypedef16() {

// ticket # 1252

const char code[] = "typedef char MOT8;\n"

"typedef MOT8 CHFOO[4096];\n"

"typedef struct {\n"

" CHFOO freem;\n"

"} STRFOO;";

// Tokenize and check output..

tok(code);

ASSERT_EQUALS("", errout_str());

}

void simplifyTypedef17() {

const char code[] = "typedef char * PCHAR, CHAR;\n"

"PCHAR pc;\n"

"CHAR c;";

const char expected[] =

"char * pc ; "

"char c ;";

ASSERT_EQUALS(expected, tok(code, false));

}

void simplifyTypedef18() {

const char code[] = "typedef vector<int[4]> a;\n"

"a b;";

ASSERT_EQUALS("vector < int [ 4 ] > b ;", tok(code));

}

void simplifyTypedef19() {

{

// ticket #1275

const char code[] = "typedef struct {} A, *B, **C;\n"

"A a;\n"

"B b;\n"

"C c;";

const char expected[] =

"struct A { } ; "

"struct A a ; "

"struct A * b ; "

"struct A * * c ;";

ASSERT_EQUALS(expected, tok(code, false));

}

{

const char code[] = "typedef struct {} A, *********B;\n"

"A a;\n"

"B b;";

const char expected[] =

"struct A { } ; "

"struct A a ; "

"struct A * * * * * * * * * b ;";

ASSERT_EQUALS(expected, tok(code, false));

}

{

const char code[] = "typedef struct {} **********A, *B, C;\n"

"A a;\n"

"B b;\n"

"C c;";

const char expected[] =

"struct Unnamed0 { } ; "

"struct Unnamed0 * * * * * * * * * * a ; "

"struct Unnamed0 * b ; "

"struct Unnamed0 c ;";

ASSERT_EQUALS(expected, tok(code, false));

}

}

void simplifyTypedef20() {

// ticket #1284

const char code[] = "typedef jobject invoke_t (jobject, Proxy *, Method *, JArray< jobject > *);";

ASSERT_EQUALS(";", tok(code));

}

void simplifyTypedef21() {

const char code[] = "typedef void (* PF)();\n"

"typedef void * (* PFV)(void *);\n"

"PF pf;\n"

"PFV pfv;";

const char expected[] =

""

""

"void ( * pf ) ( ) ; "

"void * ( * pfv ) ( void * ) ;";

ASSERT_EQUALS(expected, simplifyTypedef(code));

}

void simplifyTypedef22() {

{

const char code[] = "class Fred {\n"

" typedef void (*testfp)();\n"

" testfp get() { return test; }\n"

" static void test() { }\n"

"};";

const char expected[] =

"class Fred { "

""

"void * get ( ) { return test ; } "

"static void test ( ) { } "

"} ;";

ASSERT_EQUALS(expected, tok(code, false));

}

{

const char code[] = "class Fred {\n"

" typedef void * (*testfp)(void *);\n"

" testfp get() { return test; }\n"

" static void * test(void * p) { return p; }\n"

"};";

const char expected[] =

"class Fred { "

""

"void * * get ( ) { return test ; } "

"static void * test ( void * p ) { return p ; } "

"} ;";

ASSERT_EQUALS(expected, tok(code, false));

}

{

const char code[] = "class Fred {\n"

" typedef unsigned int * (*testfp)(unsigned int *);\n"

" testfp get() { return test; }\n"

" static unsigned int * test(unsigned int * p) { return p; }\n"

"};";

const char expected[] =

"class Fred { "

""

"unsigned int * * get ( ) { return test ; } "

"static unsigned int * test ( unsigned int * p ) { return p ; } "

"} ;";

ASSERT_EQUALS(expected, tok(code, false));

}

{

const char code[] = "class Fred {\n"

" typedef const unsigned int * (*testfp)(const unsigned int *);\n"

" testfp get() { return test; }\n"

" static const unsigned int * test(const unsigned int * p) { return p; }\n"

"};";

// static const gets changed to const static

const char expected[] =

"class Fred { "

""

"const unsigned int * * get ( ) { return test ; } "

"static const unsigned int * test ( const unsigned int * p ) { return p ; } "

"} ;";

ASSERT_EQUALS(expected, tok(code, false));

}

{

const char code[] = "class Fred {\n"

" typedef void * (*testfp)(void *);\n"

" testfp get(int i) { return test; }\n"

" static void * test(void * p) { return p; }\n"

"};";

const char expected[] =

"class Fred { "

""

"void * * get ( int i ) { return test ; } "

"static void * test ( void * p ) { return p ; } "