#
# Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# ident	"@(#)all.assertion	1.9	07/08/28 SMI"
#
# test assertions for mirror-mounts
#

################################################################################
# General info:
# suite:        mirrormnt(implement based on the TET test harness)
# nfsv4:        client+server
# solaris:      sparc+x86(32+64bit)
# zone(client): global+non-global
# fs(server):   UFS(LOFI)+ZFS
################################################################################


################################################################################
# for making the assertions clearer, take the following assumption, and give
# simple example and explanation for each assertion in lines:

# the whole structure of test dir in server:
# /test_MMs_$CLIENT(=SHRDIR)
#   |- func(=FUNC_SHR)
#      |- fs1
#         |- dir2
#         |- file2
#         |- fs2_notshare  # just for negative test
#            |- fs3_0
#         |- fs2_syml -> fs2      # this symbolic link has been created before test
#         |- fs2_unlsyml -> fs2  # this symbolic link has been created before test
#         |- fs2_newsyml -> fs2  # this will be created by one of the test
#         |- fs2
#            |- dir3
#               |- fs3_1
#                  |- readme1
#                  |- dir4
#                     |- fs4_1
#                        |- readme2
#            |- file3
#            |- newfile3   # this file will be created by one of the test
#            |- delfile3   # this file will be deleted by one of the test
#            |- fs3_newfs  # this filesystem is new created by one of the test
#            |- fs3
#               |- dir4
#               |- file4
#               |- fs4_notshare  # just for negative test
#                  |- fs5_0
#               |- fs4_syml -> fs4      # this symbolic link has been created before test
#               |- fs4_unlsyml -> fs4  # this symbolic link has been created before test
#               |- fs4_newsyml -> fs4  # this will be created by one of the test
#               |- fs4
#                  |- dir5
#                  |- file5
#                  |- newfile5  # this file will be created by one of the test
#                  |- delfile5  # this file will be deleted by one of the test
#                  |- fs5
#   |- stress(=STRESS_SHR)
#      |- fs00
#         |- fs01
#            |- ...
#         |- fs10
#            |- ... (see the structure of stress test below)
# share -F nfs -o $shropts $FUNC_SHR/fs1
# share -F nfs -o $shropts $FUNC_SHR/fs1/fs2
# share -F nfs -o $shropts $FUNC_SHR/fs1/fs2/fs3
# ...
# share -F nfs -o $shropts $STRESS_SHR
# NOTE: the share options for these filesystems could be different

# in client:
#     mount -F nfs -o $mntopts,vers=4 $server:$FUNC_SHR/fs1 /mnt
# check mount:
#     mount | grep "^/mnt on "
#     ls /mnt | wc -l
################################################################################


################################################################################
        for trigger actions - automatic mirror-mount and nested mounts
# NOTE: all tests(mirrormnt_pos* and nestedmnt_pos*) in this part will do
#       "manual" unmount at the same time, two purpose:
#           1. release the mount point for next test
#           2. test manual unmount for mirror-mount
################################################################################

######## positive tests ########

# for all mirrormnt_pos* tests with only one mirror-mount point, need to check:
# - it is a mirror-mount(4 ways):
#     1: grep "/mnt/fs2" /etc/mnttab
#     2: mount | grep "^/mnt/fs2 on "
#     3: nfsstat -m /mnt/fs2
#     4: df /mnt/fs2
# BUT according to the PRS, the output of "nfsstat -m" will mark
# mirror-mount additionally, so it should be the preferable choice, and itself
# also can be regarded as a test for checking the new output of "nfsstat -m"
# due to the advent of mirror-mount:
#     2: mount | grep "^/mnt/fs2 on "
#     3: nfsstat -m /mnt/fs2 | grep "mirrormount"
# - and the file/directory under the mirror-mount point is accessiable:
#     cat /mnt/fs2/file3
# - and unmount manually in the end:
#     umount /mnt/fs2
#     mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: mirrormnt_pos001
DESCRIPTION: check the target directory is mounted successfully if
             access it with "ls [-a] [-l]"
# ls [-a] [-l] /mnt/fs2 =
# ls /mnt/fs2       +
# ls -a /mnt/fs2    +
# ls -l /mnt/fs2    +
# ls -al /mnt/fs2

