TestSimplifyTypedef() : TestFixture("TestSimplifyTypedef") {

}

Settings settings0;

Settings settings1;

Settings settings2;

void run() OVERRIDE {

settings0.addEnabled("style");

settings2.addEnabled("style");

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(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(simplifyTypedefShadow); // #4445 - shadow variable

}

std::string tok(const char code[], bool simplify = true, Settings::PlatformType type = Settings::Native, bool debugwarnings = true) {

errout.str("");

settings0.inconclusive = true;

settings0.debugwarnings = debugwarnings; // show warnings about unhandled typedef

settings0.platform(type);

Tokenizer tokenizer(&settings0, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, "test.cpp");

if (simplify)

tokenizer.simplifyTokenList2();

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

}

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

errout.str("");

Tokenizer tokenizer(&settings1, this);

std::istringstream istr(code);

tokenizer.list.createTokens(istr);

tokenizer.createLinks();

tokenizer.simplifyTypedef();

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

}

void checkSimplifyTypedef(const char code[]) {

errout.str("");

// Tokenize..

settings2.inconclusive = true;

settings2.debugwarnings = true; // show warnings about unhandled typedef

Tokenizer tokenizer(&settings2, this);

std::istringstream istr(code);

tokenizer.tokenize(istr, "test.cpp");

}

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));

}

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 Unnamed0 { int a ; } ; "

"struct s s ; "

"struct s * ps ; "

"struct t t ; "

"struct t * tp ; "

"struct U u ; "

"struct Unnamed0 * 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 Unnamed0 { int a ; float b ; } ; "

"union s s ; "

"union s * ps ; "

"union t t ; "

"union t * tp ; "

"union U u ; "

"union Unnamed0 * 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 } ; "

"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..

tok(code, true, Settings::Native, false);

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 ; } "

"} ;";

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

}

}

void simplifyTypedef23() {

const char code[] = "typedef bool (*Callback) (int i);\n"

"void addCallback(Callback callback) { }\n"

"void addCallback1(Callback callback, int j) { }";

const char expected[] =

"void addCallback ( bool * callback ) { } "

"void addCallback1 ( bool * callback , int j ) { }";

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

}

void simplifyTypedef24() {

{

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

"void g( fp f )\n"

"{\n"

" fp f2 = (fp)f;\n"

"}";

const char expected[] =

"void g ( int * f ) "

"{ "

"int * f2 ; f2 = ( int * ) f ; "

"}";

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

}

{

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

"void g( fp f )\n"

"{\n"

" fp f2 = static_cast<fp>(f);\n"

"}";

const char expected[] =

"void g ( int * f ) "

"{ "

"int * f2 ; f2 = static_cast < int * > ( f ) ; "

"}";

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

}

}

void simplifyTypedef25() {

{

// ticket #1298

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

"struct vfs_class {\n"

" void (*fill_names) (struct vfs_class *me, fill_names_f);\n"

"}";

const char expected[] =

"struct vfs_class { "

"void ( * fill_names ) ( struct vfs_class * me , void ( * ) ( const char * ) ) ; "

"}";

ASSERT_EQUALS(expected, simplifyTypedef(code));

}

{

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

"struct vfs_class {\n"

" void (*fill_names) (fill_names_f, struct vfs_class *me);\n"

"}";

const char expected[] =

"struct vfs_class { "

"void ( * fill_names ) ( void ( * ) ( const char * ) , struct vfs_class * me ) ; "

"}";

ASSERT_EQUALS(expected, simplifyTypedef(code));

}

}

void simplifyTypedef26() {

{

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

"void addCallback(Callback (*callback)());";

const char expected[] = "void addCallback ( void ( * ( * callback ) ( ) ) ( ) ) ;";

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

}

{

// ticket # 1307

const char code[] = "typedef void (*pc_video_update_proc)(bitmap_t *bitmap,\n"

"struct mscrtc6845 *crtc);\n"

"\n"

"struct mscrtc6845 *pc_video_start(pc_video_update_proc (*choosevideomode)(running_machine *machine, int *width, int *height, struct mscrtc6845 *crtc));";

const char expected[] = "struct mscrtc6845 * pc_video_start ( void ( * ( * choosevideomode ) ( running_machine * machine , int * width , int * height , struct mscrtc6845 * crtc ) ) ( bitmap_t * bitmap , struct mscrtc6845 * crtc ) ) ;";

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

}

}

