// RUN: %check_clang_tidy %s hicpp-multiway-paths-covered %t
enum OS { Mac,
Windows,
Linux };
struct Bitfields {
unsigned UInt : 3;
int SInt : 1;
};
int return_integer() { return 42; }
void bad_switch(int i) {
switch (i) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: switch with only one case; use an if statement
case 0:
break;
}
// No default in this switch
switch (i) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: potential uncovered code path; add a default label
case 0:
break;
case 1:
break;
case 2:
break;
}
// degenerate, maybe even warning
switch (i) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: switch statement without labels has no effect
}
switch (int j = return_integer()) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: potential uncovered code path; add a default label
case 0:
case 1:
case 2:
break;
}
// Degenerated, only default case.
switch (i) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: degenerated switch with default label only
default:
break;
}
// Degenerated, only one case label and default case -> Better as if-stmt.
switch (i) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: switch could be better written as an if/else statement
case 0:
break;
default:
break;
}
unsigned long long BigNumber = 0;
switch (BigNumber) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: potential uncovered code path; add a default label
case 0:
case 1:
break;
}
const int &IntRef = i;
switch (IntRef) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: potential uncovered code path; add a default label
case 0:
case 1:
break;
}
char C = 'A';
switch (C) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: potential uncovered code path; add a default label
case 'A':
break;
case 'B':
break;
}
Bitfields Bf;
// UInt has 3 bits size.
switch (Bf.UInt) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: potential uncovered code path; add a default label
case 0:
case 1:
break;
}
// All paths explicitly covered.
switch (Bf.UInt) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
break;
}
// SInt has 1 bit size, so this is somewhat degenerated.
switch (Bf.SInt) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: switch with only one case; use an if statement
case 0:
break;
}
// All paths explicitly covered.
switch (Bf.SInt) {
case 0:
case 1:
break;
}
bool Flag = false;
switch (Flag) {
// CHECK-MESSAGES:[[@LINE-1]]:3: warning: switch with only one case; use an if statement
case true:
break;
}
switch (Flag) {
// CHECK-MESSAGES: [[@LINE-1]]:3: warning: degenerated switch with default label only
default:
break;
}
// This `switch` will create a frontend warning from '-Wswitch-bool' but is
// ok for this check.
switch (Flag) {
case true:
break;
case false:
break;
}
}
void unproblematic_switch(unsigned char c) {
//
switch (c) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
case 38:
case 39:
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
case 48:
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
case 58:
case 59:
case 60:
case 61:
case 62:
case 63:
case 64:
case 65:
case 66:
case 67:
case 68:
case 69:
case 70:
case 71:
case 72:
case 73:
case 74:
case 75:
case 76:
case 77:
case 78:
case 79:
case 80:
case 81:
case 82:
case 83:
case 84:
case 85:
case 86:
case 87:
case 88:
case 89:
case 90:
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
case 98:
case 99:
case 100:
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
case 108:
case 109:
case 110:
case 111:
case 112:
case 113:
case 114:
case 115:
case 116:
case 117:
case 118:
case 119:
case 120:
case 121:
case 122:
case 123:
case 124:
case 125:
case 126:
case 127:
case 128:
case 129:
case 130:
case 131:
case 132:
case 133:
case 134:
case 135:
case 136:
case 137:
case 138:
case 139:
case 140:
case 141:
case 142:
case 143:
case 144:
case 145:
case 146:
case 147:
case 148:
case 149:
case 150:
case 151:
case 152:
case 153:
case 154:
case 155:
case 156:
case 157:
case 158:
case 159:
case 160:
case 161:
case 162:
case 163:
case 164:
case 165:
case 166:
case 167:
case 168:
case 169:
case 170:
case 171:
case 172:
case 173:
case 174:
case 175:
case 176:
case 177:
case 178:
case 179:
case 180:
case 181:
case 182:
case 183:
case 184:
case 185:
case 186:
case 187:
case 188:
case 189:
case 190:
case 191:
case 192:
case 193:
case 194:
case 195:
case 196:
case 197:
case 198:
case 199:
case 200:
case 201:
case 202:
case 203:
case 204:
case 205:
case 206:
case 207:
case 208:
case 209:
case 210:
case 211:
case 212:
case 213:
case 214:
case 215:
case 216:
case 217:
case 218:
case 219:
case 220:
case 221:
case 222:
case 223:
case 224:
case 225:
case 226:
case 227:
case 228:
case 229:
case 230:
case 231:
case 232:
case 233:
case 234:
case 235:
case 236:
case 237:
case 238:
case 239:
case 240:
case 241:
case 242:
case 243:
case 244:
case 245:
case 246:
case 247:
case 248:
case 249:
case 250:
case 251:
case 252:
case 253:
case 254:
case 255:
break;
}
// Some paths are covered by the switch and a default case is present.
switch (c) {
case 1:
case 2:
case 3:
default:
break;
}
}
OS return_enumerator() {
return Linux;
}
// Enumpaths are already covered by a warning, this is just to ensure, that there is
// no interference or false positives.
// -Wswitch warns about uncovered enum paths and each here described case is already
// covered.
void switch_enums(OS os) {
switch (os) {
case Linux:
break;
}
switch (OS another_os = return_enumerator()) {
case Linux:
break;
}
switch (os) {
}
}
/// All of these cases will not emit a warning per default, but with explicit activation.
/// Covered in extra test file.
void problematic_if(int i, enum OS os) {
if (i > 0) {
return;
} else if (i < 0) {
return;
}
if (os == Mac) {
return;
} else if (os == Linux) {
if (true) {
return;
} else if (false) {
return;
}
return;
} else {
/* unreachable */
if (true) // check if the parent would match here as well
return;
}
// Ok, because all paths are covered
if (i > 0) {
return;
} else if (i < 0) {
return;
} else {
/* error, maybe precondition failed */
}
}
Codebase Browser
llvm