ID: mirrormnt_pos002
DESCRIPTION: check the target directory is mounted successfully if
             "ls" the file under the target directory
# ls /mnt/fs2/file3

ID: mirrormnt_pos003
DESCRIPTION: check the target directory is mounted successfully if
             "cd" to the target directory
# cd /mnt/fs2

ID: mirrormnt_pos004
DESCRIPTION: check the target directory is mounted successfully if
             create a new file under the target directory
# echo "hello world" > /mnt/fs2/newfile3

ID: mirrormnt_pos005
DESCRIPTION: check the target directory is mounted successfully if
             delete a file under the target directory
# rm /mnt/fs2/delfile3

ID: mirrormnt_pos006
DESCRIPTION: check the target directory is mounted successfully if
             rename the target directory
# mv /mnt/fs2 /mnt/fs2_ren
# cat /mnt/fs2_ren/file3
# mv /mnt/fs2_ren /mnt/fs2
# cat /mnt/fs2/file3

ID: mirrormnt_pos007
DESCRIPTION: check the target directory is mounted successfully if
             create a symbolic link to the target directory
# ln -s /mnt/fs2 /mnt/fs2_newsyml
# ls [-a] /mnt/fs2_newsyml

# for all nested_pos* tests with several mirror-mount points, need to check:
# - all mirror-mounts and files/dirs within them:
#   nfsstat -m /mnt/fs2 | grep "mirrormount"
#   nfsstat -m /mnt/fs2/fs3 | grep "mirrormount"
#   nfsstat -m /mnt/fs2/fs3/fs4 | grep "mirrormount"
#   cat /mnt/fs2/file3
#   cat /mnt/fs2/fs3/file4
#   cat /mnt/fs2/fs3/fs4/file5
# - and at last, all mirror-mounts are unmounted successfully if randomly using
#   the three unmount ways described in nestedmnt_pos001~003 cases

ID: nestedmnt_pos001
DESCRIPTION: check those target directories are all mounted successfully if
             access the last target directory with "ls [-a] [-l]"(then check
             all contained mirror-mounts are unmounted automatically if the
             first mirror-mount is unmounted forcibly)
# ls [-a] [-l] /mnt/fs2/fs3/fs4
# umount /mnt/fs2  # other two mirror-mounts(/mnt/fs2/fs3 and
                      # /mnt/fs2/fs3/fs4) will be unmounted automatically
#  mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
#  mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
#  mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: nestedmnt_pos002
DESCRIPTION: check those target directories are all mounted successfully if
             "ls" the directory under the last target directory(then check
             the second and last mirror-mounts are unmounted as expected
             if unmount the second one forcibly, but the first mirror-mount is
             still existing, at last unmount the first mirror-mount and verify)
# ls /mnt/fs2/fs3/fs4/dir5
# umount /mnt/fs2/fs3
# mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? == 0 ))
# umount /mnt/fs2
# mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: nestedmnt_pos003
DESCRIPTION: check those target directories are all mounted successfully if
             "cd" to the last target directory(then unmount all mirror-mounts
             manually one by one and verify)
# cd /mnt/fs2/fs3/fs4
# umount /mnt/fs2/fs3/fs4
# mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? == 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? == 0 ))
# umount /mnt/fs2/fs3
# mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? == 0 ))
# umount /mnt/fs2
# mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: nestedmnt_pos004
DESCRIPTION: check those target directories are all mounted successfully if
             create a new file under the last target directory
# echo "hello world" > /mnt/fs2/fs3/fs4/newfile5

ID: nestedmnt_pos005
DESCRIPTION: check those target directories are all mounted successfully if
             delete a file under the last target directory
# rm /mnt/fs2/fs3/fs4/delfile5

ID: nestedmnt_pos006
DESCRIPTION: check those target directories are all mounted successfully if
             rename the last target directory
# mv /mnt/fs2/fs3/fs4 /mnt/fs2/fs3/fs4_ren

ID: nestedmnt_pos007
DESCRIPTION: check those target directories are all mounted successfully if
             create a symbolic link to the last target directory
# ln -s /mnt/fs2/fs3/fs4 /mnt/fs2/fs3/fs4_newsyml
# ls [-a] /mnt/fs2/fs3/fs4_newsyml