void simplifyTypedef27() {

// ticket #1316

const char code[] = "int main()\n"

"{\n"

" typedef int (*func_ptr)(float, double);\n"

" VERIFY((is_same<result_of<func_ptr(char, float)>::type, int>::value));\n"

"}";

const char expected[] =

"int main ( ) "

"{ "

""

"VERIFY ( is_same < result_of < int ( * ( char , float ) ) ( float , double ) > :: type , int > :: value ) ; "

"}";

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

}

void simplifyTypedef28() {

const char code[] = "typedef std::pair<double, double> (*F)(double);\n"

"F f;";

const char expected[] = "std :: pair < double , double > ( * f ) ( double ) ;";

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

}

void simplifyTypedef29() {

const char code[] = "typedef int array [ice_or<is_int<int>::value, is_int<UDT>::value>::value ? 1 : -1];\n"

"typedef int array1 [N];\n"

"typedef int array2 [N][M];\n"

"typedef int int_t, int_array[N];\n"

"array a;\n"

"array1 a1;\n"

"array2 a2;\n"

"int_t t;\n"

"int_array ia;";

const char expected[] =

"int a [ ice_or < is_int < int > :: value , is_int < UDT > :: value > :: value ? 1 : -1 ] ; "

"int a1 [ N ] ; "

"int a2 [ N ] [ M ] ; "

"int t ; "

"int ia [ N ] ;";

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

}

void simplifyTypedef30() {

const char code[] = "typedef ::std::list<int> int_list;\n"

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

"typedef ::std::list<int> int_list_array[10];\n"

"int_list il;\n"

"int_list_iterator ili;\n"

"int_list_array ila;";

const char expected[] =

":: std :: list < int > il ; "

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

":: std :: list < int > ila [ 10 ] ;";

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

}

void simplifyTypedef31() {

{

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

"public:\n"

" typedef int INT;\n"

" INT get() const;\n"

" void put(INT x) { a = x; }\n"

" INT a;\n"

"};\n"

"A::INT A::get() const { return a; }\n"

"A::INT i = A::a;";

const char expected[] = "class A { "

"public: "

""

"int get ( ) const ; "

"void put ( int x ) { a = x ; } "

"int a ; "

"} ; "

"int A :: get ( ) const { return a ; } "

"int i ; i = A :: a ;";

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

}

{

const char code[] = "struct A {\n"

" typedef int INT;\n"

" INT get() const;\n"

" void put(INT x) { a = x; }\n"

" INT a;\n"

"};\n"

"A::INT A::get() const { return a; }\n"

"A::INT i = A::a;";

const char expected[] = "struct A { "

""

"int get ( ) const ; "

"void put ( int x ) { a = x ; } "

"int a ; "

"} ; "

"int A :: get ( ) const { return a ; } "

"int i ; i = A :: a ;";

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

}

}

void simplifyTypedef32() {

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

"typedef CHAR * LPSTR;\n"

"typedef const CHAR * LPCSTR;\n"

"CHAR c;\n"

"LPSTR cp;\n"

"LPCSTR ccp;";

const char expected[] =

"char c ; "

"char * cp ; "

"const char * ccp ;";

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

}

void simplifyTypedef33() {

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

"public:\n"

" typedef char CHAR_A;\n"

" CHAR_A funA();\n"

" class B {\n"

" public:\n"

" typedef short SHRT_B;\n"

" SHRT_B funB();\n"

" class C {\n"

" public:\n"

" typedef int INT_C;\n"

" INT_C funC();\n"

" struct D {\n"

" typedef long LONG_D;\n"

" LONG_D funD();\n"

" LONG_D d;\n"

" };\n"

" INT_C c;\n"

" };\n"

" SHRT_B b;\n"

" };\n"

" CHAR_A a;\n"

"};\n"

"A::CHAR_A A::funA() { return a; }\n"

"A::B::SHRT_B A::B::funB() { return b; }\n"

"A::B::C::INT_C A::B::C::funC() { return c; }"

"A::B::C::D::LONG_D A::B::C::D::funD() { return d; }";

const char codeFullSpecified[] = "class A {\n"

"public:\n"

" typedef char CHAR_A;\n"

" A::CHAR_A funA();\n"

" class B {\n"

" public:\n"

" typedef short SHRT_B;\n"

" A::B::SHRT_B funB();\n"

" class C {\n"

" public:\n"

" typedef int INT_C;\n"

" A::B::C::INT_C funC();\n"

" struct D {\n"

" typedef long LONG_D;\n"

" A::B::C::D::LONG_D funD();\n"

" A::B::C::D::LONG_D d;\n"

" };\n"

" A::B::C::INT_C c;\n"

" };\n"

" A::B::SHRT_B b;\n"

" };\n"

" A::CHAR_A a;\n"

"};\n"