![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sorttest CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / sort|
Return to sorttest CVS log | Up to [Research Unix] / researchv10dc / cmd / sort |
1.1 ! root 1: #!/bin/sh ! 2: ! 3: # Tests for the Unix sort utility ! 4: # Test Posix features except for locale. ! 5: # Test some nonstandard features if present. ! 6: ! 7: # Other tests may be needed for files too big to fit in memory; ! 8: # see TEST=15 below ! 9: ! 10: #--------------------------------------------------------------- ! 11: echo pathname of sort under test: ! 12: which sort 2>/dev/null || whatis sort 2>/dev/null || echo can\'t tell ! 13: ! 14: #--------------------------------------------------------------- ! 15: # Initialize switches for nonstandard features. ! 16: # Use parenthesized settings for supported features. ! 17: ! 18: o=: # officially obsolescent features: +1 -2, misplaced -o (o=) ! 19: g=: # -g numeric sort including e-format numbers (g=) ! 20: M=: # -M sort by month names (M=) ! 21: s=: # -s stable, do not compare raw bytes on equal keys (s=) ! 22: y= # -y user-specified memory size (y=-y10000) ! 23: ! 24: # Detect what features are supported, assuming bad options cause ! 25: # errors. Set switches accordingly. ! 26: ! 27: echo obsolescent and nonstandard features recognized, if any: ! 28: if sort +0 </dev/null 2>/dev/null; then o= ! 29: echo ' +1 -2'; fi ! 30: if sort /dev/null -o xx 2>/dev/null; then o= ! 31: echo ' -o among files'; fi ! 32: if sort -g </dev/null 2>/dev/null; then g= ! 33: echo ' -g g-format numbers'; fi ! 34: if sort -M </dev/null 2>/dev/null; then M= ! 35: echo ' -M months'; fi ! 36: if sort -s </dev/null 2>/dev/null; then s= ! 37: echo ' -s stable'; fi ! 38: if sort -y10000 </dev/null 2>/dev/null; then y=-y10000 ! 39: echo ' -y space'; fi ! 40: if sort -z10000 </dev/null 2>/dev/null; then ! 41: echo ' -z recsize (not exercised)'; fi ! 42: if sort -T. </dev/null 2>/dev/null; then ! 43: echo ' -T tempdir (not exercised)'; fi ! 44: ! 45: #--------------------------------------------------------------- ! 46: # look for a modern awk ! 47: ! 48: if nawk 'BEGIN{print rand()}' </dev/null >/dev/null 2>&1 ! 49: then awk=nawk ! 50: elif gawk 'BEGIN{print rand()}' </dev/null >/dev/null 2>&1 ! 51: then awk=gawk ! 52: elif awk 'BEGIN{print rand()}' </dev/null >/dev/null 2>&1 ! 53: then awk=awk ! 54: else echo "missing or old awk, inadequate for some tests; may dump core" ! 55: awk=awk ! 56: fi ! 57: ! 58: awkf="echo awk failed in test" ! 59: export awk awkf ! 60: ! 61: #--------------------------------------------------------------- ! 62: export TEST # major sequence number of test ! 63: ! 64: trap "rm -f in in1 in2 out xx -k - -o unwritablefile xsort ysort linecount checksum ! 65: exit" 0 1 2 13 15 ! 66: ! 67: ! 68: #--------------------------------------------------------------- ! 69: # shell program: xsort testno options ! 70: # Sort file "in" with specified options. ! 71: # Compare with file "out" if that is supplied, ! 72: # otherwise make plausibility checks on output ! 73: ! 74: cat <<'!' >xsort; chmod +x xsort ! 75: ! 76: X=$1; shift ! 77: ! 78: if sort "$@" in >xx && sort -c "$@" xx 2>/dev/null ! 79: then ! 80: if test -f out ! 81: then ! 82: cmp xx out >/dev/null && exit 0 ! 83: echo $TEST$X comparison failed ! 84: else ! 85: test "`checksum <in`" = "`checksum <xx`" && exit 0 ! 86: echo $TEST$X checksum failed ! 87: fi ! 88: else ! 89: echo $TEST$X failed ! 90: fi ! 91: exit 1 ! 92: ! ! 93: ! 94: #--------------------------------------------------------------- ! 95: # shell program: linecount testno file count ! 96: # declares the given "testno" to be in error if number of ! 97: # lines in "file" differs from "count" ! 98: ! 99: cat <<'!' >linecount ! 100: $awk 'END{ if(NR!='$3') print "'$TEST$1' failed" ! 101: }' $2 2>/dev/null || $awkf $TEST$1 ! 102: ! ! 103: chmod +x linecount ! 104: ! 105: #--------------------------------------------------------------- ! 106: # c program: checksum insensitive to reordering input ! 107: ! 108: cat <<! >checksum.c ! 109: #include <stdio.h> ! 110: ! 111: enum { /* primes just short of 32-bit overflows */ ! 112: C1 = 2130706703, ! 113: C2 = 16776937 ! 114: }; ! 115: ! 116: main() ! 117: { ! 118: int c; ! 119: long n; ! 120: long sum = 0; ! 121: long linesum = 0; ! 122: for(n=0; (c=getchar())!=EOF; n++) ! 123: if(c == '\n') { ! 124: sum = (sum + linesum) % C1; ! 125: linesum = 0; ! 126: } else ! 127: linesum = ((linesum<<7) + c) % C2; ! 128: printf("%ld %ld\n", sum, n); ! 129: } ! 130: ! ! 131: cc checksum.c -o checksum ! 132: ! 133: ! 134: rm -f out ! 135: ! 136: #--------------------------------------------------------------- ! 137: TEST=01; echo $TEST # -c status, checksum ! 138: # obsolescent features go together ! 139: cat <<! >in ! 140: b ! 141: a ! 142: ! ! 143: rm -f out -o ! 144: ! 145: sort -c in 2>/dev/null && echo ${TEST}A failed ! 146: ! 147: xsort B || echo checksum program may not work ! 148: ! 149: $o sort +0 in -o in || echo ${TEST}c failed ! 150: ! 151: #--------------------------------------------------------------- ! 152: TEST=02; echo $TEST # output from -c ! 153: cat <<! >in ! 154: x ! 155: y ! 156: ! ! 157: ! 158: sort -cr in >out 2>xx && echo ${TEST}A failed ! 159: test -s out && echo ${TEST}B failed ! 160: test -s xx && echo option -c is noisy "(probably legal)" ! 161: test -s xx || echo option -c is quiet "(legal, not classical)" ! 162: ! 163: sort -c /dev/null 2>xx || echo ${TEST}C failed ! 164: test -s xx && echo ${TEST}D failed ! 165: ! 166: #--------------------------------------------------------------- ! 167: TEST=03; echo $TEST # -n ! 168: cat <<! >in ! 169: -99.0 ! 170: -99.1 ! 171: -.0002 ! 172: -10 ! 173: 2 ! 174: 2.0x ! 175: 2.0.1 ! 176: 0010.000000000000000000000000000000000001 ! 177: 10 ! 178: 3x ! 179: x ! 180: ! ! 181: cat <<! >out ! 182: -99.1 ! 183: -99.0 ! 184: -10 ! 185: -.0002 ! 186: x ! 187: 2 ! 188: 2.0.1 ! 189: 2.0x ! 190: 3x ! 191: 10 ! 192: 0010.000000000000000000000000000000000001 ! 193: ! ! 194: ! 195: xsort "" -n ! 196: ! 197: #--------------------------------------------------------------- ! 198: TEST=04; echo $TEST # -b without fields, piping, -c status return ! 199: cat <<! >in ! 200: b ! 201: a ! 202: ! ! 203: cp in out ! 204: ! 205: xsort A -b ! 206: ! 207: cat in | sort | cat >xx ! 208: cmp xx out >/dev/null || echo ${TEST}B failed ! 209: ! 210: sort in | sort -cr 2>/dev/null && echo ${TEST}C failed ! 211: ! 212: #--------------------------------------------------------------- ! 213: TEST=05; echo $TEST # fields, reverse fields, -c status return ! 214: cat <<! >in ! 215: b b p ! 216: a b q ! 217: x a ! 218: ! ! 219: cat <<! >out ! 220: x a ! 221: a b q ! 222: b b p ! 223: ! ! 224: ! 225: $o xsort A +1 -2 ! 226: ! 227: $o xsort B +1 -2 +2r ! 228: ! 229: xsort C -k 2,2 ! 230: ! 231: xsort D -k 2,2 -k 3r ! 232: ! 233: xsort E -k 2,2.0 ! 234: ! 235: xsort F -k 2,2 -k 1,1 -k 3 ! 236: ! 237: sort -c -k 2 in 2>/dev/null && ${TEST}G failed ! 238: ! 239: #--------------------------------------------------------------- ! 240: TEST=06; echo $TEST # -t ! 241: cat <<! >in ! 242: a: ! 243: a! ! 244: ! ! 245: cp in out ! 246: ! 247: $o xsort A -t : -r +0 ! 248: ! 249: $o xsort B -t : +0 -1 ! 250: ! 251: xsort C -t : -r -k 1 ! 252: ! 253: xsort D -t : -k 1,1 ! 254: ! 255: #--------------------------------------------------------------- ! 256: TEST=07; echo $TEST # -t, character positions in fields ! 257: # -t: as 1 arg is not strictly conforming, but classical ! 258: cat <<! >in ! 259: : ab ! 260: :bac ! 261: ! ! 262: cat <<! >out ! 263: :bac ! 264: : ab ! 265: ! ! 266: ! 267: $o xsort A -b -t: +1.1 ! 268: ! 269: $o xsort B -t: +1.1r ! 270: ! 271: xsort C -b -t: -k 2.2 ! 272: ! 273: xsort D -t: -k 2.2r ! 274: ! 275: #--------------------------------------------------------------- ! 276: TEST=08; echo $TEST # space and tab as -t characters ! 277: cat <<! >in ! 278: b c ! 279: b c ! 280: b c ! 281: ! ! 282: cp in out ! 283: ! 284: xsort A -t ' ' -k2,2 ! 285: ! 286: xsort B -t ' ' -k2.1,2.0 ! 287: ! 288: cat <<! >out ! 289: b c ! 290: b c ! 291: b c ! 292: ! ! 293: ! 294: xsort C -t ' ' -k2,2 ! 295: ! 296: xsort D -t ' ' -k2.1,2.0 ! 297: ! 298: cat <<! >out ! 299: b c ! 300: b c ! 301: b c ! 302: ! ! 303: ! 304: xsort E -k2 ! 305: ! 306: cat <<! >out ! 307: b c ! 308: b c ! 309: b c ! 310: ! ! 311: ! 312: xsort F -k2b ! 313: ! 314: #--------------------------------------------------------------- ! 315: TEST=09; echo $TEST # alphabetic as -t character ! 316: cat <<! >in ! 317: zXa ! 318: yXa ! 319: zXb ! 320: ! ! 321: cp in out ! 322: ! 323: xsort "" -tX -k2 -k1r,1 ! 324: ! 325: #--------------------------------------------------------------- ! 326: TEST=10; echo $TEST # -m ! 327: cat <<! >in ! 328: a ! 329: ab ! 330: ab ! 331: bc ! 332: ca ! 333: ! ! 334: cat <<! >in1 ! 335: Z ! 336: a ! 337: aa ! 338: ac ! 339: c ! 340: ! ! 341: cat <<! >out ! 342: Z ! 343: a ! 344: a ! 345: aa ! 346: ab ! 347: ab ! 348: ac ! 349: bc ! 350: c ! 351: ca ! 352: ! ! 353: ! 354: sort -m in in1 >xx ! 355: cmp xx out >/dev/null || echo ${TEST}A failed ! 356: ! 357: #--------------------------------------------------------------- ! 358: TEST=11; echo $TEST # multiple files, -o overwites input, -m, -mu ! 359: cat <<! >in ! 360: a ! 361: b ! 362: c ! 363: d ! 364: ! ! 365: ! 366: sort -o xx in in in in in in in in in in in in in in in in in ! 367: linecount A xx 68 ! 368: sort -o in -mu in in in in in in in in in in in in in in in in in ! 369: linecount B in 4 ! 370: sort -o in -m in in in in in in in in in in in in in in in in in ! 371: ! 372: cmp in xx >/dev/null || echo ${TEST}C failed ! 373: ! 374: #--------------------------------------------------------------- ! 375: TEST=12; echo $TEST # does -mu pick the first among equals? ! 376: cat <<! >in ! 377: 3B ! 378: 3b ! 379: 3B2 ! 380: ~3B2 ! 381: 4.1 ! 382: 41 ! 383: 5 ! 384: 5. ! 385: ! ! 386: cat <<! >out ! 387: 3B ! 388: 3B2 ! 389: 4.1 ! 390: 5 ! 391: ! ! 392: ! 393: xsort A -mudf || echo "(other behavior is legal, not classical)" ! 394: ! 395: xsort B -mudf -k1 || echo "(other behavior is legal, not classical)" ! 396: ! 397: #--------------------------------------------------------------- ! 398: TEST=13; echo $TEST # long records (>8000 bytes, keys >16000), -r ! 399: $awk ' ! 400: BEGIN { x="x" ! 401: for(i=1; i<=12; i++) x = x x ! 402: for(i=15; i<=25; i++) print x i ! 403: }' >in </dev/null 2>/dev/null || $awkf $TEST ! 404: $awk ' ! 405: BEGIN { x="x" ! 406: for(i=1; i<=12; i++) x = x x ! 407: for(i=25; i>=15; i--) print x i ! 408: }' >out </dev/null 2>/dev/null || $awkf $TEST ! 409: ! 410: xsort A -r ! 411: ! 412: xsort B -k 1,1r -k 1 ! 413: ! 414: #--------------------------------------------------------------- ! 415: TEST=14; echo $TEST "(3 long parts)" ! 416: $awk 'BEGIN { for(i=0; i<100000; i++) { ! 417: x = rand(); if(x !~ /e/) print x } ! 418: }' </dev/null >in 2>/dev/null || $awkf $TEST ! 419: rm -f out ! 420: ! 421: xsort A; echo $TEST "(part A done)" ! 422: ! 423: xsort B -n; echo $TEST "(part B done)" ! 424: ! 425: # next test is unclean: xx is a hidden side-effect of xsort ! 426: ! 427: $awk ' ! 428: $0 < x { print "test '${TEST}C' failed"; exit } ! 429: $0 "" != x { print >"out"; x = $0 } ! 430: ' xx 2>/dev/null || $awkf ${TEST}C ! 431: ! 432: xsort C -n -u ! 433: ! 434: #--------------------------------------------------------------- ! 435: TEST=15; echo $TEST "(long)" # force intermediate files if possible ! 436: # with option -y 10000 ($y) this makes 50 intermediat ! 437: # files of 80-byte records. ! 438: case "$y" in ! 439: "") echo "sorttest warning: inadequate test of large files; revise parameters" ! 440: esac ! 441: ! 442: $awk 'BEGIN { ! 443: x = "xxxxxxxxxx" ! 444: x = x x x x x x x x ! 445: for(i=0; i<4000; i++) print rand(), x ! 446: }' >in </dev/null 2>/dev/null || $awkf $TEST ! 447: rm -f out ! 448: ! 449: xsort A -r $y ! 450: ! 451: rm -f in1 ! 452: sort -r in -o in1 ! 453: $awk '$0 "x" != x { print ; x = $0 "x" ! 454: }' in1 >out 2>/dev/null || $awkf ${TEST}B ! 455: ! 456: xsort B -u -r $y ! 457: ! 458: sort -r -u -m in1 -o in1 ! 459: cmp in1 out >/dev/null || echo ${TEST}C failed ! 460: rm in in1 out ! 461: ! 462: #--------------------------------------------------------------- ! 463: TEST=16; echo $TEST # -nr, -nm, file name - ! 464: $awk 'BEGIN { for(i=-100; i<=100; i+=2) printf "%.10d\n", i ! 465: }' >in </dev/null 2>/dev/null || $awkf $TEST ! 466: ! 467: ($awk 'BEGIN { for(i=-99; i<=100; i+=2) print i ! 468: }' </dev/null 2>/dev/null || $awkf ${TEST}A) | sort -nr in - >xx ! 469: $awk '$0+0 != 101-NR { print "'${TEST}A' failed"; exit ! 470: }' xx 2>/dev/null || $awkf ${TEST}A ! 471: ! 472: ($awk 'BEGIN { for(i=-99; i<=100; i+=2) print i ! 473: }' </dev/null 2>/dev/null || $awkf ${TEST}B) | sort -mn - in >xx ! 474: $awk '$0+0 != -101+NR { print "'${TEST}B' failed"; exit ! 475: }' xx 2>/dev/null || $awkf ${TEST}B ! 476: ! 477: #--------------------------------------------------------------- ! 478: TEST=17; echo $TEST # -d, fields without end, modifier override ! 479: cat <<! >in ! 480: a-B ! 481: a+b ! 482: a b ! 483: A+b ! 484: a b ! 485: ! ! 486: cat <<! >out ! 487: a b ! 488: a b ! 489: A+b ! 490: a-B ! 491: a+b ! 492: ! ! 493: ! 494: $o xsort A -df +0 +0d ! 495: ! 496: xsort B -df -k 1 -k 1d ! 497: ! 498: #--------------------------------------------------------------- ! 499: TEST=18; echo $TEST # -u on key only ! 500: cat <<! >in ! 501: 12 y ! 502: 13 z ! 503: 12 x ! 504: ! ! 505: cat <<! >out ! 506: 12 x ! 507: 12 y ! 508: 13 z ! 509: ! ! 510: ! 511: $o xsort A +0 -1 ! 512: ! 513: xsort B -k 1,1 ! 514: ! 515: sort -u -k 1,1 in >xx ! 516: linecount C xx 2 ! 517: ! 518: #--------------------------------------------------------------- ! 519: TEST=19; echo $TEST # -i, -d, -f ! 520: cat <<! >xx.c ! 521: run(i,j){ for( ; i<=j; i++) printf("%.3o %c\n",i,i); } ! 522: main(){ run(0, 011); /* 012=='\n' */ ! 523: run(013, 0377); } ! 524: ! ! 525: cc xx.c ! 526: a.out >in ! 527: cat <<! >xx.c ! 528: run(i,j){ for( ; i<=j; i++) printf("%.3o %c\n",i,i); } ! 529: main(){ run(0, 011); ! 530: run(013, ' '-1); ! 531: run(0177, 0377); ! 532: run(' ', 0176); } ! 533: ! ! 534: cc xx.c ! 535: a.out >out ! 536: ! 537: xsort A -i -k 2 ! 538: ! 539: cat <<! >xx.c ! 540: run(i,j){ for( ; i<=j; i++) printf("%.3o %c\n",i,i); } ! 541: main(){ run(0, 010); /* 011=='\t', 012=='\n' */ ! 542: run(013, ' '-1); ! 543: run(' '+1, '0'-1); ! 544: run('9'+1, 'A'-1); ! 545: run('Z'+1, 'a'-1); ! 546: run('z'+1, 0377); ! 547: run('\t', '\t'); ! 548: run(' ', ' '); ! 549: run('0', '9'); ! 550: run('A', 'Z'); ! 551: run('a', 'z'); } ! 552: ! ! 553: cc xx.c ! 554: a.out >out ! 555: ! 556: xsort B -d -k 2 ! 557: ! 558: cat <<! >xx.c ! 559: run(i,j){ for( ; i<=j; i++) printf("%.3o %c\n",i,i); } ! 560: main(){ int i; ! 561: run(0, 011); ! 562: run(013, 'A'-1); ! 563: for(i='A'; i<='Z'; i++) ! 564: printf("%.3o %c\n%.3o %c\n",i,i,i+040,i+040); ! 565: run('Z'+1, 'a'-1); ! 566: run('z'+1, 0377); } ! 567: ! ! 568: cc xx.c ! 569: a.out >out ! 570: rm xx.c ! 571: ! 572: xsort C -f -k 2 ! 573: ! 574: #--------------------------------------------------------------- ! 575: TEST=20; echo $TEST # -d, -f, -b applies only to fields ! 576: cat <<! >in ! 577: b ! 578: 'C ! 579: a ! 580: ! ! 581: cp in out ! 582: ! 583: xsort A -d ! 584: ! 585: xsort B -f ! 586: ! 587: cat <<! >out ! 588: b ! 589: a ! 590: 'C ! 591: ! ! 592: ! 593: xsort C -dfb ! 594: ! 595: #--------------------------------------------------------------- ! 596: TEST=21; echo $TEST # behavior of null bytes ! 597: cat <<'!' >xx.c ! 598: main() { printf("\n%cb\n%ca\n",0,0); } ! 599: ! ! 600: cc xx.c ! 601: a.out >in ! 602: sort -u in >xx ! 603: cmp in xx >/dev/null && echo ${TEST}A failed ! 604: test "`wc -c <in`" = "`wc -c <xx`" || echo ${TEST}B failed ! 605: rm xx.c a.out ! 606: ! 607: #--------------------------------------------------------------- ! 608: TEST=22; echo $TEST # field limits ! 609: cat <<! >in ! 610: a 2 ! 611: a 1 ! 612: b 2 ! 613: b 1 ! 614: ! ! 615: cat <<! >out ! 616: b 1 ! 617: b 2 ! 618: a 1 ! 619: a 2 ! 620: ! ! 621: ! 622: xsort "" -r -k1,1 -k2n ! 623: ! 624: #--------------------------------------------------------------- ! 625: TEST=23; echo $TEST # empty file, compact -o ! 626: ! 627: echo hi >xx ! 628: ! 629: sort -oxx </dev/null ! 630: cmp xx /dev/null >/dev/null || echo ${TEST}A failed ! 631: ! 632: sort -c </dev/null || echo ${TEST}B failed ! 633: ! 634: sort -cu </dev/null || echo ${TEST}C failed ! 635: ! 636: #--------------------------------------------------------------- ! 637: TEST=24; echo $TEST # many fields ! 638: cat <<! >in ! 639: 0:2:3:4:5:6:7:8:9 ! 640: 1:1:3:4:5:6:7:8:9 ! 641: 1:2:2:4:5:6:7:8:9 ! 642: 1:2:3:3:5:6:7:8:9 ! 643: 1:2:3:4:4:6:7:8:9 ! 644: 1:2:3:4:5:5:7:8:9 ! 645: 1:2:3:4:5:6:6:8:9 ! 646: 1:2:3:4:5:6:7:7:9 ! 647: 1:2:3:4:5:6:7:8:8 ! 648: ! ! 649: cat <<! >out ! 650: 1:2:3:4:5:6:7:8:8 ! 651: 1:2:3:4:5:6:7:7:9 ! 652: 1:2:3:4:5:6:6:8:9 ! 653: 1:2:3:4:5:5:7:8:9 ! 654: 1:2:3:4:4:6:7:8:9 ! 655: 1:2:3:3:5:6:7:8:9 ! 656: 1:2:2:4:5:6:7:8:9 ! 657: 1:1:3:4:5:6:7:8:9 ! 658: 0:2:3:4:5:6:7:8:9 ! 659: ! ! 660: ! 661: xsort "" -t: -k9 -k8 -k7 -k6 -k5 -k4 -k3 -k2 -k1 ! 662: ! 663: #--------------------------------------------------------------- ! 664: TEST=25; echo $TEST # variously specified alpha fields ! 665: # numbers give the correct orderings ! 666: cat <<! >in ! 667: 01:04:19:01:16:01:21:01 a ! 668: 02:03:13:15:13:19:15:02 a ! 669: 03:02:07:09:07:13:09:03 a ! 670: 04:01:01:03:01:07:03:04 a ! 671: 05:08:20:16:17:02:20:05 aa ! 672: 06:07:14:18:14:20:14:06 aa ! 673: 07:06:08:10:08:14:08:07 aa ! 674: 08:05:02:04:02:08:02:08 aa ! 675: 09:16:22:02:22:04:24:13 b ! 676: 10:15:16:20:19:22:18:14 b ! 677: 11:14:10:12:10:16:12:15 b ! 678: 12:13:04:06:04:10:06:16 b ! 679: 13:24:24:22:24:06:22:21 bb ! 680: 14:23:18:24:21:24:16:22 bb ! 681: 15:22:12:14:12:18:10:23 bb ! 682: 16:21:06:08:06:12:04:24 bb ! 683: 17:12:21:21:18:03:19:09 ab ! 684: 18:11:15:19:15:21:13:10 ab ! 685: 19:10:09:11:09:15:07:11 ab ! 686: 20:09:03:05:03:09:01:12 ab ! 687: 21:20:23:17:23:05:23:17 ba ! 688: 22:19:17:23:20:23:17:18 ba ! 689: 23:18:11:13:11:17:11:19 ba ! 690: 24:17:05:07:05:11:05:20 ba ! 691: ! ! 692: sort -k2b -k2 in >xx ! 693: sort -c -t: -k2n xx 2>/dev/null || echo ${TEST}A failed ! 694: sort -k2,2.1b -k2 in >xx ! 695: sort -c -t: -k3n xx 2>/dev/null || echo ${TEST}B failed ! 696: sort -k2.3 -k2 in >xx ! 697: sort -c -t: -k4n xx 2>/dev/null || echo ${TEST}C failed ! 698: sort -k2b,2.3 -k2 in >xx ! 699: sort -c -t: -k5n xx 2>/dev/null || echo ${TEST}D failed ! 700: sort -k2.3,2.1b -k2 in >xx ! 701: sort -c -t: -k6n xx 2>/dev/null || echo ${TEST}E failed ! 702: sort -k2,2.1b -k2r in >xx ! 703: sort -c -t: -k7n xx 2>/dev/null || echo ${TEST}F failed ! 704: sort -b -k2,2 -k2 in >xx ! 705: sort -c -t: -k8n xx 2>/dev/null || echo ${TEST}G failed ! 706: sort -b -k2,2b -k2 in >xx # perhaps same as G ! 707: sort -c -t: -k3n xx 2>/dev/null || echo ${TEST}H failed\ ! 708: "(standard is not clear on this)" ! 709: ! 710: #--------------------------------------------------------------- ! 711: TEST=26; echo $TEST # empty fields, out of bounds fields ! 712: cat <<! >in ! 713: 0 5 ! 714: 1 4 ! 715: 2 3 ! 716: 3 2 ! 717: 4 1 ! 718: 5 0 ! 719: ! ! 720: cp in out ! 721: ! 722: xsort "" -k2.2,2.1 -k2.3,2.4 ! 723: ! 724: #--------------------------------------------------------------- ! 725: TEST=27; echo $TEST # displaced -o ! 726: rm -f out ! 727: ! 728: $o sort /dev/null -o out || $o echo ${TEST}B failed ! 729: $o test -f out || $o echo ${TEST}C failed ! 730: ! 731: #--------------------------------------------------------------- ! 732: TEST=28; echo $TEST # apparently nonmonotone field specs ! 733: cat <<! >in ! 734: aaaa c ! 735: x a ! 736: 0 b ! 737: ! ! 738: cp in out ! 739: ! 740: $o xsort A +1 -0.3 +1.4 -1.5 ! 741: ! 742: xsort B -k2,1.3 -k2.5,2.5 ! 743: ! 744: #--------------------------------------------------------------- ! 745: TEST=29; echo $TEST # determination of end of option list ! 746: cat >-k <<! ! 747: x ! 748: ! ! 749: rm -f out -c ! 750: ! 751: sort -- -k </dev/null >xx || echo ${TEST}A argument failed ! 752: cmp xx -k || echo ${TEST}A comparison failed ! 753: ! 754: cat >in <<! ! 755: xxx ! 756: ! ! 757: >- ! 758: >-o ! 759: >in1 ! 760: ! 761: sort -- - -o in1 <in >out ! 762: cmp in out >/dev/null || echo ${TEST}C failed ! 763: test -s in1 && echo ${TEST}D failed ! 764: ! 765: #--------------------------------------------------------------- ! 766: TEST=30; echo $TEST # missing newline ! 767: $awk 'BEGIN{ printf "%s", "x"}' >in 2>/dev/null || $awkf $TEST ! 768: echo x >out ! 769: ! 770: xsort "" 2>/dev/null ! 771: ! 772: #--------------------------------------------------------------- ! 773: TEST=31; echo $TEST # -M, multiple fields ! 774: cat <<! >in ! 775: jan 10 1900 ! 776: Feb 26 1900 ! 777: feb 25 1900 ! 778: January xx 1900 ! 779: August 11 1900 ! 780: jan 15 1990 ! 781: feb 22 1990 ! 782: mar 15 1990 ! 783: apr 1 1990 ! 784: may 45 1990 ! 785: jun 14 1990 ! 786: jul 4 1990 ! 787: aug 1~ 1990 ! 788: aug 11 1990 ! 789: sep 1 1990 ! 790: oct 12 1990 ! 791: nov 24 1990 ! 792: dec 25 1990 ! 793: never 3 1990 ! 794: Dec 25 1990 ! 795: ! ! 796: cat <<! >out ! 797: January xx 1900 ! 798: jan 10 1900 ! 799: feb 25 1900 ! 800: Feb 26 1900 ! 801: August 11 1900 ! 802: never 3 1990 ! 803: jan 15 1990 ! 804: feb 22 1990 ! 805: mar 15 1990 ! 806: apr 1 1990 ! 807: may 45 1990 ! 808: jun 14 1990 ! 809: jul 4 1990 ! 810: aug 1~ 1990 ! 811: aug 11 1990 ! 812: sep 1 1990 ! 813: oct 12 1990 ! 814: nov 24 1990 ! 815: Dec 25 1990 ! 816: dec 25 1990 ! 817: ! ! 818: ! 819: $M xsort "" -k3n -k1M -k2n ! 820: ! 821: #--------------------------------------------------------------- ! 822: TEST=32; echo $TEST # -M case insensitivity, -r ! 823: cat <<! >in ! 824: x ! 825: june ! 826: january ! 827: december ! 828: ! ! 829: cat <<! >out ! 830: december ! 831: june ! 832: january ! 833: x ! 834: ! ! 835: ! 836: $M xsort "" -Mr ! 837: ! 838: #--------------------------------------------------------------- ! 839: TEST=33; echo $TEST # -g, big enough for IEEE floating point ! 840: cat <<! >in ! 841: 2 ! 842: 1 ! 843: 10 ! 844: 1e-1 ! 845: .2 ! 846: 1e ! 847: 1E1 ! 848: 1e. ! 849: 3e+308 ! 850: 3e307 ! 851: 1e-308 ! 852: 1e-307 ! 853: ! ! 854: cat <<! >out ! 855: 1e-308 ! 856: 1e-307 ! 857: 1e-1 ! 858: .2 ! 859: 1 ! 860: 1e ! 861: 1e. ! 862: 2 ! 863: 10 ! 864: 1E1 ! 865: 3e307 ! 866: 3e+308 ! 867: ! ! 868: ! 869: $g xsort "" -g ! 870: ! 871: #--------------------------------------------------------------- ! 872: TEST=34; echo $TEST # -g wide operands ! 873: cat <<! >in ! 874: .99999999999999999999 ! 875: 099999999999999999999e-21 ! 876: 099999999999999999999e-19 ! 877: .1e1 ! 878: ! ! 879: cat <<! >out ! 880: 099999999999999999999e-21 ! 881: .99999999999999999999 ! 882: .1e1 ! 883: 099999999999999999999e-19 ! 884: ! ! 885: ! 886: $g xsort A -g ! 887: ! 888: cat <<! >out ! 889: .1e1 ! 890: .99999999999999999999 ! 891: 099999999999999999999e-19 ! 892: 099999999999999999999e-21 ! 893: ! ! 894: ! 895: xsort B -n ! 896: ! 897: #--------------------------------------------------------------- ! 898: TEST=35; echo $TEST #-g, -u with different fp reps ! 899: cat <<! >in ! 900: +0 ! 901: -0 ! 902: 0 ! 903: 0.10 ! 904: +.1 ! 905: -.1 ! 906: -100e-3x ! 907: x ! 908: ! ! 909: cat <<! >out ! 910: -.1 ! 911: -100e-3x ! 912: +0 ! 913: -0 ! 914: 0 ! 915: x ! 916: +.1 ! 917: 0.10 ! 918: ! ! 919: ! 920: $g xsort A -g ! 921: ! 922: $g sort -gu in >xx && $g sort -c -gu xx || echo ${TEST}B failed ! 923: $g linecount C xx 3 ! 924: ! 925: #--------------------------------------------------------------- ! 926: TEST=36; echo $TEST # -s ! 927: cat <<! >in ! 928: a 2 ! 929: b 1 ! 930: c 2 ! 931: a 1 ! 932: b 2 ! 933: c 1 ! 934: ! ! 935: cat <<! >out ! 936: a 2 ! 937: a 1 ! 938: b 1 ! 939: b 2 ! 940: c 2 ! 941: c 1 ! 942: ! ! 943: ! 944: $s xsort "" -s -k1,1 ! 945: ! 946: #--------------------------------------------------------------- ! 947: TEST=37; echo $TEST # -s, multiple files ! 948: cat <<! >in ! 949: a 2 ! 950: c 2 ! 951: ! ! 952: cat <<! >in1 ! 953: a 1 ! 954: b 1 ! 955: c 1 ! 956: ! ! 957: cat <<! >out ! 958: c 2 ! 959: b 1 ! 960: a 2 ! 961: ! ! 962: ! 963: $s sort -smru -k1,1 in in in1 in1 >xx ! 964: $s cmp xx out >/dev/null || echo $TEST failed ! 965: ! 966: #--------------------------------------------------------------- ! 967: TEST=38; echo $TEST # -s ! 968: $s $awk ' ! 969: BEGIN { ! 970: for(i=1; i<50; i++) ! 971: for(j=1; j<=i; j++) { ! 972: print i, 2 >"in" ! 973: print i, 1 >"in1" ! 974: } ! 975: }' </dev/null 2>/dev/null || $awkf $TEST ! 976: ! 977: $s sort -m -s -k1,1n in in1 >out ! 978: ! 979: $s $awk ' ! 980: func stop() { print "'$TEST' failed"; exit } ! 981: $1!=last1 { if(count!=last1 || $2!=2) stop(); ! 982: count = 0} ! 983: $1==last1 && $2!=last2 { if(count!=last1 || $2!=1) stop(); ! 984: count = 0 } ! 985: { count++; last1 = $1; last2 = $2 } ! 986: ' out 2>/dev/null || $awkf $TEST ! 987: ! 988: #--------------------------------------------------------------- ! 989: TEST=39; echo $TEST # empty fields ! 990: cat <<! >in ! 991: bXXa ! 992: aXXb ! 993: ! ! 994: cp in out ! 995: ! 996: xsort A -k3 -tX ! 997: xsort B -k2 -tX ! 998: xsort C -r -k2,2 -tX ! 999: xsort D -r -k4 -tX ! 1000: ! 1001: #--------------------------------------------------------------- ! 1002: TEST=40; echo $TEST # deceptive field boundaries ! 1003: cat <<! >in ! 1004: 1.2 ! 1005: 1.10 ! 1006: ! ! 1007: cp in out ! 1008: ! 1009: xsort A -t. -k1,1n -k2,2n ! 1010: xsort B -t. -k1nr -k2n ! 1011: ! 1012: cat <<! >in ! 1013: feb ! 1014: jan ! 1015: jan ! 1016: feb ! 1017: ! ! 1018: cp in out ! 1019: ! 1020: $M xsort C -k1.1,1.4M ! 1021: ! 1022: #--------------------------------------------------------------- ! 1023: TEST=41; echo $TEST # diagnostics ! 1024: ! 1025: echo hi >in ! 1026: ! 1027: cat <<\! >ysort ! 1028: error=0 warning=0 works=0 ! 1029: sort "$@" 2>out <in >in1 || error=1 ! 1030: test -s out && warning=1 ! 1031: test -s in1 && works=1 ! 1032: case $error$warning$works in ! 1033: 000) echo sort "$@" does not indicate trouble, but does not sort ;; ! 1034: 001) echo sort "$@" does not indicate trouble ;; ! 1035: 010) echo sort "$@" warns, does not sort, and yields exit status zero ;; ! 1036: 011) echo sort "$@" warns and continues ;; ! 1037: 100) echo sort "$@" yields nonzero exit status and does not sort ;; ! 1038: 101) echo sort "$@" yields nonzero exit status, but sorts ;; ! 1039: 111) echo sort "$@" warns and yields nonzero exit status, but sorts ! 1040: esac ! 1041: ! ! 1042: chmod +x ysort ! 1043: echo "behavior (other than message and error exit)" ! 1044: echo " in some questionable cases:" ! 1045: ! 1046: rm -f nosuchfile ! 1047: ysort nosuchfile ! 1048: ! 1049: echo x >unwritablefile ! 1050: chmod 0 unwritablefile ! 1051: ysort -o unwritablefile </dev/null ! 1052: ! 1053: cat in | ysort - - ! 1054: ! 1055: for i in -k -k0 -k-1 -k1, -kb -k1,2u -t -o ! 1056: do ysort $i ! 1057: done ! 1058: ! 1059: $g ysort -n -g ! 1060: $M ysort -n -M ! 1061: ysort -d -i ! 1062: ysort -n -i ! 1063: ysort -c in in ! 1064: ysort -t. -t: ! 1065: ! 1066: for i in -a -e -h -j -p -q -v -w -x -0 -1 -2 ! 1067: do ysort $i ! 1068: done ! 1069: ! 1070: $g false && ysort -g ! 1071: $s false && ysort -s ! 1072: $z false && ysort -z ! 1073: ! 1074: case "$y" in ! 1075: "") ysort -y ! 1076: esac ! 1077: ! 1078: ysort -k1,1 -f ! 1079: ! 1080: cat <<! >in ! 1081: A b ! 1082: a bc ! 1083: a Bd ! 1084: B ! 1085: ! ! 1086: cat <<! >in1 ! 1087: A b ! 1088: B ! 1089: a bc ! 1090: a Bd ! 1091: ! ! 1092: cat <<! >in2 ! 1093: A b ! 1094: B ! 1095: a Bd ! 1096: a bc ! 1097: ! ! 1098: ! 1099: if sort -k1,1 -f -k2,2 <in >out 2>/dev/null ! 1100: then ! 1101: echo sort -k1,1 -f -k2,2 : ! 1102: if cmp out in >/dev/null ! 1103: then echo " -f applies to fields 1 and 2" ! 1104: elif cmp out in1 >/dev/null ! 1105: then echo " -f applies to field 2 only" ! 1106: elif cmp out in1 >/dev/null ! 1107: then echo " -f ineffectual" ! 1108: elif cmp out /dev/null >/dev/null ! 1109: then echo " exit status zero, but no output" ! 1110: else echo " inexplicable" ! 1111: fi ! 1112: fi
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.