![[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.