ID: nestedmnt_pos008
DESCRIPTION: check those target directories are all mounted successfully even
             with 'hole' in the path
# ls -l /mnt/fs2/dir3/fs3_1/dir4/fs4_1

ID: nestedmnt_pos009
DESCRIPTION: check those target directories are all mounted successfully if
             access the initial mount point with "ls -lR"
# ls -lR /mnt

ID: nestedmnt_pos010
DESCRIPTION: check those target directories are all mounted successfully if
             find all files/dirs under the initial mount point
# find /mnt

ID: nestedmnt_pos011
DESCRIPTION: check those target directories are all mounted successfully if
             multi-processes access them simultaneously
# one process accesses /mnt/fs2/fs3
# another process accesses /mnt/fs2/fs3/fs4

ID: nestedmnt_pos012
DESCRIPTION: check those target directories are all mounted successfully if
             create a symbolic link to the last target directory
# ln -s /mnt/fs2 /mnt/fs2_newsyml
# ln -s /mnt/fs2/../fs2_newsyml/fs3 /tmp/test_mm_syml
# ls /tmp/test_mm_syml/dir4
# rm /tmp/test_mm_syml /mnt/fs2_newsyml

######## negative tests ########

# for all mirrormnt_neg* tests below, need to check the /mnt/fs2 is not mounted:
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: mirrormnt_neg001
DESCRIPTION: check the target directory is not mounted if access its
             parent directory with "ls [-a] [-l]"
# ls [-a] [-l] /mnt

ID: mirrormnt_neg002
DESCRIPTION: check the target directory is not mounted if access it
             with "ls -d[l]"
# ls -d /mnt/fs2
# ls -dl /mnt/fs2

ID: mirrormnt_neg003
DESCRIPTION: check the target directory is not mounted if access it with
             "ls -l" but the needed filesystem in server has not been shared yet
# ls -l /mnt/fs2_notshare/fs3

ID: mirrormnt_neg004
DESCRIPTION: check the target directory is not mounted if access its
             symbolic link with "ls [-d] [-l]"
# ls -d /mnt/fs2_newsyml
# ls -l /mnt/fs2_newsyml
# ls -dl /mnt/fs2_newsyml

# for all nestedmnt_neg* tests below, need to check the last target directory is
# not mounted(but others are mounted as expected):
# mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
# nfsstat -m /mnt/fs2/fs3 | grep "mirrormount" && (( $? == 0 ))
# nfsstat -m /mnt/fs2 | grep "mirrormount" && (( $? == 0 ))

ID: nestedmnt_neg001
DESCRIPTION: check the last target directory is not mounted if access its
             parent directory with "ls [-a] [-l]"
# ls [-a] [-l] /mnt/fs2/fs3
# umount /mnt/fs2
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: nestedmnt_neg002
DESCRIPTION: check the last target directory is not mounted if access it
             with "ls -d[l]"
# ls -d /mnt/fs2/fs3/fs4
# ls -dl /mnt/fs2/fs3/fs4
# umount /mnt/fs2/fs3
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? == 0 ))
# umount /mnt/fs2
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: nestedmnt_neg003
DESCRIPTION: check the last target directory is not mounted if access it with
             "ls -l" but the needed filesystem in server has not been shared yet
# ls -l /mnt/fs2/fs3/fs4_notshare # will give error message?? but "/mnt/fs2" and
                                  # "/mnt/fs2/fs3" still will be mirror-mounted??
# umount /mnt/fs2
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: nestedmnt_neg004
DESCRIPTION: check the last target directory is not mounted if access its
             symbolic link with "ls -l"
# ls -l /mnt/fs2/fs3/fs4_newsyml
# umount /mnt/fs2/fs3
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? == 0 ))
# umount /mnt/fs2
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))


################################################################################
        for interaction with automounter
################################################################################

ID: mirrormnt_automnt001
DESCRIPTION: check the target directory is mounted automatically by automounter
             instead of mirror-mount when there is an auto-map for it, then
             check it can be mounted again after unmounting manually
