1 // Written in the D programming language. 2 3 /++ 4 Functions which operate on ASCII characters. 5 6 All of the functions in std.ascii accept Unicode characters but 7 effectively ignore them if they're not ASCII. All `isX` functions return 8 `false` for non-ASCII characters, and all `toX` functions do nothing 9 to non-ASCII characters. 10 11 For functions which operate on Unicode characters, see 12 $(MREF std, uni). 13 14 $(SCRIPT inhibitQuickIndex = 1;) 15 $(DIVC quickindex, 16 $(BOOKTABLE, 17 $(TR $(TH Category) $(TH Functions)) 18 $(TR $(TD Validation) $(TD 19 $(LREF isAlpha) 20 $(LREF isAlphaNum) 21 $(LREF isASCII) 22 $(LREF isControl) 23 $(LREF isDigit) 24 $(LREF isGraphical) 25 $(LREF isHexDigit) 26 $(LREF isOctalDigit) 27 $(LREF isPrintable) 28 $(LREF isPunctuation) 29 $(LREF isUpper) 30 $(LREF isWhite) 31 )) 32 $(TR $(TD Conversions) $(TD 33 $(LREF toLower) 34 $(LREF toUpper) 35 )) 36 $(TR $(TD Constants) $(TD 37 $(LREF digits) 38 $(LREF fullHexDigits) 39 $(LREF hexDigits) 40 $(LREF letters) 41 $(LREF lowercase) 42 $(LREF lowerHexDigits) 43 $(LREF newline) 44 $(LREF octalDigits) 45 $(LREF uppercase) 46 $(LREF whitespace) 47 )) 48 $(TR $(TD Enums) $(TD 49 $(LREF ControlChar) 50 $(LREF LetterCase) 51 )) 52 )) 53 References: 54 $(LINK2 http://www.digitalmars.com/d/ascii-table.html, ASCII Table), 55 $(HTTP en.wikipedia.org/wiki/Ascii, Wikipedia) 56 57 License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). 58 Authors: $(HTTP digitalmars.com, Walter Bright) and 59 $(HTTP jmdavisprog.com, Jonathan M Davis) 60 Source: $(PHOBOSSRC std/ascii.d) 61 +/ 62 module std.ascii; 63 64 immutable fullHexDigits = "0123456789ABCDEFabcdef"; /// 0 .. 9A .. Fa .. f 65 immutable hexDigits = fullHexDigits[0 .. 16]; /// 0 .. 9A .. F 66 immutable lowerHexDigits = "0123456789abcdef"; /// 0 .. 9a .. f 67 immutable digits = hexDigits[0 .. 10]; /// 0 .. 9 68 immutable octalDigits = digits[0 .. 8]; /// 0 .. 7 69 immutable letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; /// A .. Za .. z 70 immutable uppercase = letters[0 .. 26]; /// A .. Z 71 immutable lowercase = letters[26 .. 52]; /// a .. z 72 immutable whitespace = " \t\v\r\n\f"; /// ASCII _whitespace 73 74 /++ 75 Letter case specifier. 76 +/ 77 enum LetterCase : bool 78 { 79 upper, /// Upper case letters 80 lower /// Lower case letters 81 } 82 83 /// 84 @safe unittest 85 { 86 import std.conv : to; 87 88 assert(42.to!string(16, LetterCase.upper) == "2A"); 89 assert(42.to!string(16, LetterCase.lower) == "2a"); 90 } 91 92 /// 93 @safe unittest 94 { 95 import std.digest.hmac : hmac; 96 import std.digest : toHexString; 97 import std.digest.sha : SHA1; 98 import std.string : representation; 99 100 const sha1HMAC = "A very long phrase".representation 101 .hmac!SHA1("secret".representation) 102 .toHexString!(LetterCase.lower); 103 assert(sha1HMAC == "49f2073c7bf58577e8c9ae59fe8cfd37c9ab94e5"); 104 } 105 106 /++ 107 All control characters in the ASCII table ($(HTTPS www.asciitable.com, source)). 108 +/ 109 enum ControlChar : char 110 { 111 nul = '\x00', /// Null 112 soh = '\x01', /// Start of heading 113 stx = '\x02', /// Start of text 114 etx = '\x03', /// End of text 115 eot = '\x04', /// End of transmission 116 enq = '\x05', /// Enquiry 117 ack = '\x06', /// Acknowledge 118 bel = '\x07', /// Bell 119 bs = '\x08', /// Backspace 120 tab = '\x09', /// Horizontal tab 121 lf = '\x0A', /// NL line feed, new line 122 vt = '\x0B', /// Vertical tab 123 ff = '\x0C', /// NP form feed, new page 124 cr = '\x0D', /// Carriage return 125 so = '\x0E', /// Shift out 126 si = '\x0F', /// Shift in 127 dle = '\x10', /// Data link escape 128 dc1 = '\x11', /// Device control 1 129 dc2 = '\x12', /// Device control 2 130 dc3 = '\x13', /// Device control 3 131 dc4 = '\x14', /// Device control 4 132 nak = '\x15', /// Negative acknowledge 133 syn = '\x16', /// Synchronous idle 134 etb = '\x17', /// End of transmission block 135 can = '\x18', /// Cancel 136 em = '\x19', /// End of medium 137 sub = '\x1A', /// Substitute 138 esc = '\x1B', /// Escape 139 fs = '\x1C', /// File separator 140 gs = '\x1D', /// Group separator 141 rs = '\x1E', /// Record separator 142 us = '\x1F', /// Unit separator 143 del = '\x7F' /// Delete 144 } 145 146 /// 147 @safe pure nothrow @nogc unittest 148 { 149 import std.algorithm.comparison, std.algorithm.searching, std.range, std.traits; 150 151 // Because all ASCII characters fit in char, so do these 152 static assert(ControlChar.ack.sizeof == 1); 153 154 // All control characters except del are in row starting from 0 155 static assert(EnumMembers!ControlChar.only.until(ControlChar.del).equal(iota(32))); 156 157 static assert(ControlChar.nul == '\0'); 158 static assert(ControlChar.bel == '\a'); 159 static assert(ControlChar.bs == '\b'); 160 static assert(ControlChar.ff == '\f'); 161 static assert(ControlChar.lf == '\n'); 162 static assert(ControlChar.cr == '\r'); 163 static assert(ControlChar.tab == '\t'); 164 static assert(ControlChar.vt == '\v'); 165 } 166 167 /// 168 @safe pure nothrow unittest 169 { 170 import std.conv; 171 //Control character table can be used in place of hexcodes. 172 with (ControlChar) assert(text("Phobos", us, "Deimos", us, "Tango", rs) == "Phobos\x1FDeimos\x1FTango\x1E"); 173 } 174 175 /// Newline sequence for this system. 176 version (Windows) 177 immutable newline = "\r\n"; 178 else version (Posix) 179 immutable newline = "\n"; 180 else 181 static assert(0, "Unsupported OS"); 182 183 184 /++ 185 Params: c = The character to test. 186 Returns: Whether `c` is a letter or a number (0 .. 9, a .. z, A .. Z). 187 +/ 188 bool isAlphaNum(dchar c) @safe pure nothrow @nogc 189 { 190 const hc = c | 0x20; 191 return ('0' <= c && c <= '9') || ('a' <= hc && hc <= 'z'); 192 } 193 194 /// 195 @safe pure nothrow @nogc unittest 196 { 197 assert( isAlphaNum('A')); 198 assert( isAlphaNum('1')); 199 assert(!isAlphaNum('#')); 200 201 // N.B.: does not return true for non-ASCII Unicode alphanumerics: 202 assert(!isAlphaNum('á')); 203 } 204 205 @safe unittest 206 { 207 import std.range; 208 foreach (c; chain(digits, octalDigits, fullHexDigits, letters, lowercase, uppercase)) 209 assert(isAlphaNum(c)); 210 211 foreach (c; whitespace) 212 assert(!isAlphaNum(c)); 213 } 214 215 216 /++ 217 Params: c = The character to test. 218 Returns: Whether `c` is an ASCII letter (A .. Z, a .. z). 219 +/ 220 bool isAlpha(dchar c) @safe pure nothrow @nogc 221 { 222 // Optimizer can turn this into a bitmask operation on 64 bit code 223 return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); 224 } 225 226 /// 227 @safe pure nothrow @nogc unittest 228 { 229 assert( isAlpha('A')); 230 assert(!isAlpha('1')); 231 assert(!isAlpha('#')); 232 233 // N.B.: does not return true for non-ASCII Unicode alphabetic characters: 234 assert(!isAlpha('á')); 235 } 236 237 @safe unittest 238 { 239 import std.range; 240 foreach (c; chain(letters, lowercase, uppercase)) 241 assert(isAlpha(c)); 242 243 foreach (c; chain(digits, octalDigits, whitespace)) 244 assert(!isAlpha(c)); 245 } 246 247 248 /++ 249 Params: c = The character to test. 250 Returns: Whether `c` is a lowercase ASCII letter (a .. z). 251 +/ 252 bool isLower(dchar c) @safe pure nothrow @nogc 253 { 254 return c >= 'a' && c <= 'z'; 255 } 256 257 /// 258 @safe pure nothrow @nogc unittest 259 { 260 assert( isLower('a')); 261 assert(!isLower('A')); 262 assert(!isLower('#')); 263 264 // N.B.: does not return true for non-ASCII Unicode lowercase letters 265 assert(!isLower('á')); 266 assert(!isLower('Á')); 267 } 268 269 @safe unittest 270 { 271 import std.range; 272 foreach (c; lowercase) 273 assert(isLower(c)); 274 275 foreach (c; chain(digits, uppercase, whitespace)) 276 assert(!isLower(c)); 277 } 278 279 280 /++ 281 Params: c = The character to test. 282 Returns: Whether `c` is an uppercase ASCII letter (A .. Z). 283 +/ 284 bool isUpper(dchar c) @safe pure nothrow @nogc 285 { 286 return c <= 'Z' && 'A' <= c; 287 } 288 289 /// 290 @safe pure nothrow @nogc unittest 291 { 292 assert( isUpper('A')); 293 assert(!isUpper('a')); 294 assert(!isUpper('#')); 295 296 // N.B.: does not return true for non-ASCII Unicode uppercase letters 297 assert(!isUpper('á')); 298 assert(!isUpper('Á')); 299 } 300 301 @safe unittest 302 { 303 import std.range; 304 foreach (c; uppercase) 305 assert(isUpper(c)); 306 307 foreach (c; chain(digits, lowercase, whitespace)) 308 assert(!isUpper(c)); 309 } 310 311 312 /++ 313 Params: c = The character to test. 314 Returns: Whether `c` is a digit (0 .. 9). 315 +/ 316 bool isDigit(dchar c) @safe pure nothrow @nogc 317 { 318 return '0' <= c && c <= '9'; 319 } 320 321 /// 322 @safe pure nothrow @nogc unittest 323 { 324 assert( isDigit('3')); 325 assert( isDigit('8')); 326 assert(!isDigit('B')); 327 assert(!isDigit('#')); 328 329 // N.B.: does not return true for non-ASCII Unicode numbers 330 assert(!isDigit('０')); // full-width digit zero (U+FF10) 331 assert(!isDigit('４')); // full-width digit four (U+FF14) 332 } 333 334 @safe unittest 335 { 336 import std.range; 337 foreach (c; digits) 338 assert(isDigit(c)); 339 340 foreach (c; chain(letters, whitespace)) 341 assert(!isDigit(c)); 342 } 343 344 345 /++ 346 Params: c = The character to test. 347 Returns: Whether `c` is a digit in base 8 (0 .. 7). 348 +/ 349 bool isOctalDigit(dchar c) @safe pure nothrow @nogc 350 { 351 return c >= '0' && c <= '7'; 352 } 353 354 /// 355 @safe pure nothrow @nogc unittest 356 { 357 assert( isOctalDigit('0')); 358 assert( isOctalDigit('7')); 359 assert(!isOctalDigit('8')); 360 assert(!isOctalDigit('A')); 361 assert(!isOctalDigit('#')); 362 } 363 364 @safe unittest 365 { 366 import std.range; 367 foreach (c; octalDigits) 368 assert(isOctalDigit(c)); 369 370 foreach (c; chain(letters, ['8', '9'], whitespace)) 371 assert(!isOctalDigit(c)); 372 } 373 374 375 /++ 376 Params: c = The character to test. 377 Returns: Whether `c` is a digit in base 16 (0 .. 9, A .. F, a .. f). 378 +/ 379 bool isHexDigit(dchar c) @safe pure nothrow @nogc 380 { 381 const hc = c | 0x20; 382 return ('0' <= c && c <= '9') || ('a' <= hc && hc <= 'f'); 383 } 384 385 /// 386 @safe pure nothrow @nogc unittest 387 { 388 assert( isHexDigit('0')); 389 assert( isHexDigit('A')); 390 assert( isHexDigit('f')); // lowercase hex digits are accepted 391 assert(!isHexDigit('g')); 392 assert(!isHexDigit('G')); 393 assert(!isHexDigit('#')); 394 } 395 396 @safe unittest 397 { 398 import std.range; 399 foreach (c; fullHexDigits) 400 assert(isHexDigit(c)); 401 402 foreach (c; chain(lowercase[6 .. $], uppercase[6 .. $], whitespace)) 403 assert(!isHexDigit(c)); 404 } 405 406 407 /++ 408 Params: c = The character to test. 409 Returns: Whether or not `c` is a whitespace character. That includes the 410 space, tab, vertical tab, form feed, carriage return, and linefeed 411 characters. 412 +/ 413 bool isWhite(dchar c) @safe pure nothrow @nogc 414 { 415 return c == ' ' || (c >= 0x09 && c <= 0x0D); 416 } 417 418 /// 419 @safe pure nothrow @nogc unittest 420 { 421 assert( isWhite(' ')); 422 assert( isWhite('\t')); 423 assert( isWhite('\n')); 424 assert(!isWhite('1')); 425 assert(!isWhite('a')); 426 assert(!isWhite('#')); 427 428 // N.B.: Does not return true for non-ASCII Unicode whitespace characters. 429 static import std.uni; 430 assert(std.uni.isWhite('\u00A0')); 431 assert(!isWhite('\u00A0')); // std.ascii.isWhite 432 } 433 434 @safe unittest 435 { 436 import std.range; 437 foreach (c; whitespace) 438 assert(isWhite(c)); 439 440 foreach (c; chain(digits, letters)) 441 assert(!isWhite(c)); 442 } 443 444 445 /++ 446 Params: c = The character to test. 447 Returns: Whether `c` is a control character. 448 +/ 449 bool isControl(dchar c) @safe pure nothrow @nogc 450 { 451 return c < 0x20 || c == 0x7F; 452 } 453 454 /// 455 @safe pure nothrow @nogc unittest 456 { 457 assert( isControl('\0')); 458 assert( isControl('\022')); 459 assert( isControl('\n')); // newline is both whitespace and control 460 assert(!isControl(' ')); 461 assert(!isControl('1')); 462 assert(!isControl('a')); 463 assert(!isControl('#')); 464 465 // N.B.: non-ASCII Unicode control characters are not recognized: 466 assert(!isControl('\u0080')); 467 assert(!isControl('\u2028')); 468 assert(!isControl('\u2029')); 469 } 470 471 @safe unittest 472 { 473 import std.range; 474 foreach (dchar c; 0 .. 32) 475 assert(isControl(c)); 476 assert(isControl(127)); 477 478 foreach (c; chain(digits, letters, [' '])) 479 assert(!isControl(c)); 480 } 481 482 483 /++ 484 Params: c = The character to test. 485 Returns: Whether or not `c` is a punctuation character. That includes 486 all ASCII characters which are not control characters, letters, digits, or 487 whitespace. 488 +/ 489 bool isPunctuation(dchar c) @safe pure nothrow @nogc 490 { 491 return c <= '~' && c >= '!' && !isAlphaNum(c); 492 } 493 494 /// 495 @safe pure nothrow @nogc unittest 496 { 497 assert( isPunctuation('.')); 498 assert( isPunctuation(',')); 499 assert( isPunctuation(':')); 500 assert( isPunctuation('!')); 501 assert( isPunctuation('#')); 502 assert( isPunctuation('~')); 503 assert( isPunctuation('+')); 504 assert( isPunctuation('_')); 505 506 assert(!isPunctuation('1')); 507 assert(!isPunctuation('a')); 508 assert(!isPunctuation(' ')); 509 assert(!isPunctuation('\n')); 510 assert(!isPunctuation('\0')); 511 512 // N.B.: Non-ASCII Unicode punctuation characters are not recognized. 513 assert(!isPunctuation('\u2012')); // (U+2012 = en-dash) 514 } 515 516 @safe unittest 517 { 518 foreach (dchar c; 0 .. 128) 519 { 520 if (isControl(c) || isAlphaNum(c) || c == ' ') 521 assert(!isPunctuation(c)); 522 else 523 assert(isPunctuation(c)); 524 } 525 } 526 527 528 /++ 529 Params: c = The character to test. 530 Returns: Whether or not `c` is a printable character other than the 531 space character. 532 +/ 533 bool isGraphical(dchar c) @safe pure nothrow @nogc 534 { 535 return '!' <= c && c <= '~'; 536 } 537 538 /// 539 @safe pure nothrow @nogc unittest 540 { 541 assert( isGraphical('1')); 542 assert( isGraphical('a')); 543 assert( isGraphical('#')); 544 assert(!isGraphical(' ')); // whitespace is not graphical 545 assert(!isGraphical('\n')); 546 assert(!isGraphical('\0')); 547 548 // N.B.: Unicode graphical characters are not regarded as such. 549 assert(!isGraphical('á')); 550 } 551 552 @safe unittest 553 { 554 foreach (dchar c; 0 .. 128) 555 { 556 if (isControl(c) || c == ' ') 557 assert(!isGraphical(c)); 558 else 559 assert(isGraphical(c)); 560 } 561 } 562 563 564 /++ 565 Params: c = The character to test. 566 Returns: Whether or not `c` is a printable character - including the 567 space character. 568 +/ 569 bool isPrintable(dchar c) @safe pure nothrow @nogc 570 { 571 return c >= ' ' && c <= '~'; 572 } 573 574 /// 575 @safe pure nothrow @nogc unittest 576 { 577 assert( isPrintable(' ')); // whitespace is printable 578 assert( isPrintable('1')); 579 assert( isPrintable('a')); 580 assert( isPrintable('#')); 581 assert(!isPrintable('\0')); // control characters are not printable 582 583 // N.B.: Printable non-ASCII Unicode characters are not recognized. 584 assert(!isPrintable('á')); 585 } 586 587 @safe unittest 588 { 589 foreach (dchar c; 0 .. 128) 590 { 591 if (isControl(c)) 592 assert(!isPrintable(c)); 593 else 594 assert(isPrintable(c)); 595 } 596 } 597 598 599 /++ 600 Params: c = The character to test. 601 Returns: Whether or not `c` is in the ASCII character set - i.e. in the 602 range 0 .. 0x7F. 603 +/ 604 pragma(inline, true) 605 bool isASCII(dchar c) @safe pure nothrow @nogc 606 { 607 return c <= 0x7F; 608 } 609 610 /// 611 @safe pure nothrow @nogc unittest 612 { 613 assert( isASCII('a')); 614 assert(!isASCII('á')); 615 } 616 617 @safe unittest 618 { 619 foreach (dchar c; 0 .. 128) 620 assert(isASCII(c)); 621 622 assert(!isASCII(128)); 623 } 624 625 626 /++ 627 Converts an ASCII letter to lowercase. 628 629 Params: c = A character of any type that implicitly converts to `dchar`. 630 In the case where it's a built-in type, or an enum of a built-in type, 631 `Unqual!(OriginalType!C)` is returned, whereas if it's a user-defined 632 type, `dchar` is returned. 633 634 Returns: The corresponding lowercase letter, if `c` is an uppercase 635 ASCII character, otherwise `c` itself. 636 +/ 637 auto toLower(C)(C c) 638 if (is(C : dchar)) 639 { 640 import std.traits : OriginalType; 641 642 static if (!__traits(isScalar, C)) 643 alias R = dchar; 644 else static if (is(immutable OriginalType!C == immutable OC, OC)) 645 alias R = OC; 646 647 return isUpper(c) ? cast(R)(cast(R) c + 'a' - 'A') : cast(R) c; 648 } 649 650 /// 651 @safe pure nothrow @nogc unittest 652 { 653 assert(toLower('a') == 'a'); 654 assert(toLower('A') == 'a'); 655 assert(toLower('#') == '#'); 656 657 // N.B.: Non-ASCII Unicode uppercase letters are not converted. 658 assert(toLower('Á') == 'Á'); 659 } 660 661 @safe pure nothrow unittest 662 { 663 664 import std.meta; 665 static foreach (C; AliasSeq!(char, wchar, dchar, immutable char, ubyte)) 666 { 667 foreach (i, c; uppercase) 668 assert(toLower(cast(C) c) == lowercase[i]); 669 670 foreach (C c; 0 .. 128) 671 { 672 if (c < 'A' || c > 'Z') 673 assert(toLower(c) == c); 674 else 675 assert(toLower(c) != c); 676 } 677 678 foreach (C c; 128 .. C.max) 679 assert(toLower(c) == c); 680 681 //CTFE 682 static assert(toLower(cast(C)'a') == 'a'); 683 static assert(toLower(cast(C)'A') == 'a'); 684 } 685 } 686 687 688 /++ 689 Converts an ASCII letter to uppercase. 690 691 Params: c = Any type which implicitly converts to `dchar`. In the case 692 where it's a built-in type, or an enum of a built-in type, 693 `Unqual!(OriginalType!C)` is returned, whereas if it's a user-defined 694 type, `dchar` is returned. 695 696 Returns: The corresponding uppercase letter, if `c` is a lowercase ASCII 697 character, otherwise `c` itself. 698 +/ 699 auto toUpper(C)(C c) 700 if (is(C : dchar)) 701 { 702 import std.traits : OriginalType; 703 704 static if (!__traits(isScalar, C)) 705 alias R = dchar; 706 else static if (is(immutable OriginalType!C == immutable OC, OC)) 707 alias R = OC; 708 709 return isLower(c) ? cast(R)(cast(R) c - ('a' - 'A')) : cast(R) c; 710 } 711 712 /// 713 @safe pure nothrow @nogc unittest 714 { 715 assert(toUpper('a') == 'A'); 716 assert(toUpper('A') == 'A'); 717 assert(toUpper('#') == '#'); 718 719 // N.B.: Non-ASCII Unicode lowercase letters are not converted. 720 assert(toUpper('á') == 'á'); 721 } 722 723 @safe pure nothrow unittest 724 { 725 import std.meta; 726 static foreach (C; AliasSeq!(char, wchar, dchar, immutable char, ubyte)) 727 { 728 foreach (i, c; lowercase) 729 assert(toUpper(cast(C) c) == uppercase[i]); 730 731 foreach (C c; 0 .. 128) 732 { 733 if (c < 'a' || c > 'z') 734 assert(toUpper(c) == c); 735 else 736 assert(toUpper(c) != c); 737 } 738 739 foreach (C c; 128 .. C.max) 740 assert(toUpper(c) == c); 741 742 //CTFE 743 static assert(toUpper(cast(C)'a') == 'A'); 744 static assert(toUpper(cast(C)'A') == 'A'); 745 } 746 } 747 748 749 @safe unittest //Test both toUpper and toLower with non-builtin 750 { 751 import std.meta; 752 import std.traits; 753 754 //User Defined [Char|Wchar|Dchar] 755 static struct UDC { char c; alias c this; } 756 static struct UDW { wchar c; alias c this; } 757 static struct UDD { dchar c; alias c this; } 758 //[Char|Wchar|Dchar] Enum 759 enum CE : char {a = 'a', A = 'A'} 760 enum WE : wchar {a = 'a', A = 'A'} 761 enum DE : dchar {a = 'a', A = 'A'} 762 //User Defined [Char|Wchar|Dchar] Enum 763 enum UDCE : UDC {a = UDC('a'), A = UDC('A')} 764 enum UDWE : UDW {a = UDW('a'), A = UDW('A')} 765 enum UDDE : UDD {a = UDD('a'), A = UDD('A')} 766 767 //User defined types with implicit cast to dchar test. 768 static foreach (Char; AliasSeq!(UDC, UDW, UDD)) 769 { 770 assert(toLower(Char('a')) == 'a'); 771 assert(toLower(Char('A')) == 'a'); 772 static assert(toLower(Char('a')) == 'a'); 773 static assert(toLower(Char('A')) == 'a'); 774 static assert(toUpper(Char('a')) == 'A'); 775 static assert(toUpper(Char('A')) == 'A'); 776 } 777 778 //Various enum tests. 779 static foreach (Enum; AliasSeq!(CE, WE, DE, UDCE, UDWE, UDDE)) 780 { 781 assert(toLower(Enum.a) == 'a'); 782 assert(toLower(Enum.A) == 'a'); 783 assert(toUpper(Enum.a) == 'A'); 784 assert(toUpper(Enum.A) == 'A'); 785 static assert(toLower(Enum.a) == 'a'); 786 static assert(toLower(Enum.A) == 'a'); 787 static assert(toUpper(Enum.a) == 'A'); 788 static assert(toUpper(Enum.A) == 'A'); 789 } 790 791 //Return value type tests for enum of non-UDT. These should be the original type. 792 static foreach (T; AliasSeq!(CE, WE, DE)) 793 {{ 794 alias C = OriginalType!T; 795 static assert(is(typeof(toLower(T.init)) == C)); 796 static assert(is(typeof(toUpper(T.init)) == C)); 797 }} 798 799 //Return value tests for UDT and enum of UDT. These should be dchar 800 static foreach (T; AliasSeq!(UDC, UDW, UDD, UDCE, UDWE, UDDE)) 801 { 802 static assert(is(typeof(toLower(T.init)) == dchar)); 803 static assert(is(typeof(toUpper(T.init)) == dchar)); 804 } 805 }