Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
May 19, 2012, 3:03:02 PM (13 years ago)
Author:
landauf
Message:

renamed set and get functions in MultiType:

  • setValue() → set()
  • getXYZ() → get<xyz>()

(e.g. get<int>() instead of getInt() and get<std::string>() instead of getString())

File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/branches/testing/test/util/MultiTypeTest.cc

    r9223 r9224  
    1212    // x assignment(other)
    1313
    14     // x setValue(value)
    15     // ? setValue(pointer)
    16     // x setValue<type>(value)
     14    // x set(value)
     15    // ? set(pointer)
     16    // x set<type>(value)
    1717
    1818    // x convert<type>()
    … …  
    2626    // ? (pointer class) conversion
    2727    // x getValue(pointer)
    28     // x getXXX()
     28    // x get<type>()
    2929    // ? getPointer()
    3030
    … …  
    4545    // Constructor //
    4646    /////////////////
    47     TEST(MultiType, ValueChar)              { char value = -100;                                MultiType mt(value);    EXPECT_TRUE(mt.isType<char>());                 EXPECT_EQ(-100, mt.getChar()); }
    48     TEST(MultiType, ValueUnsignedChar)      { unsigned char value = 255u;                       MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned char>());        EXPECT_EQ(255u, mt.getUnsignedChar()); }
    49     TEST(MultiType, ValueShort)             { short value = -10000;                             MultiType mt(value);    EXPECT_TRUE(mt.isType<short>());                EXPECT_EQ(-10000, mt.getShort()); }
    50     TEST(MultiType, ValueUnsignedShort)     { unsigned short value = 65535u;                    MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned short>());       EXPECT_EQ(65535u, mt.getUnsignedShort()); }
    51     TEST(MultiType, ValueInt)               { int value = -1000000000;                          MultiType mt(value);    EXPECT_TRUE(mt.isType<int>());                  EXPECT_EQ(-1000000000, mt.getInt()); }
    52     TEST(MultiType, ValueUnsignedInt)       { unsigned int value = 4000000000u;                 MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned int>());         EXPECT_EQ(4000000000u, mt.getUnsignedInt()); }
    53     TEST(MultiType, ValueLong)              { long value = -1000000000;                         MultiType mt(value);    EXPECT_TRUE(mt.isType<long>());                 EXPECT_EQ(-1000000000, mt.getLong()); }
    54     TEST(MultiType, ValueUnsignedLong)      { unsigned long value = 4000000000u;                MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned long>());        EXPECT_EQ(4000000000u, mt.getUnsignedLong()); }
    55     TEST(MultiType, ValueLongLong)          { long long value = -1000000000000000000L;          MultiType mt(value);    EXPECT_TRUE(mt.isType<long long>());            EXPECT_EQ(-1000000000000000000L, mt.getLongLong()); }
    56     TEST(MultiType, ValueUnsignedLongLong)  { unsigned long long value = 4000000000000000000UL; MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned long long>());   EXPECT_EQ(4000000000000000000UL, mt.getUnsignedLongLong()); }
    57     TEST(MultiType, ValueFloat)             { float value = 0.123456f;                          MultiType mt(value);    EXPECT_TRUE(mt.isType<float>());                EXPECT_EQ(0.123456f, mt.getFloat()); }
    58     TEST(MultiType, ValueDouble)            { double value = 0.123456789;                       MultiType mt(value);    EXPECT_TRUE(mt.isType<double>());               EXPECT_EQ(0.123456789, mt.getDouble()); }
    59     TEST(MultiType, ValueLongDouble)        { long double value = 0.123456789123456789;         MultiType mt(value);    EXPECT_TRUE(mt.isType<long double>());          EXPECT_EQ(0.123456789123456789, mt.getLongDouble()); }
    60     TEST(MultiType, ValueBool)              { bool value = true;                                MultiType mt(value);    EXPECT_TRUE(mt.isType<bool>());                 EXPECT_EQ(true, mt.getBool()); }
    61     TEST(MultiType, ValueVoidpointer)       { int* pointer = new int; void* value = pointer;    MultiType mt(value);    EXPECT_TRUE(mt.isType<void*>());                EXPECT_EQ(value, mt.getPointer<void>()); delete pointer; }
    62     TEST(MultiType, ValueString)            { std::string value = "Hello World";                MultiType mt(value);    EXPECT_TRUE(mt.isType<std::string>());          EXPECT_EQ("Hello World", mt.getString()); }
    63     TEST(MultiType, ValueVector2)           { Vector2 value = Vector2(11, 22);                  MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector2>());              EXPECT_EQ(Vector2(11, 22), mt.getVector2()); }
    64     TEST(MultiType, ValueVector3)           { Vector3 value = Vector3(11, 22, 33);              MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector3>());              EXPECT_EQ(Vector3(11, 22, 33), mt.getVector3()); }
    65     TEST(MultiType, ValueVector4)           { Vector4 value = Vector4(11, 22, 33, 44);          MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector4>());              EXPECT_EQ(Vector4(11, 22, 33, 44), mt.getVector4()); }
    66     TEST(MultiType, ValueColourValue)       { ColourValue value = ColourValue(11, 22, 33, 44);  MultiType mt(value);    EXPECT_TRUE(mt.isType<ColourValue>());          EXPECT_EQ(ColourValue(11, 22, 33, 44), mt.getColourValue()); }
    67     TEST(MultiType, ValueQuaternion)        { Quaternion value = Quaternion(11, 22, 33, 44);    MultiType mt(value);    EXPECT_TRUE(mt.isType<Quaternion>());           EXPECT_EQ(Quaternion(11, 22, 33, 44), mt.getQuaternion()); }
    68     TEST(MultiType, ValueRadian)            { Radian value = Radian(0.123);                     MultiType mt(value);    EXPECT_TRUE(mt.isType<Radian>());               EXPECT_EQ(Radian(0.123), mt.getRadian()); }
    69     TEST(MultiType, ValueDegree)            { Degree value = Degree(123);                       MultiType mt(value);    EXPECT_TRUE(mt.isType<Degree>());               EXPECT_EQ(Degree(123), mt.getDegree()); }
    70     TEST(MultiType, ValueMbool)             { mbool value = mbool(true);                        MultiType mt(value);    EXPECT_TRUE(mt.isType<bool>());                 EXPECT_EQ(mbool(true), mt.getBool()); }
    71     TEST(MultiType, ValueCharPointer)       { const char* value = "Hello World";                MultiType mt(value);    EXPECT_TRUE(mt.isType<std::string>());          EXPECT_EQ("Hello World", mt.getString()); }
     47    TEST(MultiType, ValueChar)              { char value = -100;                                MultiType mt(value);    EXPECT_TRUE(mt.isType<char>());                 EXPECT_EQ(-100, mt.get<char>()); }
     48    TEST(MultiType, ValueUnsignedChar)      { unsigned char value = 255u;                       MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned char>());        EXPECT_EQ(255u, mt.get<unsigned char>()); }
     49    TEST(MultiType, ValueShort)             { short value = -10000;                             MultiType mt(value);    EXPECT_TRUE(mt.isType<short>());                EXPECT_EQ(-10000, mt.get<short>()); }
     50    TEST(MultiType, ValueUnsignedShort)     { unsigned short value = 65535u;                    MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned short>());       EXPECT_EQ(65535u, mt.get<unsigned short>()); }
     51    TEST(MultiType, ValueInt)               { int value = -1000000000;                          MultiType mt(value);    EXPECT_TRUE(mt.isType<int>());                  EXPECT_EQ(-1000000000, mt.get<int>()); }
     52    TEST(MultiType, ValueUnsignedInt)       { unsigned int value = 4000000000u;                 MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned int>());         EXPECT_EQ(4000000000u, mt.get<unsigned int>()); }
     53    TEST(MultiType, ValueLong)              { long value = -1000000000;                         MultiType mt(value);    EXPECT_TRUE(mt.isType<long>());                 EXPECT_EQ(-1000000000, mt.get<long>()); }
     54    TEST(MultiType, ValueUnsignedLong)      { unsigned long value = 4000000000u;                MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned long>());        EXPECT_EQ(4000000000u, mt.get<unsigned long>()); }
     55    TEST(MultiType, ValueLongLong)          { long long value = -1000000000000000000L;          MultiType mt(value);    EXPECT_TRUE(mt.isType<long long>());            EXPECT_EQ(-1000000000000000000L, mt.get<long long>()); }
     56    TEST(MultiType, ValueUnsignedLongLong)  { unsigned long long value = 4000000000000000000UL; MultiType mt(value);    EXPECT_TRUE(mt.isType<unsigned long long>());   EXPECT_EQ(4000000000000000000UL, mt.get<unsigned long long>()); }
     57    TEST(MultiType, ValueFloat)             { float value = 0.123456f;                          MultiType mt(value);    EXPECT_TRUE(mt.isType<float>());                EXPECT_EQ(0.123456f, mt.get<float>()); }
     58    TEST(MultiType, ValueDouble)            { double value = 0.123456789;                       MultiType mt(value);    EXPECT_TRUE(mt.isType<double>());               EXPECT_EQ(0.123456789, mt.get<double>()); }
     59    TEST(MultiType, ValueLongDouble)        { long double value = 0.123456789123456789;         MultiType mt(value);    EXPECT_TRUE(mt.isType<long double>());          EXPECT_EQ(0.123456789123456789, mt.get<long double>()); }
     60    TEST(MultiType, ValueBool)              { bool value = true;                                MultiType mt(value);    EXPECT_TRUE(mt.isType<bool>());                 EXPECT_EQ(true, mt.get<bool>()); }
     61    TEST(MultiType, ValueVoidpointer)       { int* pointer = new int; void* value = pointer;    MultiType mt(value);    EXPECT_TRUE(mt.isType<void*>());                EXPECT_EQ(value, mt.get<void*>()); delete pointer; }
     62    TEST(MultiType, ValueString)            { std::string value = "Hello World";                MultiType mt(value);    EXPECT_TRUE(mt.isType<std::string>());          EXPECT_EQ("Hello World", mt.get<std::string>()); }
     63    TEST(MultiType, ValueVector2)           { Vector2 value = Vector2(11, 22);                  MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector2>());              EXPECT_EQ(Vector2(11, 22), mt.get<Vector2>()); }
     64    TEST(MultiType, ValueVector3)           { Vector3 value = Vector3(11, 22, 33);              MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector3>());              EXPECT_EQ(Vector3(11, 22, 33), mt.get<Vector3>()); }
     65    TEST(MultiType, ValueVector4)           { Vector4 value = Vector4(11, 22, 33, 44);          MultiType mt(value);    EXPECT_TRUE(mt.isType<Vector4>());              EXPECT_EQ(Vector4(11, 22, 33, 44), mt.get<Vector4>()); }
     66    TEST(MultiType, ValueColourValue)       { ColourValue value = ColourValue(11, 22, 33, 44);  MultiType mt(value);    EXPECT_TRUE(mt.isType<ColourValue>());          EXPECT_EQ(ColourValue(11, 22, 33, 44), mt.get<ColourValue>()); }
     67    TEST(MultiType, ValueQuaternion)        { Quaternion value = Quaternion(11, 22, 33, 44);    MultiType mt(value);    EXPECT_TRUE(mt.isType<Quaternion>());           EXPECT_EQ(Quaternion(11, 22, 33, 44), mt.get<Quaternion>()); }
     68    TEST(MultiType, ValueRadian)            { Radian value = Radian(0.123);                     MultiType mt(value);    EXPECT_TRUE(mt.isType<Radian>());               EXPECT_EQ(Radian(0.123), mt.get<Radian>()); }
     69    TEST(MultiType, ValueDegree)            { Degree value = Degree(123);                       MultiType mt(value);    EXPECT_TRUE(mt.isType<Degree>());               EXPECT_EQ(Degree(123), mt.get<Degree>()); }
     70    TEST(MultiType, ValueMbool)             { mbool value = mbool(true);                        MultiType mt(value);    EXPECT_TRUE(mt.isType<bool>());                 EXPECT_EQ(mbool(true), mt.get<bool>()); }
     71    TEST(MultiType, ValueCharPointer)       { const char* value = "Hello World";                MultiType mt(value);    EXPECT_TRUE(mt.isType<std::string>());          EXPECT_EQ("Hello World", mt.get<std::string>()); }
    7272
    7373    //////////////////////
    … …  
    8888
    8989        EXPECT_TRUE(mt2.isType<float>());
    90         EXPECT_EQ(0.1234f, mt2.getFloat());
     90        EXPECT_EQ(0.1234f, mt2.get<float>());
    9191    }
    9292
    … …  
    104104        EXPECT_FALSE(mt.null());
    105105        EXPECT_TRUE(mt.isType<int>());
    106         EXPECT_EQ(55, mt.getInt());
     106        EXPECT_EQ(55, mt.get<int>());
    107107    }
    108108
    … …  
    112112
    113113        EXPECT_TRUE(mt.isType<int>());
    114         EXPECT_EQ(66, mt.getInt());
     114        EXPECT_EQ(66, mt.get<int>());
    115115
    116116        mt = 77.7f; // will be converted to int
    117117
    118118        EXPECT_TRUE(mt.isType<int>());
    119         EXPECT_EQ(77, mt.getInt());
    120         EXPECT_EQ(77.0f, mt.getFloat());
     119        EXPECT_EQ(77, mt.get<int>());
     120        EXPECT_EQ(77.0f, mt.get<float>());
    121121    }
    122122
    … …  
    126126
    127127        EXPECT_TRUE(mt.isType<float>());
    128         EXPECT_EQ(66, mt.getInt());
    129         EXPECT_EQ(66.6f, mt.getFloat());
     128        EXPECT_EQ(66, mt.get<int>());
     129        EXPECT_EQ(66.6f, mt.get<float>());
    130130
    131131        mt = 77.7f;
    132132
    133133        EXPECT_TRUE(mt.isType<float>());
    134         EXPECT_EQ(77, mt.getInt());
    135         EXPECT_EQ(77.7f, mt.getFloat());
     134        EXPECT_EQ(77, mt.get<int>());
     135        EXPECT_EQ(77.7f, mt.get<float>());
    136136    }
    137137
    … …  
    141141
    142142        EXPECT_TRUE(mt.isType<Vector3>());
    143         EXPECT_EQ(Vector3(1, 2, 3), mt.getVector3());
     143        EXPECT_EQ(Vector3(1, 2, 3), mt.get<Vector3>());
    144144        EXPECT_FALSE(mt.hasDefaultValue());
    145145
    … …  
    147147
    148148        EXPECT_TRUE(mt.isType<Vector3>());
    149         EXPECT_EQ(Vector3::ZERO, mt.getVector3());
     149        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
    150150        EXPECT_TRUE(mt.hasDefaultValue());
    151151    }
    … …  
    162162        EXPECT_TRUE(mt2.isType<float>());
    163163
    164         EXPECT_EQ(33, mt1.getInt());
    165         EXPECT_EQ(33.0f, mt1.getFloat());
    166         EXPECT_EQ(44.4f, mt2.getFloat());
     164        EXPECT_EQ(33, mt1.get<int>());
     165        EXPECT_EQ(33.0f, mt1.get<float>());
     166        EXPECT_EQ(44.4f, mt2.get<float>());
    167167
    168168        mt1 = mt2;
    … …  
    171171        EXPECT_TRUE(mt2.isType<float>());
    172172
    173         EXPECT_EQ(44, mt1.getInt());
    174         EXPECT_EQ(44.0f, mt1.getFloat());
    175         EXPECT_EQ(44.4f, mt2.getFloat());
    176     }
    177 
    178     /////////////////////
    179     // setValue(value) //
    180     /////////////////////
     173        EXPECT_EQ(44, mt1.get<int>());
     174        EXPECT_EQ(44.0f, mt1.get<float>());
     175        EXPECT_EQ(44.4f, mt2.get<float>());
     176    }
     177
     178    ////////////////
     179    // set(value) //
     180    ////////////////
    181181    TEST(MultiType, SetValueBoolToEmpty)
    182182    {
    183183        MultiType mt;
    184184
    185         mt.setValue(true);
     185        mt.set(true);
    186186
    187187        EXPECT_TRUE(mt.isType<bool>());
    188         EXPECT_EQ(true, mt.getBool());
     188        EXPECT_EQ(true, mt.get<bool>());
    189189    }
    190190
    … …  
    194194
    195195        EXPECT_TRUE(mt.isType<std::string>());
    196         EXPECT_EQ("Hello", mt.getString());
    197 
    198         mt.setValue(1234);
     196        EXPECT_EQ("Hello", mt.get<std::string>());
     197
     198        mt.set(1234);
    199199
    200200        EXPECT_TRUE(mt.isType<std::string>());
    201         EXPECT_EQ("1234", mt.getString());
    202     }
    203 
    204     ///////////////////////////
    205     // setValue<type>(value) //
    206     ///////////////////////////
     201        EXPECT_EQ("1234", mt.get<std::string>());
     202    }
     203
     204    //////////////////////
     205    // set<type>(value) //
     206    //////////////////////
    207207    TEST(MultiType, SetValueWithTypeIntToString)
    208208    {
    … …  
    210210
    211211        EXPECT_TRUE(mt.isType<std::string>());
    212         EXPECT_EQ("Hello", mt.getString());
    213 
    214         mt.setValue<int>(1234);
    215 
    216         EXPECT_TRUE(mt.isType<int>());
    217         EXPECT_EQ(1234, mt.getInt());
     212        EXPECT_EQ("Hello", mt.get<std::string>());
     213
     214        mt.set<int>(1234);
     215
     216        EXPECT_TRUE(mt.isType<int>());
     217        EXPECT_EQ(1234, mt.get<int>());
    218218    }
    219219
    … …  
    223223
    224224        EXPECT_TRUE(mt.isType<std::string>());
    225         EXPECT_EQ("Hello", mt.getString());
    226 
    227         mt.setValue<int>("1234");
    228 
    229         EXPECT_TRUE(mt.isType<int>());
    230         EXPECT_EQ(1234, mt.getInt());
     225        EXPECT_EQ("Hello", mt.get<std::string>());
     226
     227        mt.set<int>("1234");
     228
     229        EXPECT_TRUE(mt.isType<int>());
     230        EXPECT_EQ(1234, mt.get<int>());
    231231    }
    232232
    … …  
    236236
    237237        EXPECT_TRUE(mt.isType<int>());
    238         EXPECT_EQ(4321, mt.getInt());
    239 
    240         mt.setValue<int>(1234);
    241 
    242         EXPECT_TRUE(mt.isType<int>());
    243         EXPECT_EQ(1234, mt.getInt());
     238        EXPECT_EQ(4321, mt.get<int>());
     239
     240        mt.set<int>(1234);
     241
     242        EXPECT_TRUE(mt.isType<int>());
     243        EXPECT_EQ(1234, mt.get<int>());
    244244    }
    245245
    … …  
    253253
    254254        EXPECT_TRUE(mt.isType<int>());
    255         EXPECT_EQ(0, mt.getInt());
     255        EXPECT_EQ(0, mt.get<int>());
    256256
    257257//        EXPECT_TRUE(mt.hasDefaultValue());
    … …  
    263263
    264264        EXPECT_TRUE(mt.isType<float>());
    265         EXPECT_EQ(1.234f, mt.getFloat());
    266         EXPECT_EQ(1, mt.getInt());
     265        EXPECT_EQ(1.234f, mt.get<float>());
     266        EXPECT_EQ(1, mt.get<int>());
    267267
    268268        mt.convert<int>();
    269269
    270270        EXPECT_TRUE(mt.isType<int>());
    271         EXPECT_EQ(1.0f, mt.getFloat());
    272         EXPECT_EQ(1, mt.getInt());
     271        EXPECT_EQ(1.0f, mt.get<float>());
     272        EXPECT_EQ(1, mt.get<int>());
    273273    }
    274274
    … …  
    278278
    279279        EXPECT_TRUE(mt.isType<float>());
    280         EXPECT_EQ(1.234f, mt.getFloat());
    281         EXPECT_EQ(Vector3::ZERO, mt.getVector3());
     280        EXPECT_EQ(1.234f, mt.get<float>());
     281        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
    282282
    283283        mt.convert<Vector3>();
    284284
    285285        EXPECT_TRUE(mt.isType<Vector3>());
    286         EXPECT_EQ(0.0f, mt.getFloat());
    287         EXPECT_EQ(Vector3::ZERO, mt.getVector3());
     286        EXPECT_EQ(0.0f, mt.get<float>());
     287        EXPECT_EQ(Vector3::ZERO, mt.get<Vector3>());
    288288
    289289//        EXPECT_TRUE(mt.hasDefaultValue());
    … …  
    300300        EXPECT_FALSE(mt.isType<void>());
    301301        EXPECT_FALSE(mt.null());
    302         EXPECT_EQ(10, mt.getInt());
     302        EXPECT_EQ(10, mt.get<int>());
    303303
    304304        mt.reset();
    … …  
    307307        EXPECT_TRUE(mt.isType<void>());
    308308        EXPECT_TRUE(mt.null());
    309         EXPECT_EQ(0, mt.getInt());
     309        EXPECT_EQ(0, mt.get<int>());
    310310    }
    311311
    … …  
    319319        EXPECT_TRUE(mt.isType<int>());
    320320        EXPECT_FALSE(mt.isType<float>());
    321         EXPECT_EQ(10, mt.getInt());
     321        EXPECT_EQ(10, mt.get<int>());
    322322
    323323        mt.reset<float>();
    … …  
    325325        EXPECT_FALSE(mt.isType<int>());
    326326        EXPECT_TRUE(mt.isType<float>());
    327         EXPECT_EQ(0, mt.getInt());
     327        EXPECT_EQ(0, mt.get<int>());
    328328    }
    329329
    … …  
    336336
    337337        EXPECT_TRUE(mt.isType<int>());
    338         EXPECT_EQ(10, mt.getInt());
     338        EXPECT_EQ(10, mt.get<int>());
    339339
    340340        mt.resetValue();
    341341
    342342        EXPECT_TRUE(mt.isType<int>());
    343         EXPECT_EQ(0, mt.getInt());
     343        EXPECT_EQ(0, mt.get<int>());
    344344    }
    345345
    … …  
    430430
    431431    //////////////
    432     // getXXX() //
     432    // get<type>() //
    433433    //////////////
    434434    TEST(MultiType, GetValueFromInt)
    … …  
    436436        MultiType mt(256);
    437437
    438         EXPECT_EQ(0, mt.getChar());
    439         EXPECT_EQ(0u, mt.getUnsignedChar());
    440         EXPECT_EQ(256, mt.getShort());
    441         EXPECT_EQ(256u, mt.getUnsignedShort());
    442         EXPECT_EQ(256, mt.getInt());
    443         EXPECT_EQ(256u, mt.getUnsignedInt());
    444         EXPECT_EQ(256, mt.getLong());
    445         EXPECT_EQ(256u, mt.getUnsignedLong());
    446         EXPECT_EQ(256, mt.getLongLong());
    447         EXPECT_EQ(256u, mt.getUnsignedLongLong());
    448         EXPECT_EQ(256.0f, mt.getFloat());
    449         EXPECT_EQ(256.0, mt.getDouble());
    450         EXPECT_EQ(256.0, mt.getLongDouble());
    451         EXPECT_TRUE(mt.getBool());
    452         EXPECT_EQ("256", mt.getString());
     438        EXPECT_EQ(0, mt.get<char>());
     439        EXPECT_EQ(0u, mt.get<unsigned char>());
     440        EXPECT_EQ(256, mt.get<short>());
     441        EXPECT_EQ(256u, mt.get<unsigned short>());
     442        EXPECT_EQ(256, mt.get<int>());
     443        EXPECT_EQ(256u, mt.get<unsigned int>());
     444        EXPECT_EQ(256, mt.get<long>());
     445        EXPECT_EQ(256u, mt.get<unsigned long>());
     446        EXPECT_EQ(256, mt.get<long long>());
     447        EXPECT_EQ(256u, mt.get<unsigned long long>());
     448        EXPECT_EQ(256.0f, mt.get<float>());
     449        EXPECT_EQ(256.0, mt.get<double>());
     450        EXPECT_EQ(256.0, mt.get<long double>());
     451        EXPECT_TRUE(mt.get<bool>());
     452        EXPECT_EQ("256", mt.get<std::string>());
    453453    }
    454454
    … …  
    457457        MultiType mt(128.821);
    458458
    459         EXPECT_EQ(-128, mt.getChar());
    460         EXPECT_EQ(128u, mt.getUnsignedChar());
    461         EXPECT_EQ(128, mt.getShort());
    462         EXPECT_EQ(128u, mt.getUnsignedShort());
    463         EXPECT_EQ(128, mt.getInt());
    464         EXPECT_EQ(128u, mt.getUnsignedInt());
    465         EXPECT_EQ(128, mt.getLong());
    466         EXPECT_EQ(128u, mt.getUnsignedLong());
    467         EXPECT_EQ(128, mt.getLongLong());
    468         EXPECT_EQ(128u, mt.getUnsignedLongLong());
    469         EXPECT_EQ(128.821f, mt.getFloat());
    470         EXPECT_EQ(128.821, mt.getDouble());
    471         EXPECT_EQ(128.821, mt.getLongDouble());
    472         EXPECT_TRUE(mt.getBool());
    473         EXPECT_EQ("128.821", mt.getString());
     459        EXPECT_EQ(-128, mt.get<char>());
     460        EXPECT_EQ(128u, mt.get<unsigned char>());
     461        EXPECT_EQ(128, mt.get<short>());
     462        EXPECT_EQ(128u, mt.get<unsigned short>());
     463        EXPECT_EQ(128, mt.get<int>());
     464        EXPECT_EQ(128u, mt.get<unsigned int>());
     465        EXPECT_EQ(128, mt.get<long>());
     466        EXPECT_EQ(128u, mt.get<unsigned long>());
     467        EXPECT_EQ(128, mt.get<long long>());
     468        EXPECT_EQ(128u, mt.get<unsigned long long>());
     469        EXPECT_EQ(128.821f, mt.get<float>());
     470        EXPECT_EQ(128.821, mt.get<double>());
     471        EXPECT_EQ(128.821, mt.get<long double>());
     472        EXPECT_TRUE(mt.get<bool>());
     473        EXPECT_EQ("128.821", mt.get<std::string>());
    474474    }
    475475
    … …  
    478478        MultiType mt("0.123");
    479479
    480         EXPECT_EQ('0', mt.getChar());
    481         EXPECT_EQ('0', mt.getUnsignedChar());
    482         EXPECT_EQ(0, mt.getShort());
    483         EXPECT_EQ(0u, mt.getUnsignedShort());
    484         EXPECT_EQ(0, mt.getInt());
    485         EXPECT_EQ(0u, mt.getUnsignedInt());
    486         EXPECT_EQ(0, mt.getLong());
    487         EXPECT_EQ(0u, mt.getUnsignedLong());
    488         EXPECT_EQ(0, mt.getLongLong());
    489         EXPECT_EQ(0u, mt.getUnsignedLongLong());
    490         EXPECT_EQ(0.123f, mt.getFloat());
    491         EXPECT_EQ(0.123, mt.getDouble());
    492         EXPECT_DOUBLE_EQ(0.123, mt.getLongDouble());
    493         EXPECT_FALSE(mt.getBool());
    494         EXPECT_EQ("0.123", mt.getString());
     480        EXPECT_EQ('0', mt.get<char>());
     481        EXPECT_EQ('0', mt.get<unsigned char>());
     482        EXPECT_EQ(0, mt.get<short>());
     483        EXPECT_EQ(0u, mt.get<unsigned short>());
     484        EXPECT_EQ(0, mt.get<int>());
     485        EXPECT_EQ(0u, mt.get<unsigned int>());
     486        EXPECT_EQ(0, mt.get<long>());
     487        EXPECT_EQ(0u, mt.get<unsigned long>());
     488        EXPECT_EQ(0, mt.get<long long>());
     489        EXPECT_EQ(0u, mt.get<unsigned long long>());
     490        EXPECT_EQ(0.123f, mt.get<float>());
     491        EXPECT_EQ(0.123, mt.get<double>());
     492        EXPECT_DOUBLE_EQ(0.123, mt.get<long double>());
     493        EXPECT_FALSE(mt.get<bool>());
     494        EXPECT_EQ("0.123", mt.get<std::string>());
    495495    }
    496496
Note: See TracChangeset for help on using the changeset viewer.