# has a direct map:
#     /mnt/fs2 -$mntopts $server:/export/fs1/fs2
# automount -t $timeout
# ls /mnt/fs2
# mount | grep "^/mnt/fs2 on " && (( $? == 0 ))
# nfsstat -m /mnt/fs2 | grep "mirrormount" && (( $? != 0 ))
# umount /mnt/fs2    # unmount the auto-mount point manually and verify
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))
# cat /mnt/fs2/file3
# mount | grep "^/mnt/fs2 on " && (( $? == 0 ))
# nfsstat -m /mnt/fs2 | grep "mirrormount" && (( $? != 0 ))
# sleep 120  # assume $timeout<120, then check if it has been unmounted automatically
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: mirrormnt_automnt002
DESCRIPTION: check only the directory, for which a direct map is defined, is
             mounted automatically by automounter instead of mirror-mount, but
             other directories are mirror-mounted, then check they can be
             mounted again after unmounting automatically
# has a direct map:
#     /mnt/fs2/fs3 -$mntopts $server:/export/fs1/fs2/fs3
# automount -t $timeout
# ls -l /mnt/fs2/fs3/fs4
# nfsstat -m /mnt/fs2 | grep "mirrormount" && (( $? == 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? == 0 )) # it is mounted indeed
# nfsstat -m /mnt/fs2/fs3 | grep "mirrormount" && (( $? != 0 ))
                                                           # but isn't a mirror-mount
# nfsstat -m /mnt/fs2/fs3/fs4 | grep "mirrormount" && (( $? == 0 ))
# sleep 120  # assume $timeout<120, then check if they all have been unmounted automatically
# mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))
# cat /mnt/fs2/fs3/fs4/file5
# nfsstat -m /mnt/fs2 | grep "mirrormount" && (( $? == 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? == 0 )) # it is mounted indeed
# nfsstat -m /mnt/fs2/fs3 | grep "mirrormount" && (( $? != 0 ))
                                                           # but isn't a mirror-mount
# nfsstat -m /mnt/fs2/fs3/fs4 | grep "mirrormount" && (( $? == 0 ))
# umount /mnt/fs2    # unmount the mirror-mount point manually
# mount | grep "^/mnt/fs2/fs3/fs4 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2/fs3 on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: mirrormnt_automnt003
DESCRIPTION: check the target directory is mounted successfully if access
             directory under /net, but it is not mirror-mount, and the new
             shared filesystem is mirror-mounted if it is shared after the
             client automounter has first enumerated the list of
             server-shared filesystems

# ls /net/$SERVER/$FUNC_SHR/fs1/fs2
# mount | grep "^/net/$SERVER/$FUNC_SHR/fs1/fs2 on " && (( $? == 0 ))
# nfsstat -m /net/$SERVER/$FUNC_SHR/fs1/fs2 | grep "mirrormount" && (( $? != 0 ))
# in server: share /export/fs1/fs2_noshare
# ls /net/$SERVER/$FUNC_SHR/fs1/fs2_notshare
# mount | grep "^/net/$SERVER/$FUNC_SHR/fs1/fs2_notshare on " && (( $? == 0 ))
# nfsstat -m /net/$SERVER/$FUNC_SHR/fs1/fs2_notshare | grep "mirrormount" && (( $? == 0 ))


################################################################################
        for shared filesystem changes - new shared fs or unshared old fs
################################################################################

ID: namespc_change001
DESCRIPTION: check the new shared filesystem in server is visible
             to client immediately, and it is invisible if deleted
# ls -d /mnt/fs2/fs3_newfs && (( $? != 0 )) # no such fs yet,
                                            # only /mnt/fs2 is mirror-mounted
# nfsstat -m /mnt/fs2 | grep "mirrormount" && (( $? == 0 ))
# in server: create fs /export/fs1/fs2/fs3_newfs and share it
# ls -d /mnt/fs2/fs3_newfs && (( $? == 0 )) # the new fs is visible
# ls -l /mnt/fs2/fs3_newfs                  # the new fs will be mirror-mounted
# nfsstat -m /mnt/fs2/fs3_newfs | grep "mirrormount" && (( $? == 0 ))
# in server: unshare /export/fs1/fs2/fs3_newfs and delete this filesystem
# ls -d /mnt/fs2/fs3_newfs && (( $? != 0 )) # will print error message(No such file or directory)
# umount /mnt/fs2
# mount | grep "^/mnt/fs2/fs3_newfs on " && (( $? != 0 ))
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: namespc_change002
DESCRIPTION: check the file under the unshared filesystem in server is not
             accessible to client immediately
