framework/common/tcuEither.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Tester Core
   3  * ----------------------------------------
   4  *
   5  * Copyright 2015 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Template class that is either type of Left or Right.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "tcuEither.hpp"
  25
  26 namespace tcu
  27 {
  28 namespace
  29 {
  30
  31 enum
  32 {
  33         COPYCHECK_VALUE = 1637423219
  34 };
  35
  36 class TestClassWithConstructor
  37 {
  38 public:
  39         TestClassWithConstructor (int i)
  40                 : m_i                   (i)
  41                 , m_copyCheck   (COPYCHECK_VALUE)
  42         {
  43         }
  44
  45         ~TestClassWithConstructor (void)
  46         {
  47                 TCU_CHECK(m_copyCheck == COPYCHECK_VALUE);
  48         }
  49
  50         TestClassWithConstructor (const TestClassWithConstructor& other)
  51                 : m_i                   (other.m_i)
  52                 , m_copyCheck   (other.m_copyCheck)
  53         {
  54         }
  55
  56         TestClassWithConstructor& operator= (const TestClassWithConstructor& other)
  57         {
  58                 TCU_CHECK(m_copyCheck == COPYCHECK_VALUE);
  59
  60                 if (this == &other)
  61                         return *this;
  62
  63                 m_i = other.m_i;
  64                 m_copyCheck = other.m_copyCheck;
  65
  66                 TCU_CHECK(m_copyCheck == COPYCHECK_VALUE);
  67
  68                 return *this;
  69         }
  70
  71         int getValue (void) const
  72         {
  73                 TCU_CHECK(m_copyCheck == COPYCHECK_VALUE);
  74
  75                 return m_i;
  76         }
  77
  78 private:
  79         int m_i;
  80         int m_copyCheck;
  81 };
  82
  83 } // anonymous
  84
  85 void Either_selfTest (void)
  86 {
  87         // Simple test for first
  88         {
  89                 const int                                       intValue        = 1503457782;
  90                 const Either<int, float>        either          (intValue);
  91
  92                 TCU_CHECK(either.isFirst());
  93                 TCU_CHECK(!either.isSecond());
  94
  95                 TCU_CHECK(either.is<int>());
  96                 TCU_CHECK(!either.is<float>());
  97
  98                 TCU_CHECK(either.getFirst() == intValue);
  99                 TCU_CHECK(either.get<int>() == intValue);
 100         }
 101
 102         // Simple test for second
 103         {
 104                 const float                                     floatValue      = 0.43223332995f;
 105                 const Either<int, float>        either          (floatValue);
 106
 107                 TCU_CHECK(!either.isFirst());
 108                 TCU_CHECK(either.isSecond());
 109
 110                 TCU_CHECK(!either.is<int>());
 111                 TCU_CHECK(either.is<float>());
 112
 113                 TCU_CHECK(either.getSecond() == floatValue);
 114                 TCU_CHECK(either.get<float>() == floatValue);
 115         }
 116
 117         // Assign first value
 118         {
 119                 const int                       intValue        = 1942092699;
 120                 const float                     floatValue      = 0.43223332995f;
 121                 Either<int, float>      either          (floatValue);
 122
 123                 either = intValue;
 124
 125                 TCU_CHECK(either.isFirst());
 126                 TCU_CHECK(!either.isSecond());
 127
 128                 TCU_CHECK(either.is<int>());
 129                 TCU_CHECK(!either.is<float>());
 130
 131                 TCU_CHECK(either.getFirst() == intValue);
 132                 TCU_CHECK(either.get<int>() == intValue);
 133         }
 134
 135         // Assign second value
 136         {
 137                 const int                       intValue        = 1942092699;
 138                 const float                     floatValue      = 0.43223332995f;
 139                 Either<int, float>      either          (intValue);
 140
 141                 either = floatValue;
 142
 143                 TCU_CHECK(!either.isFirst());
 144                 TCU_CHECK(either.isSecond());
 145
 146                 TCU_CHECK(!either.is<int>());
 147                 TCU_CHECK(either.is<float>());
 148
 149                 TCU_CHECK(either.getSecond() == floatValue);
 150                 TCU_CHECK(either.get<float>() == floatValue);
 151         }
 152
 153         // Assign first either value
 154         {
 155                 const int                                       intValue        = 1942092699;
 156                 const float                                     floatValue      = 0.43223332995f;
 157                 Either<int, float>                      either          (floatValue);
 158                 const Either<int, float>        otherEither     (intValue);
 159
 160                 either = otherEither;
 161
 162                 TCU_CHECK(either.isFirst());
 163                 TCU_CHECK(!either.isSecond());
 164
 165                 TCU_CHECK(either.is<int>());
 166                 TCU_CHECK(!either.is<float>());
 167
 168                 TCU_CHECK(either.getFirst() == intValue);
 169                 TCU_CHECK(either.get<int>() == intValue);
 170         }
 171
 172         // Assign second either value
 173         {
 174                 const int                                       intValue        = 1942092699;
 175                 const float                                     floatValue      = 0.43223332995f;
 176                 Either<int, float>                      either          (intValue);
 177                 const Either<int, float>        otherEither     (floatValue);
 178
 179                 either = otherEither;
 180
 181                 TCU_CHECK(!either.isFirst());
 182                 TCU_CHECK(either.isSecond());
 183
 184                 TCU_CHECK(!either.is<int>());
 185                 TCU_CHECK(either.is<float>());
 186
 187                 TCU_CHECK(either.getSecond() == floatValue);
 188                 TCU_CHECK(either.get<float>() == floatValue);
 189         }
 190
 191         // Simple test for first with constructor
 192         {
 193                 const TestClassWithConstructor                          testObject      (171899615);
 194                 const Either<TestClassWithConstructor, int>     either          (testObject);
 195
 196                 TCU_CHECK(either.isFirst());
 197                 TCU_CHECK(!either.isSecond());
 198
 199                 TCU_CHECK(either.is<TestClassWithConstructor>());
 200                 TCU_CHECK(!either.is<int>());
 201
 202                 TCU_CHECK(either.getFirst().getValue() == testObject.getValue());
 203                 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
 204         }
 205
 206         // Simple test for second with constructor
 207         {
 208                 const TestClassWithConstructor                          testObject      (171899615);
 209                 const Either<int, TestClassWithConstructor>     either          (testObject);
 210
 211                 TCU_CHECK(!either.isFirst());
 212                 TCU_CHECK(either.isSecond());
 213
 214                 TCU_CHECK(either.is<TestClassWithConstructor>());
 215                 TCU_CHECK(!either.is<int>());
 216
 217                 TCU_CHECK(either.getSecond().getValue() == testObject.getValue());
 218                 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
 219         }
 220
 221         // Assign first with constructor
 222         {
 223                 const int                                                               intValue        = 1942092699;
 224                 const TestClassWithConstructor                  testObject      (171899615);
 225                 Either<TestClassWithConstructor, int>   either          (intValue);
 226
 227                 either = testObject;
 228
 229                 TCU_CHECK(either.isFirst());
 230                 TCU_CHECK(!either.isSecond());
 231
 232                 TCU_CHECK(either.is<TestClassWithConstructor>());
 233                 TCU_CHECK(!either.is<int>());
 234
 235                 TCU_CHECK(either.getFirst().getValue() == testObject.getValue());
 236                 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
 237         }
 238
 239         // Assign second with constructor
 240         {
 241                 const int                                                               intValue        = 1942092699;
 242                 const TestClassWithConstructor                  testObject      (171899615);
 243                 Either<int, TestClassWithConstructor>   either          (intValue);
 244
 245                 either = testObject;
 246
 247                 TCU_CHECK(!either.isFirst());
 248                 TCU_CHECK(either.isSecond());
 249
 250                 TCU_CHECK(either.is<TestClassWithConstructor>());
 251                 TCU_CHECK(!either.is<int>());
 252
 253                 TCU_CHECK(either.getSecond().getValue() == testObject.getValue());
 254                 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
 255         }
 256
 257         // Assign first either with constructor
 258         {
 259                 const int                                                                       intValue        = 1942092699;
 260                 const TestClassWithConstructor                          testObject      (171899615);
 261                 Either<TestClassWithConstructor, int>           either          (intValue);
 262                 const Either<TestClassWithConstructor, int>     otherEither     (testObject);
 263
 264                 either = otherEither;
 265
 266                 TCU_CHECK(either.isFirst());
 267                 TCU_CHECK(!either.isSecond());
 268
 269                 TCU_CHECK(either.is<TestClassWithConstructor>());
 270                 TCU_CHECK(!either.is<int>());
 271
 272                 TCU_CHECK(either.getFirst().getValue() == testObject.getValue());
 273                 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
 274         }
 275
 276         // Assign second either with constructor
 277         {
 278                 const int                                                                       intValue        = 1942092699;
 279                 const TestClassWithConstructor                          testObject      (171899615);
 280                 Either<int, TestClassWithConstructor>           either          (intValue);
 281                 const Either<int, TestClassWithConstructor>     otherEither     (testObject);
 282
 283                 either = otherEither;
 284
 285                 TCU_CHECK(!either.isFirst());
 286                 TCU_CHECK(either.isSecond());
 287
 288                 TCU_CHECK(either.is<TestClassWithConstructor>());
 289                 TCU_CHECK(!either.is<int>());
 290
 291                 TCU_CHECK(either.getSecond().getValue() == testObject.getValue());
 292                 TCU_CHECK(either.get<TestClassWithConstructor>().getValue() == testObject.getValue());
 293         }
 294 }
 295
 296 } // tcu