bin/ls/tests/ls_tests.sh

   1 #
   2 # Copyright 2015 EMC Corp.
   3 # All rights reserved.
   4 #
   5 # Redistribution and use in source and binary forms, with or without
   6 # modification, are permitted provided that the following conditions are
   7 # met:
   8 #
   9 # * Redistributions of source code must retain the above copyright
  10 #   notice, this list of conditions and the following disclaimer.
  11 # * Redistributions in binary form must reproduce the above copyright
  12 #   notice, this list of conditions and the following disclaimer in the
  13 #   documentation and/or other materials provided with the distribution.
  14 #
  15 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  18 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  19 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  21 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 #
  27 # $FreeBSD$
  28 #
  29
  30 create_test_dir()
  31 {
  32         [ -z "$ATF_TMPDIR" ] || return 0
  33
  34         export ATF_TMPDIR=$(pwd)
  35
  36         # XXX: need to nest this because of how kyua creates $TMPDIR; otherwise
  37         # it will run into EPERM issues later
  38         TEST_INPUTS_DIR="${ATF_TMPDIR}/test/inputs"
  39
  40         atf_check -e empty -s exit:0 mkdir -m 0777 -p $TEST_INPUTS_DIR
  41         cd $TEST_INPUTS_DIR
  42 }
  43
  44 create_test_inputs()
  45 {
  46         create_test_dir
  47
  48         atf_check -e empty -s exit:0 mkdir -m 0755 -p a/b/1
  49         atf_check -e empty -s exit:0 ln -s a/b c
  50         atf_check -e empty -s exit:0 touch d
  51         atf_check -e empty -s exit:0 ln d e
  52         atf_check -e empty -s exit:0 touch .f
  53         atf_check -e empty -s exit:0 mkdir .g
  54         atf_check -e empty -s exit:0 mkfifo h
  55         atf_check -e ignore -s exit:0 dd if=/dev/zero of=i count=1000 bs=1
  56         atf_check -e empty -s exit:0 touch klmn
  57         atf_check -e empty -s exit:0 touch opqr
  58         atf_check -e empty -s exit:0 touch stuv
  59         atf_check -e empty -s exit:0 install -m 0755 /dev/null wxyz
  60         atf_check -e empty -s exit:0 touch 0b00000001
  61         atf_check -e empty -s exit:0 touch 0b00000010
  62         atf_check -e empty -s exit:0 touch 0b00000011
  63         atf_check -e empty -s exit:0 touch 0b00000100
  64         atf_check -e empty -s exit:0 touch 0b00000101
  65         atf_check -e empty -s exit:0 touch 0b00000110
  66         atf_check -e empty -s exit:0 touch 0b00000111
  67         atf_check -e empty -s exit:0 touch 0b00001000
  68         atf_check -e empty -s exit:0 touch 0b00001001
  69         atf_check -e empty -s exit:0 touch 0b00001010
  70         atf_check -e empty -s exit:0 touch 0b00001011
  71         atf_check -e empty -s exit:0 touch 0b00001100
  72         atf_check -e empty -s exit:0 touch 0b00001101
  73         atf_check -e empty -s exit:0 touch 0b00001110
  74         atf_check -e empty -s exit:0 touch 0b00001111
  75 }
  76
  77 KB=1024
  78 MB=$(( 1024 * $KB ))
  79 GB=$(( 1024 * $MB ))
  80 TB=$(( 1024 * $GB ))
  81 PB=$(( 1024 * $TB ))
  82
  83 create_test_inputs2()
  84 {
  85         create_test_dir
  86
  87         if ! getconf MIN_HOLE_SIZE "$(pwd)"; then
  88             echo "getconf MIN_HOLE_SIZE $(pwd) failed; sparse files probably" \
  89                  "not supported by file system"
  90             mount
  91             atf_skip "Test's work directory does not support sparse files;" \
  92                      "try with a different TMPDIR?"
  93         fi
  94
  95         for filesize in 1 512 $(( 2 * $KB )) $(( 10 * $KB )) $(( 512 * $KB )); \
  96         do
  97                 atf_check -e ignore -o empty -s exit:0 \
  98                     dd if=/dev/zero of=${filesize}.file bs=1 \
  99                     count=1 oseek=${filesize} conv=sparse
 100                 files="${files} ${filesize}.file"
 101         done
 102
 103         for filesize in $MB $GB $TB; do
 104                 atf_check -e ignore -o empty -s exit:0 \
 105                     dd if=/dev/zero of=${filesize}.file bs=$MB \
 106                     count=1 oseek=$(( $filesize / $MB )) conv=sparse
 107                 files="${files} ${filesize}.file"
 108         done
 109 }
 110
 111 atf_test_case A_flag
 112 A_flag_head()
 113 {
 114         atf_set "descr" "Verify -A support with unprivileged users"
 115 }
 116
 117 A_flag_body()
 118 {
 119         create_test_dir
 120
 121         atf_check -e empty -o empty -s exit:0 ls -A
 122
 123         create_test_inputs
 124
 125         WITH_A=$PWD/../with_A.out
 126         WITHOUT_A=$PWD/../without_A.out
 127
 128         atf_check -e empty -o save:$WITH_A -s exit:0 ls -A
 129         atf_check -e empty -o save:$WITHOUT_A -s exit:0 ls
 130
 131         echo "-A usage"
 132         cat $WITH_A
 133         echo "No -A usage"
 134         cat $WITHOUT_A
 135
 136         for dot_path in '\.f' '\.g'; do
 137                 atf_check -e empty -o not-empty -s exit:0 grep "${dot_path}" \
 138                     $WITH_A
 139                 atf_check -e empty -o empty -s not-exit:0 grep "${dot_path}" \
 140                     $WITHOUT_A
 141         done
 142 }
 143
 144 atf_test_case A_flag_implied_when_root
 145 A_flag_implied_when_root_head()
 146 {
 147         atf_set "descr" "Verify that -A is implied for root"
 148         atf_set "require.user" "root"
 149 }
 150
 151 A_flag_implied_when_root_body()
 152 {
 153         create_test_dir
 154
 155         atf_check -e empty -o empty -s exit:0 ls -A
 156
 157         create_test_inputs
 158
 159         WITH_EXPLICIT=$PWD/../with_explicit_A.out
 160         WITH_IMPLIED=$PWD/../with_implied_A.out
 161
 162         atf_check -e empty -o save:$WITH_EXPLICIT -s exit:0 ls -A
 163         atf_check -e empty -o save:$WITH_IMPLIED -s exit:0 ls
 164
 165         echo "Explicit -A usage"
 166         cat $WITH_EXPLICIT
 167         echo "Implicit -A usage"
 168         cat $WITH_IMPLIED
 169
 170         atf_check_equal "$(cat $WITH_EXPLICIT)" "$(cat $WITH_IMPLIED)"
 171 }
 172
 173 atf_test_case B_flag
 174 B_flag_head()
 175 {
 176         atf_set "descr" "Verify that the output from ls -B prints out non-printable characters"
 177 }
 178
 179 B_flag_body()
 180 {
 181         atf_check -e empty -o empty -s exit:0 touch "$(printf "y\013z")"
 182         atf_check -e empty -o match:'y\\013z' -s exit:0 ls -B
 183 }
 184
 185 atf_test_case C_flag
 186 C_flag_head()
 187 {
 188         atf_set "descr" "Verify that the output from ls -C is multi-column, sorted down"
 189 }
 190
 191 print_index()
 192 {
 193         local i=1
 194         local wanted_index=$1; shift
 195
 196         while [ $i -le $wanted_index ]; do
 197                 if [ $i -eq $wanted_index ]; then
 198                         echo $1
 199                         return
 200                 fi
 201                 shift
 202                 : $(( i += 1 ))
 203         done
 204 }
 205
 206 C_flag_body()
 207 {
 208         create_test_inputs
 209
 210         WITH_C=$PWD/../with_C.out
 211
 212         export COLUMNS=40
 213         atf_check -e empty -o save:$WITH_C -s exit:0 ls -C
 214
 215         echo "With -C usage"
 216         cat $WITH_C
 217
 218         paths=$(find -s . -mindepth 1 -maxdepth 1 \! -name '.*' -exec basename {} \; )
 219         set -- $paths
 220         num_paths=$#
 221         num_columns=2
 222
 223         max_num_paths_per_column=$(( $(( $num_paths + 1 )) / $num_columns ))
 224
 225         local i=1
 226         while [ $i -le $max_num_paths_per_column ]; do
 227                 column_1=$(print_index $i $paths)
 228                 column_2=$(print_index $(( $i + $max_num_paths_per_column )) $paths)
 229                 #echo "paths[$(( $i + $max_num_paths_per_column ))] = $column_2"
 230                 expected_expr="$column_1"
 231                 if [ -n "$column_2" ]; then
 232                         expected_expr="$expected_expr[[:space:]]+$column_2"
 233                 fi
 234                 atf_check -e ignore -o not-empty -s exit:0 \
 235                     egrep "$expected_expr" $WITH_C
 236                 : $(( i += 1 ))
 237         done
 238 }
 239
 240 atf_test_case D_flag
 241 D_flag_head()
 242 {
 243         atf_set "descr" "Verify that the output from ls -D modifies the time format used with ls -l"
 244 }
 245
 246 D_flag_body()
 247 {
 248         atf_check -e empty -o empty -s exit:0 touch a.file
 249         atf_check -e empty -o match:"$(stat -f '%c[[:space:]]+%N' a.file)" \
 250             -s exit:0 ls -lD '%s'
 251 }
 252
 253 atf_test_case F_flag
 254 F_flag_head()
 255 {
 256         atf_set "descr" "Verify that the output from ls -F prints out appropriate symbols after files"
 257 }
 258
 259 F_flag_body()
 260 {
 261         create_test_inputs
 262
 263         atf_check -e empty -s exit:0 \
 264             sh -c "pid=${ATF_TMPDIR}/nc.pid; daemon -p \$pid nc -lU j; sleep 2; pkill -F \$pid"
 265
 266         atf_check -e empty -o match:'a/' -s exit:0 ls -F
 267         atf_check -e empty -o match:'c@' -s exit:0 ls -F
 268         atf_check -e empty -o match:'h\|' -s exit:0 ls -F
 269         atf_check -e empty -o match:'j=' -s exit:0 ls -F
 270         #atf_check -e empty -o match:'<whiteout-file>%' -s exit:0 ls -F
 271         atf_check -e empty -o match:'stuv' -s exit:0 ls -F
 272         atf_check -e empty -o match:'wxyz\*' -s exit:0 ls -F
 273 }
 274
 275 atf_test_case H_flag
 276 H_flag_head()
 277 {
 278         atf_set "descr" "Verify that ls -H follows symlinks"
 279 }
 280
 281 H_flag_body()
 282 {
 283         create_test_inputs
 284
 285         atf_check -e empty -o match:'1' -s exit:0 ls -H c
 286 }
 287
 288 atf_test_case I_flag
 289 I_flag_head()
 290 {
 291         atf_set "descr" "Verify that the output from ls -I is the same as ls for an unprivileged user"
 292 }
 293
 294 I_flag_body()
 295 {
 296         create_test_inputs
 297
 298         WITH_I=$PWD/../with_I.out
 299         WITHOUT_I=$PWD/../without_I.out
 300
 301         atf_check -e empty -o save:$WITH_I -s exit:0 ls -I
 302         atf_check -e empty -o save:$WITHOUT_I -s exit:0 ls
 303
 304         echo "Explicit -I usage"
 305         cat $WITH_I
 306         echo "No -I usage"
 307         cat $WITHOUT_I
 308
 309         atf_check_equal "$(cat $WITH_I)" "$(cat $WITHOUT_I)"
 310 }
 311
 312 atf_test_case I_flag_voids_implied_A_flag_when_root
 313 I_flag_voids_implied_A_flag_when_root_head()
 314 {
 315         atf_set "descr" "Verify that -I voids out implied -A for root"
 316         atf_set "require.user" "root"
 317 }
 318
 319 I_flag_voids_implied_A_flag_when_root_body()
 320 {
 321         create_test_inputs
 322
 323         atf_check -o not-match:'\.f' -s exit:0 ls -I
 324         atf_check -o not-match:'\.g' -s exit:0 ls -I
 325
 326         atf_check -o match:'\.f' -s exit:0 ls -A -I
 327         atf_check -o match:'\.g' -s exit:0 ls -A -I
 328 }
 329
 330 atf_test_case L_flag
 331 L_flag_head()
 332 {
 333         atf_set "descr" "Verify that -L prints out the symbolic link and conversely -P prints out the target for the symbolic link"
 334 }
 335
 336 L_flag_body()
 337 {
 338         atf_check -e empty -o empty -s exit:0 ln -s target1/target2 link1
 339         atf_check -e empty -o match:link1 -s exit:0 ls -L
 340         atf_check -e empty -o not-match:target1/target2 -s exit:0 ls -L
 341 }
 342
 343 atf_test_case R_flag
 344 R_flag_head()
 345 {
 346         atf_set "descr" "Verify that the output from ls -R prints out the directory contents recursively"
 347 }
 348
 349 R_flag_body()
 350 {
 351         create_test_inputs
 352
 353         WITH_R=$PWD/../with_R.out
 354         WITH_R_expected_output=$PWD/../with_R_expected.out
 355
 356         atf_check -e empty -o save:$WITH_R -s exit:0 ls -R
 357
 358         set -- . $(find -s . \! -name '.*' -type d)
 359         while [ $# -gt 0 ]; do
 360                 dir=$1; shift
 361                 [ "$dir" != "." ] && echo "$dir:"
 362                 (cd $dir && ls -1A | sed -e '/^\./d')
 363                 [ $# -ne 0 ] && echo
 364         done > $WITH_R_expected_output
 365
 366         echo "-R usage"
 367         cat $WITH_R
 368         echo "-R expected output"
 369         cat $WITH_R_expected_output
 370
 371         atf_check_equal "$(cat $WITH_R)" "$(cat $WITH_R_expected_output)"
 372 }
 373
 374 atf_test_case S_flag
 375 S_flag_head()
 376 {
 377         atf_set "descr" "Verify that -S sorts by file size, then by filename lexicographically"
 378 }
 379
 380 S_flag_body()
 381 {
 382         create_test_dir
 383
 384         file_list_dir=$PWD/../files
 385
 386         atf_check -e empty -o empty -s exit:0 mkdir -p $file_list_dir
 387
 388         create_test_inputs
 389         create_test_inputs2
 390
 391         WITH_S=$PWD/../with_S.out
 392         WITHOUT_S=$PWD/../without_S.out
 393
 394         atf_check -e empty -o save:$WITH_S ls -D '%s' -lS
 395         atf_check -e empty -o save:$WITHOUT_S ls -D '%s' -l
 396
 397         WITH_S_parsed=$(awk '! /^total/ { print $7 }' $WITH_S)
 398         set -- $(awk '! /^total/ { print $5, $7 }' $WITHOUT_S)
 399         while [ $# -gt 0 ]; do
 400                 size=$1; shift
 401                 filename=$1; shift
 402                 echo $filename >> $file_list_dir/${size}
 403         done
 404         file_lists=$(find $file_list_dir -type f -exec basename {} \; | sort -nr)
 405         WITHOUT_S_parsed=$(for file_list in $file_lists; do sort < $file_list_dir/$file_list; done)
 406
 407         echo "-lS usage (parsed)"
 408         echo "$WITH_S_parsed"
 409         echo "-l usage (parsed)"
 410         echo "$WITHOUT_S_parsed"
 411
 412         atf_check_equal "$WITHOUT_S_parsed" "$WITH_S_parsed"
 413 }
 414
 415 atf_test_case T_flag
 416 T_flag_head()
 417 {
 418         atf_set "descr" "Verify -T support"
 419 }
 420
 421 T_flag_body()
 422 {
 423         create_test_dir
 424
 425         atf_check -e empty -o empty -s exit:0 touch a.file
 426
 427         mtime_in_secs=$(stat -f %m -t %s a.file)
 428         mtime=$(date -j -f %s $mtime_in_secs +"[[:space:]]+%b[[:space:]]+%e[[:space:]]+%H:%M:%S[[:space:]]+%Y")
 429
 430         atf_check -e empty -o match:"$mtime"'[[:space:]]+a\.file' \
 431             -s exit:0 ls -lT a.file
 432 }
 433
 434 atf_test_case a_flag
 435 a_flag_head()
 436 {
 437         atf_set "descr" "Verify -a support"
 438 }
 439
 440 a_flag_body()
 441 {
 442         create_test_dir
 443
 444         # Make sure "." and ".." show up with -a
 445         atf_check -e empty -o match:'\.[[:space:]]+\.\.'  -s exit:0 ls -ax
 446
 447         create_test_inputs
 448
 449         WITH_a=$PWD/../with_a.out
 450         WITHOUT_a=$PWD/../without_a.out
 451
 452         atf_check -e empty -o save:$WITH_a -s exit:0 ls -a
 453         atf_check -e empty -o save:$WITHOUT_a -s exit:0 ls
 454
 455         echo "-a usage"
 456         cat $WITH_a
 457         echo "No -a usage"
 458         cat $WITHOUT_a
 459
 460         for dot_path in '\.f' '\.g'; do
 461                 atf_check -e empty -o not-empty -s exit:0 grep "${dot_path}" \
 462                     $WITH_a
 463                 atf_check -e empty -o empty -s not-exit:0 grep "${dot_path}" \
 464                     $WITHOUT_a
 465         done
 466 }
 467
 468 atf_test_case b_flag
 469 b_flag_head()
 470 {
 471         atf_set "descr" "Verify that the output from ls -b prints out non-printable characters"
 472 }
 473
 474 b_flag_body()
 475 {
 476         atf_check -e empty -o empty -s exit:0 touch "$(printf "y\013z")"
 477         atf_check -e empty -o match:'y\\vz' -s exit:0 ls -b
 478 }
 479
 480 atf_test_case d_flag
 481 d_flag_head()
 482 {
 483         atf_set "descr" "Verify that -d doesn't descend down directories"
 484 }
 485
 486 d_flag_body()
 487 {
 488         create_test_dir
 489
 490         output=$PWD/../output
 491
 492         atf_check -e empty -o empty -s exit:0 mkdir -p a/b
 493
 494         for path in . $PWD a; do
 495                 atf_check -e empty -o save:$output -s exit:0 ls -d $path
 496                 atf_check_equal "$(cat $output)" "$path"
 497         done
 498 }
 499
 500 atf_test_case f_flag
 501 f_flag_head()
 502 {
 503         atf_set "descr" "Verify that -f prints out the contents of a directory unsorted"
 504 }
 505
 506 f_flag_body()
 507 {
 508         create_test_inputs
 509
 510         output=$PWD/../output
 511
 512         # XXX: I don't have enough understanding of how the algorithm works yet
 513         # to determine more than the fact that all the entries printed out
 514         # exist
 515         paths=$(find -s . -mindepth 1 -maxdepth 1 \! -name '.*' -exec basename {} \; )
 516
 517         atf_check -e empty -o save:$output -s exit:0 ls -f
 518
 519         for path in $paths; do
 520                 atf_check -e ignore -o not-empty -s exit:0 \
 521                     egrep "^$path$" $output
 522         done
 523 }
 524
 525 atf_test_case g_flag
 526 g_flag_head()
 527 {
 528         atf_set "descr" "Verify that -g does nothing (compatibility flag)"
 529 }
 530
 531 g_flag_body()
 532 {
 533         create_test_inputs2
 534         for file in $files; do
 535                 atf_check -e empty -o match:"$(ls -a $file)" -s exit:0 \
 536                     ls -ag $file
 537                 atf_check -e empty -o match:"$(ls -la $file)" -s exit:0 \
 538                     ls -alg $file
 539         done
 540 }
 541
 542 atf_test_case h_flag
 543 h_flag_head()
 544 {
 545         atf_set "descr" "Verify that -h prints out the humanized units for file sizes with ls -l"
 546         atf_set "require.progs" "bc"
 547 }
 548
 549 h_flag_body()
 550 {
 551         # XXX: this test doesn't currently show how 999 bytes will be 999B,
 552         # but 1000 bytes will be 1.0K, due to how humanize_number(3) works.
 553         create_test_inputs2
 554         for file in $files; do
 555                 file_size=$(stat -f '%z' "$file") || \
 556                     atf_fail "stat'ing $file failed"
 557                 scale=2
 558                 if [ $file_size -lt $KB ]; then
 559                         divisor=1
 560                         scale=0
 561                         suffix=B
 562                 elif [ $file_size -lt $MB ]; then
 563                         divisor=$KB
 564                         suffix=K
 565                 elif [ $file_size -lt $GB ]; then
 566                         divisor=$MB
 567                         suffix=M
 568                 elif [ $file_size -lt $TB ]; then
 569                         divisor=$GB
 570                         suffix=G
 571                 elif [ $file_size -lt $PB ]; then
 572                         divisor=$TB
 573                         suffix=T
 574                 else
 575                         divisor=$PB
 576                         suffix=P
 577                 fi
 578
 579                 bc_expr="$(printf "scale=%s\n%s/%s\nquit" $scale $file_size $divisor)"
 580                 size_humanized=$(bc -e "$bc_expr" | tr '.' '\.' | sed -e 's,\.00,,')
 581
 582                 atf_check -e empty -o match:"$size_humanized.+$file" \
 583                     -s exit:0 ls -hl $file
 584         done
 585 }
 586
 587 atf_test_case i_flag
 588 i_flag_head()
 589 {
 590         atf_set "descr" "Verify that -i prints out the inode for files"
 591 }
 592
 593 i_flag_body()
 594 {
 595         create_test_inputs
 596
 597         paths=$(find -L . -mindepth 1)
 598         [ -n "$paths" ] || atf_skip 'Could not find any paths to iterate over (!)'
 599
 600         for path in $paths; do
 601                 atf_check -e empty \
 602                     -o match:"$(stat -f '[[:space:]]*%i[[:space:]]+%N' $path)" \
 603                     -s exit:0 ls -d1i $path
 604         done
 605 }
 606
 607 atf_test_case k_flag
 608 k_flag_head()
 609 {
 610         atf_set "descr" "Verify that -k prints out the size with a block size of 1kB"
 611 }
 612
 613 k_flag_body()
 614 {
 615         create_test_inputs2
 616         for file in $files; do
 617                 atf_check -e empty \
 618                     -o match:"[[:space:]]+$(stat -f "%z" $file)[[:space:]]+.+[[:space:]]+$file" ls -lk $file
 619         done
 620 }
 621
 622 atf_test_case l_flag
 623 l_flag_head()
 624 {
 625         atf_set "descr" "Verify that -l prints out the output in long format"
 626 }
 627
 628 l_flag_body()
 629 {
 630
 631         atf_check -e empty -o empty -s exit:0 touch a.file
 632
 633         mtime_in_secs=$(stat -f "%m" -t "%s" a.file)
 634         mtime=$(date -j -f "%s" $mtime_in_secs +"%b[[:space:]]+%e[[:space:]]+%H:%M")
 635
 636         expected_output=$(stat -f "%Sp[[:space:]]+%l[[:space:]]+%Su[[:space:]]+%Sg[[:space:]]+%z[[:space:]]+$mtime[[:space:]]+a\\.file" a.file)
 637
 638         atf_check -e empty -o match:"$expected_output" -s exit:0 ls -l a.file
 639 }
 640
 641 atf_test_case lcomma_flag
 642 lcomma_flag_head()
 643 {
 644         atf_set "descr" "Verify that -l, prints out the size with ',' delimiters"
 645 }
 646
 647 lcomma_flag_body()
 648 {
 649         create_test_inputs
 650
 651         atf_check \
 652             -o match:'\-rw\-r\-\-r\-\-[[:space:]]+.+[[:space:]]+1,000[[:space:]]+.+i' \
 653             env LC_ALL=en_US.ISO8859-1 ls -l, i
 654 }
 655
 656 atf_test_case m_flag
 657 m_flag_head()
 658 {
 659         atf_set "descr" "Verify that the output from ls -m is comma-separated"
 660 }
 661
 662 m_flag_body()
 663 {
 664         create_test_dir
 665
 666         output=$PWD/../output
 667
 668         atf_check -e empty -o empty -s exit:0 touch ,, "a,b " c d e
 669
 670         atf_check -e empty -o save:$output -s exit:0 ls -m
 671
 672         atf_check_equal "$(cat $output)" ",,, a,b , c, d, e"
 673 }
 674
 675 atf_test_case n_flag
 676 n_flag_head()
 677 {
 678         atf_set "descr" "Verify that the output from ls -n prints out numeric GIDs/UIDs instead of symbolic GIDs/UIDs"
 679         atf_set "require.user" "root"
 680 }
 681
 682 n_flag_body()
 683 {
 684         daemon_gid=$(id -g daemon) || atf_skip "could not resolve gid for daemon (!)"
 685         nobody_uid=$(id -u nobody) || atf_skip "could not resolve uid for nobody (!)"
 686
 687         atf_check -e empty -o empty -s exit:0 touch a.file
 688         atf_check -e empty -o empty -s exit:0 chown $nobody_uid:$daemon_gid a.file
 689
 690         atf_check -e empty \
 691             -o match:'\-rw\-r\-\-r\-\-[[:space:]]+1[[:space:]]+'"$nobody_uid[[:space:]]+$daemon_gid"'[[:space:]]+.+a\.file' \
 692             ls -ln a.file
 693
 694 }
 695
 696 atf_test_case o_flag
 697 o_flag_head()
 698 {
 699         atf_set "descr" "Verify that the output from ls -o prints out the chflag values or '-' if none are set"
 700 }
 701
 702 o_flag_body()
 703 {
 704         local size=12345
 705
 706         create_test_dir
 707
 708         atf_check -e ignore -o empty -s exit:0 dd if=/dev/zero of=a.file \
 709             bs=$size count=1
 710         atf_check -e ignore -o empty -s exit:0 dd if=/dev/zero of=b.file \
 711             bs=$size count=1
 712         atf_check -e empty -o empty -s exit:0 chflags uarch a.file
 713         atf_check -e empty -o empty -s exit:0 chflags 0 b.file
 714
 715         atf_check -e empty -o match:"[[:space:]]+uarch[[:space:]]$size+.+a\\.file" \
 716             -s exit:0 ls -lo a.file
 717         atf_check -e empty -o match:"[[:space:]]+\\-[[:space:]]$size+.+b\\.file" \
 718             -s exit:0 ls -lo b.file
 719 }
 720
 721 atf_test_case p_flag
 722 p_flag_head()
 723 {
 724         atf_set "descr" "Verify that the output from ls -p prints out '/' after directories"
 725 }
 726
 727 p_flag_body()
 728 {
 729         create_test_inputs
 730
 731         paths=$(find -L .)
 732         [ -n "$paths" ] || atf_skip 'Could not find any paths to iterate over (!)'
 733
 734         for path in $paths; do
 735                 suffix=
 736                 # If path is not a symlink and is a directory, then the suffix
 737                 # must be "/".
 738                 if [ ! -L "${path}" -a -d "$path" ]; then
 739                         suffix=/
 740                 fi
 741                 atf_check -e empty -o match:"$path${suffix}" -s exit:0 \
 742                     ls -dp $path
 743         done
 744 }
 745
 746 atf_test_case q_flag_and_w_flag
 747 q_flag_and_w_flag_head()
 748 {
 749         atf_set "descr" "Verify that the output from ls -q prints out '?' for ESC and ls -w prints out the escape character"
 750 }
 751
 752 q_flag_and_w_flag_body()
 753 {
 754         create_test_dir
 755
 756         test_file="$(printf "y\01z")"
 757
 758         atf_check -e empty -o empty -s exit:0 touch "$test_file"
 759
 760         atf_check -e empty -o match:'y\?z' -s exit:0 ls -q "$test_file"
 761         atf_check -e empty -o match:"$test_file" -s exit:0 ls -w "$test_file"
 762 }
 763
 764 atf_test_case r_flag
 765 r_flag_head()
 766 {
 767         atf_set "descr" "Verify that the output from ls -r sorts the same way as reverse sorting with sort(1)"
 768 }
 769
 770 r_flag_body()
 771 {
 772         create_test_inputs
 773
 774         WITH_r=$PWD/../with_r.out
 775         WITH_sort=$PWD/../with_sort.out
 776
 777         atf_check -e empty -o save:$WITH_r -s exit:0 ls -1r
 778         atf_check -e empty -o save:$WITH_sort -s exit:0 sh -c 'ls -1 | sort -r'
 779
 780         echo "Sorted with -r"
 781         cat $WITH_r
 782         echo "Reverse sorted with sort(1)"
 783         cat $WITH_sort
 784
 785         atf_check_equal "$(cat $WITH_r)" "$(cat $WITH_sort)"
 786 }
 787
 788 atf_test_case s_flag
 789 s_flag_head()
 790 {
 791         atf_set "descr" "Verify that the output from ls -s matches the output from stat(1)"
 792 }
 793
 794 s_flag_body()
 795 {
 796         create_test_inputs2
 797         for file in $files; do
 798                 atf_check -e empty \
 799                     -o match:"$(stat -f "%b" $file)[[:space:]]+$file" ls -s $file
 800         done
 801 }
 802
 803 atf_test_case t_flag
 804 t_flag_head()
 805 {
 806         atf_set "descr" "Verify that the output from ls -t sorts by modification time"
 807 }
 808
 809 t_flag_body()
 810 {
 811         create_test_dir
 812
 813         atf_check -e empty -o empty -s exit:0 touch a.file
 814         atf_check -e empty -o empty -s exit:0 touch b.file
 815
 816         atf_check -e empty -o match:'a\.file' -s exit:0 sh -c 'ls -lt | tail -n 1'
 817         atf_check -e empty -o match:'b\.file.*a\.file' -s exit:0 ls -Ct
 818
 819         atf_check -e empty -o empty -s exit:0 rm a.file
 820         atf_check -e empty -o empty -s exit:0 sh -c 'echo "i am a" > a.file'
 821
 822         atf_check -e empty -o match:'b\.file' -s exit:0 sh -c 'ls -lt | tail -n 1'
 823         atf_check -e empty -o match:'a\.file.*b\.file' -s exit:0 ls -Ct
 824 }
 825
 826 atf_test_case u_flag
 827 u_flag_head()
 828 {
 829         atf_set "descr" "Verify that the output from ls -u sorts by last access"
 830 }
 831
 832 u_flag_body()
 833 {
 834         create_test_dir
 835
 836         atf_check -e empty -o empty -s exit:0 touch a.file
 837         atf_check -e empty -o empty -s exit:0 touch b.file
 838
 839         atf_check -e empty -o match:'b\.file' -s exit:0 sh -c 'ls -lu | tail -n 1'
 840         atf_check -e empty -o match:'a\.file.*b\.file' -s exit:0 ls -Cu
 841
 842         atf_check -e empty -o empty -s exit:0 sh -c 'echo "i am a" > a.file'
 843         atf_check -e empty -o match:'i am a' -s exit:0 cat a.file
 844
 845         atf_check -e empty -o match:'b\.file' -s exit:0 sh -c 'ls -lu | tail -n 1'
 846         atf_check -e empty -o match:'a\.file.*b\.file' -s exit:0 ls -Cu
 847 }
 848
 849 atf_test_case x_flag
 850 x_flag_head()
 851 {
 852         atf_set "descr" "Verify that the output from ls -x is multi-column, sorted across"
 853 }
 854
 855 x_flag_body()
 856 {
 857         create_test_inputs
 858
 859         WITH_x=$PWD/../with_x.out
 860
 861         atf_check -e empty -o save:$WITH_x -s exit:0 ls -x
 862
 863         echo "With -x usage"
 864         cat $WITH_x
 865
 866         atf_check -e ignore -o not-empty -s exit:0 \
 867             egrep "a[[:space:]]+c[[:space:]]+d[[:space:]]+e[[:space:]]+h" $WITH_x
 868         atf_check -e ignore -o not-empty -s exit:0 \
 869             egrep "i[[:space:]]+klmn[[:space:]]+opqr[[:space:]]+stuv[[:space:]]+wxyz" $WITH_x
 870 }
 871
 872 atf_test_case y_flag
 873 y_flag_head()
 874 {
 875         atf_set "descr" "Verify that the output from ls -y sorts the same way as sort(1)"
 876 }
 877
 878 y_flag_body()
 879 {
 880         create_test_inputs
 881
 882         WITH_sort=$PWD/../with_sort.out
 883         WITH_y=$PWD/../with_y.out
 884
 885         atf_check -e empty -o save:$WITH_sort -s exit:0 sh -c 'ls -1 | sort'
 886         atf_check -e empty -o save:$WITH_y -s exit:0 ls -1y
 887
 888         echo "Sorted with sort(1)"
 889         cat $WITH_sort
 890         echo "Sorted with -y"
 891         cat $WITH_y
 892
 893         atf_check_equal "$(cat $WITH_sort)" "$(cat $WITH_y)"
 894 }
 895
 896 atf_test_case 1_flag
 897 1_flag_head()
 898 {
 899         atf_set "descr" "Verify that -1 prints out one item per line"
 900 }
 901
 902 1_flag_body()
 903 {
 904         create_test_inputs
 905
 906         WITH_1=$PWD/../with_1.out
 907         WITHOUT_1=$PWD/../without_1.out
 908
 909         atf_check -e empty -o save:$WITH_1 -s exit:0 ls -1
 910         atf_check -e empty -o save:$WITHOUT_1 -s exit:0 \
 911                 sh -c 'for i in $(ls); do echo $i; done'
 912
 913         echo "Explicit -1 usage"
 914         cat $WITH_1
 915         echo "No -1 usage"
 916         cat $WITHOUT_1
 917
 918         atf_check_equal "$(cat $WITH_1)" "$(cat $WITHOUT_1)"
 919 }
 920
 921 atf_init_test_cases()
 922 {
 923         export BLOCKSIZE=512
 924
 925         atf_add_test_case A_flag
 926         atf_add_test_case A_flag_implied_when_root
 927         atf_add_test_case B_flag
 928         atf_add_test_case C_flag
 929         atf_add_test_case D_flag
 930         atf_add_test_case F_flag
 931         #atf_add_test_case G_flag
 932         atf_add_test_case H_flag
 933         atf_add_test_case I_flag
 934         atf_add_test_case I_flag_voids_implied_A_flag_when_root
 935         atf_add_test_case L_flag
 936         #atf_add_test_case P_flag
 937         atf_add_test_case R_flag
 938         atf_add_test_case S_flag
 939         atf_add_test_case T_flag
 940         #atf_add_test_case U_flag
 941         #atf_add_test_case W_flag
 942         #atf_add_test_case Z_flag
 943         atf_add_test_case a_flag
 944         atf_add_test_case b_flag
 945         #atf_add_test_case c_flag
 946         atf_add_test_case d_flag
 947         atf_add_test_case f_flag
 948         atf_add_test_case g_flag
 949         atf_add_test_case h_flag
 950         atf_add_test_case i_flag
 951         atf_add_test_case k_flag
 952         atf_add_test_case l_flag
 953         atf_add_test_case lcomma_flag
 954         atf_add_test_case m_flag
 955         atf_add_test_case n_flag
 956         atf_add_test_case o_flag
 957         atf_add_test_case p_flag
 958         atf_add_test_case q_flag_and_w_flag
 959         atf_add_test_case r_flag
 960         atf_add_test_case s_flag
 961         atf_add_test_case t_flag
 962         atf_add_test_case u_flag
 963         atf_add_test_case x_flag
 964         atf_add_test_case y_flag
 965         atf_add_test_case 1_flag
 966 }