# cd /mnt/fs2/fs3/fs4
# cat /mnt/fs2/fs3/file4 && (( $? == 0 ))
# in server: unshare /export/fs1/fs2/fs3
# cat /mnt/fs2/fs3/file4 && (( $? != 0 ))
# umount /mnt/fs2

ID: namespc_change003
DESCRIPTION: check the changes to the share options will take effect to client
             immediately
# ls /mnt/fs2/fs3/fs4
# echo "This file is writable now" >> /mnt/fs2/fs3/file4  && (( $? == 0 ))
# in server: reshare /export/fs1/fs2/fs3 with different options(-o ro)
# echo "This file is read-only now" >> /mnt/fs2/fs3/file4 && (( $? != 0 ))
# umount /mnt/fs2


################################################################################
        for inheritance of mount properties and security
################################################################################

ID: inherit_opts_pos001
DESCRIPTION: check the target directory is mounted successfully with the same
             mount options as its parent directory
# eg: mntopts="ro,sec=none"
# mount -F nfs -o $mntopts,vers=4 $server:/export/fs1/fs2 /mnt
# ls -l /mnt/fs2/fs3                              # fs2 will be mirror-mounted
# echo "fs3 should be read-only too" > /mnt/fs2/fs3/rofs.new && (( $? != 0 ))
# nfsstat -m /mnt/fs2/fs3 | grep "Flags:" | grep "sec=none"

ID: inherit_opts_pos002
DESCRIPTION: check even with unmatched share/mount options, the target directory
             still can be mounted successfully if client can talk with server
             with the specific security mode of the shared filesystem
# eg: mntopts="rw,sec=sys"
# in server:
#     share -F nfs -o "rw,sec=sys" /export/fs1 # only this has matched share/mount options
#     share -F nfs -o "rw,sec=krb5" /export/fs1/fs2
#     share -F nfs -o "rw,sec=krb5i" /export/fs1/fs2/fs3
#     share -F nfs -o "rw,sec=krb5p" /export/fs1/fs2/fs3/fs4
# in client:
#     mount -F nfs -o $mntopts,vers=4 $server:/export/fs1 /mnt
#     ls -l /mnt/fs2/fs3/fs4
#     nfsstat -m /mnt/fs2/fs3/fs4 | grep "mirrormount" && (( $? == 0 ))
#     nfsstat -m /mnt/fs2/fs3/fs4 | grep "Flags:" | grep "sec=krb5"
#     nfsstat -m /mnt/fs2/fs3 | grep "mirrormount" && (( $? == 0 ))
#     nfsstat -m /mnt/fs2/fs3 | grep "Flags:" | grep "sec=krb5i"
#     nfsstat -m /mnt/fs2 | grep "mirrormount" && (( $? == 0 ))
#     nfsstat -m /mnt/fs2 | grep "Flags:" | grep "sec=krb5p"
# NOTE: client supports krb5, krb5i and krb5p, so once mount /mnt/fs2/fs3 fails
#       for the first time, mirror-mount will try to mount it with krb5i(share
#       option of /export/fs1/fs2/fs3) by re-negotiation.

ID: inherit_opts_neg001
DESCRIPTION: check with unmatched share/mount options, the target directory
             will not be mounted if client does not support the specific
             security mode of the shared filesystem
# eg: mntopts="ro,sec=sys"
# in server:
#     share -F nfs -o "ro,sec=sys" /export/fs1 # only this has matched share/mount options
#     share -F nfs -o "ro,sec=krb5p" /export/fs1/fs2
#     share -F nfs -o "ro,sec=krb5i" /export/fs1/fs2/fs3
#     share -F nfs -o "ro,sec=krb5" /export/fs1/fs2/fs3/fs4
#     share -F nfs -o "ro,sec=none" /export/fs1/fs2/fs3/fs4/fs5
# in client:
#     mount -F nfs -o $mntopts,vers=4 $server:/export/fs1 /mnt
#     ls -l /mnt/fs2/fs3/fs4/fs5
#     nfsstat -m /mnt/fs2/fs3/fs4/fs5 | grep "mirrormount" && (( $? == 0 ))
#     nfsstat -m /mnt/fs2/fs3/fs4 | grep "mirrormount" && (( $? != 0 ))
#     nfsstat -m /mnt/fs2/fs3 | grep "mirrormount" && (( $? != 0 ))
#     nfsstat -m /mnt/fs2 | grep "mirrormount" && (( $? != 0 ))
# NOTE: only the last directory is mounted if client does not support
#       krb5, krb5i and krb5p


################################################################################
        for negative tests with v2/v3 mounts
################################################################################

ID: v2mount_neg001
DESCRIPTION: check the target directory will not be mounted if its parent
             filesystem is mounted with "vers=2" manually
# mount -F nfs -o $mntopts,vers=2 $server:/export/fs1 /mnt
# ls /mnt/fs2    # empty dir and no mirror-mount occurs
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: v3mount_neg001
DESCRIPTION: check the target directory will not be mounted if its parent
             filesystem is mounted with "vers=3" manually
# mount -F nfs -o $mntopts,vers=3 $server:/export/fs1 /mnt
# ls -l /mnt/fs2    # empty dir and no mirror-mount occurs
# mount | grep "^/mnt/fs2 on " && (( $? != 0 ))

ID: mount_root001
DESCRIPTION: check the target directory is mounted successfully if its parent
             filesystem is mounted with root "/" manually
# mount -F nfs -o $mntopts,vers=4 $server:/ /mnt
# ls -l /mnt/$FUNC_SHR/fs1
# mount | grep "^/mnt/fs1 on " && (( $? == 0 ))

ID: mount_url001
DESCRIPTION: check the target directory is mounted successfully if its parent
             filesystem is url mounted manually
# mount -F nfs -o $mntopts,vers=4 nfs://$server/ /mnt
# ls -l /mnt/$FUNC_SHR/fs1
# mount | grep "^/mnt/fs1 on " && (( $? == 0 ))


################################################################################
        for stress test with lots of mirror mounts and automounts together
################################################################################

ID: stress_001
DESCRIPTION: check all shared filesystems will be mounted automatically if
             access the root mount point with "ls -lR"
# server has following 100 shared filesystems under $BASEDIR/stress/ directory:
# fs00 fs01 fs02 fs03 fs04 fs05 fs06 fs07 fs08 fs09
#      fs10 fs11 fs12 fs13 fs14 fs15 fs16 fs17 fs18 fs19
#           fs20 fs21 fs22 fs23 fs24 fs25 fs26 fs27 fs28 fs29
#                fs30 fs31 fs32 fs33 fs34 fs35 fs36 fs37 fs38 fs39
#                     fs40 fs41 fs42 fs43 fs44 fs45 fs46 fs47 fs48 fs49
#                          fs50 fs51 fs52 fs53 fs54 fs55 fs56 fs57 fs58 fs59
#                               fs60 fs61 fs62 fs63 fs64 fs65 fs66 fs67 fs68 fs69
#                                    fs70 fs71 fs72 fs73 fs74 fs75 fs76 fs77 fs78 fs79
#                                         fs80 fs81 fs82 fs83 fs84 fs85 fs86 fs87 fs88 fs89
#                                              fs90 fs91 fs92 fs93 fs94 fs95 fs96 fs97 fs98 fs99
# NOTE:  there will have lots of mirror-mounts and automounts together
# client:
#  mount -F nfs -o $mntopts,vers=4 $server:$STRESS_SHR $STRESS_MNT
#  ls -lR $STRESS_MNT


################################################################################
        for performance test compared to automount
################################################################################

ID: perf_001
DESCRIPTION: check there is no performance degradation compared to automount of
             the same mount directory tree
# - use the longest path of stress test directly: .../stress/fs00/fs10/fs20/fs30/
#   fs40/fs50/fs60/fs70/fs80/fs90/fs91/fs92/fs93/fs94/fs95/fs96/fs97/fs98/fs99
# - record the mount time taken for each level of directory with mirror-mount and
#   auto-mount seperately, and compare the times one by one to make sure that the
#   mirror-mount does not take more time than auto-mount
# - all times are captured by dtrace script, so they are nanosecond values:
#   for auto-mount: calculate the execution time of auto_trigger_mount function
#   for mirror-mount: calculate the execution time of nfs4_trigger_mount function