2N/A#ident "%Z%%M% %I% %E% SMI" mwc
2N/AThe contents of this file are subject to the terms of the
2N/ACommon Development and Distribution License, Version 1.0 only
2N/A(the "License"). You may not use this file except in compliance
2N/ASee the License for the specific language governing permissions
2N/Aand limitations under the License.
2N/AWhen distributing Covered Code, include this CDDL HEADER in each
2N/AIf applicable, add the following below this CDDL HEADER, with the
2N/Afields enclosed by brackets "[]" replaced with your own identifying
2N/Ainformation: Portions Copyright [yyyy] [name of copyright owner]
2N/A Enterprise: Public Layer Test Specification
2N/A ===========================================
2N/A This document describes a test specification intended to be used
2N/Ain the development of tests designed to validate the service provider
2N/Alayer API described in Section 2.2 of the Enterprise DHCP Service
2N/AArchitecture Specification (ARCH) [1]. The first test is a basic sanity
2N/Atest, designed to verify that the API works as designed when fed data
2N/Ain the correct form. The second test is a full test, which compliments
2N/Athe basic sanity test by providing cases which test the stability and
2N/AMT-safeness of the API.
2N/A Test suite(s) written to this specification should be run on
2N/Aevery available public module on the reference platform of each of the
2N/Asupported architectures (sparcv8, sparcv9, IA32, IA64) for each build
2N/Aof the ON consolidation. See "Enterprise Reference platforms" [2] for
2N/A The packages SUNWdhc{df,db,dn} containing the public module(s)
2N/Aunder test. The data service(s) (if necessary) which hosts the data
2N/Astore must be configured and running. A data store container directory
2N/A(location) within the data service must exist and be empty. The machine
2N/Aunder test must have the appropriate authorization (root user) for
2N/Aaccessing the hosting data service. Note that it is important to note
2N/Awhether the data service is hosted on the test machine, or whether the
2N/Adata service is hosted on a different machine and the machine under
2N/Atest is a client of that data service. Where the data service is hosted
2N/Awill have an affect on the test results, particularly performance.
2N/A This test validates the basic operation of service
2N/A provider layer API function calls when presented with valid
2N/A arguments in a valid run environment. It is implemented as a
2N/A multithreaded program running a single thread to exercise the API
2N/A referenced in Section 2.2 of ARCH [1]. This program should create
2N/A dhcptab and dhcp network containers within the data store, and
2N/A exercise the *_dt and *_dn calls to add, modify, and delete
2N/A multiple records. The result of the add, modify, and delete
2N/A operations must be validated between each operation. The program
2N/A should be written such that the initial condition described under
2N/A TEST PREPARATION is restored. Operations are
PASS/FAIL, and must
2N/A be compared against a human-verified expect file.
2N/A Item Description Application
2N/A ==== =========== ===========
2N/A <location> Public module specific status, list,
2N/A path name to container open_dt,
2N/A for 'files' data store). open_dn,
2N/A <Server IP> System under test's IP N/A
2N/A dt records As follows: *_dt
2N/A Locale m :UTCoffst=-18000:
2N/A Solaris m :SrootIP4=129.148.174.27:SrootNM="atlantic": \
2N/A :SinstIP4=129.148.174.27:SinstNM="atlantic": \
2N/A :Sterm="xterm":BootSrvA=129.148.174.27:
2N/A sun4u m :Include=Solaris:Include=sparc:
2N/A 172.21.0.0 m :Subnet=255.255.0.0:Router=172.21.0.2: \
2N/A :Broadcst=172.21.255.255:
2N/A atlantic m :Include=Locale:Timeserv=129.148.174.27:LeaseTim=3600: \
2N/A :DNSserv=172.21.0.1:
2N/A 010800207E8A02 m :Impress=172.22.255.27:
2N/A 172.21.0.0 Dhcp network container. *_dn
2N/A dn records ~3000, as follows: *_dn
2N/A 00 00 172.21.0.6 <Server IP> 0 atlantic
2N/A 00 00 172.21.12.6 <Server IP> 0 atlantic
2N/A Generic Data Store Status
2N/A =========================
2N/A Call function with <location>. PASS if DSVC_SUCCESS is
2N/A returned, FAIL otherwise. If this case fails, abort the test.
2N/A Call function. Version value returned must be one (1)
2N/A for PASS. If this case fails, abort the test.
2N/A Call function. Compare returned capability against
2N/A confirmed capability known for the public module under test.
2N/A Call function with <location>. PASS if DSVC_NOENT is
2N/A returned, listppp is NULL, and count is set to 0. As part of
2N/A Test preparation, there should be *no* containers of any kind in
2N/A the underlying data service of the public module. If this case
2N/A fails, abort the test.
2N/A dhcptab Container API
2N/A =====================
2N/A Case #5 alloc_dtrec:
2N/A Call function, verify that a non-NULL dt_rec_t pointer
2N/A is returned. Free result with free_dtrec.
2N/A Create a dhcptab at <location> specifying DSVC_CREATE |
2N/A DSVC_READ | DSVC_WRITE. Preserve handpp for use in the following
2N/A cases. PASS if DSVC_SUCCESS is returned, abort the test
2N/A 7.1. Initialize container.
2N/A Using the handle returned in case #6, add the
2N/A dhcptab test records to the dhcptab. Verify that the
2N/A dhcptab exists by calling list.
2N/A 7.2. Attempt to add duplicate record.
2N/A Attempt to add the SbootRS symbol definition and
2N/A 172.21.0.0 macro definition to the dhcptab container.
2N/A PASS if DSVC_EXISTS is returned in both cases.
2N/A 8.1. Verify case #7.
2N/A Using a count value of -1 and a "query" value
2N/A initialized by DSVC_QINIT (Figure 5 of ARCH[1]), verify
2N/A that the contents of the dhcptab container match the
2N/A test data. Note that the order of the records returned
2N/A may not be the same as the order in which they were
2N/A 8.2 Verify dhcptab container type.
2N/A 8.2.1. Look for all records with a DT_QTYPE
2N/A value of "s". Verify that only the "s" type
2N/A records are returned.
2N/A 8.2.2. Look for all records with a DT_QTYPE
2N/A value of "m". Verify that only the "m" type
2N/A records are returned.
2N/A 8.2.3. Look for DT_QKEY of "atlantic". Verify
2N/A that only the macro "atlantic" is returned, and
2N/A the value is correct.
2N/A 8.2.4. Look for DTQKEY of i86pc and not a
2N/A DT_QTYPE of "m". Verify that only the macro
2N/A "i86pc" is returned.
2N/A 9.1 Modify dhcptab container records
2N/A 9.1.1. Using lookup_dt to find the record with a
2N/A DT_QKEY of "Sterm", change the name of the
2N/A record from "Sterm" to "sTERM". Use lookup_dt to
2N/A verify that the original record has been
2N/A 9.1.2. Using lookup_dt to find the record with a
2N/A DT_QKEY of "Solaris", change the value portion
2N/A of the record to be:
2N/A :SrootIP4=129.148.174.27:SrootNM="atlantic": \
2N/A :SinstIP4=129.148.174.27:SinstNM="atlantic": \
2N/A :sTERM="sun-cmd":BootSrvA=129.148.174.27:
2N/A Using lookup_dt, reexecute the lookup and verify
2N/A that the value portion of the record has been
2N/A Using lookup_dt to find the record with a DT_QKEY of
2N/A this record can no longer be found (DSVC_NOENT).
2N/A Close the open instance of the dhcptab container. Verify
2N/A that close_dt returns DSVC_SUCCESS.
2N/A Remove the dhcptab container. Verify that it no longer
2N/A dhcp network Container API
2N/A ==========================
2N/A Using DSVC_CREATE | DSVC_READ | DSVC_WRITE, create a
2N/A dhcp network container (called <network address>). Preserve the
2N/A handle returned for later use in the following test cases. PASS
2N/A if DSVC_SUCCESS is returned, terminate the test otherwise.
2N/A Verify that the dhcp network container exists using list.
2N/A 14.1. Initialize container.
2N/A Using the handle returned in case #13, add the
2N/A dhcp network test records to the dhcp network container.
2N/A Verify that the dhcp network container exists by
2N/A 14.2. Attempt to add duplicate record.
2N/A Attempt to add the 172.21.0.254 client record
2N/A to the <network address> dhcp network container. PASS
2N/A if DSVC_EXISTS is returned.
2N/A 15.1. Verify case #14.
2N/A Using a "count" of -1 and a "query" value
2N/A initialized using DSVC_QINIT (Figure 5 of ARCH[1]),
2N/A verify that the contents of the <network address>
2N/A container match the test data. "records" should equal
2N/A the number of records added in case #14. Note that the
2N/A order of the records returned may not be the same as the
2N/A order in which they were added in case #14.
2N/A 15.2. Verify <network address> dhcp network container
2N/A 15.2.1. Look for all records with a DN_QCIP of
2N/A <network address>+100. Verify that only one
2N/A record (with a cip of <network address>+100 is
2N/A 15.2.2. Look for all records with a DN_QMACRO
2N/A value of "atlantic". Verify that all records
2N/A are returned ("records" == 3000). Note that the
2N/A records returned may not be in the same order in
2N/A which they were added as part of case #14.
2N/A 16.1. Using lookup_dn to find the record with a DN_QCIP
2N/A of <network address>+10, change the lease field to
2N/A 1/1/2000 and the flags field to MANUAL. Use lookup_dn to
2N/A verify that the original record has been changed.
2N/A 16.2. Using lookup_dn to find the record with a
2N/A DN_QFLAGS of MANUAL. Change the dn_cid field to
2N/A 01080020FFFFFF, dn_flags field to MANUAL+AUTOMATIC,
2N/A dn_sip field to 172.23.0.77, dn_lease field to -1,
2N/A dn_macro field to "happy", and the dn_comment field to
2N/A "This is a test". Use lookup_dn to verify that the
2N/A original record has been changed correctly.
2N/A Using lookup_dn to find the record with a DN_QCIP of
2N/A <network address>+101, delete this record. Verify using
2N/A lookup_dn that this record can no longer be found.
2N/A Close the open instance of the dhcp network container
2N/A <network address>. Verify that close_dn returns DSVC_SUCCESS.
2N/A Remove the dhcp network container <network address>.
2N/A Verify that the container is in fact gone using list.
2N/A This suite verifies that the dhcptab and dhcp network
2N/A table API function calls respond correctly when presented with
2N/A incorrect data. It also validates the MT-safeness of the API.
2N/A The test suite should allow any number of concurrent threads or
2N/A test suite processes to be invoked. The data must remain
2N/A consistent as measured at certain points during the test in
2N/A order for the test to be considered to have passed successfully.
2N/A Item Description Application
2N/A ==== =========== ===========
2N/A <location> Public module specific status, list,
2N/A path name to container open_dt,
2N/A for 'files' data store). open_dn,
2N/A <Server IP> System under test's IP N/A
2N/A dt records As follows: *_dt
2N/A Locale m :UTCoffst=-18000:
2N/A Solaris m :SrootIP4=129.148.174.27:SrootNM="atlantic": \
2N/A :SinstIP4=129.148.174.27:SinstNM="atlantic": \
2N/A :Sterm="xterm":BootSrvA=129.148.174.27:
2N/A sun4u m :Include=Solaris:Include=sparc:
2N/A 172.21.0.0 m :Subnet=255.255.0.0:Router=172.21.0.2: \
2N/A :Broadcst=172.21.255.255:
2N/A atlantic m :Include=Locale:Timeserv=129.148.174.27:LeaseTim=3600: \
2N/A :DNSserv=172.21.0.1:
2N/A 010800207E8A02 m :Impress=172.22.255.27:
2N/A 172.21.0.0 Dhcp network container. *_dn
2N/A dn records ~3000, as follows: *_dn
2N/A 00 00 172.21.0.6 <Server IP> 0 atlantic
2N/A 00 00 172.21.12.6 <Server IP> 0 atlantic
2N/A Disable the underlying data service. How this is done
2N/A is data service-dependent. Call each of status, version,
2N/A capability, list, open_dt, remove_dt, open_dn, and remove_dn.
2N/A PASS if the function returns DSVC_INTERNAL or
2N/A DSVC_MODULE_ERROR. What is returned is data service-specific. If
2N/A this test FAILs (
e.g. a function returns DSVC_SUCCESS, terminate
2N/A Cleanup: Reenable the underlying data service.
2N/A dhcptab Container API
2N/A =====================
2N/A 2.1. Invalid Location
2N/A Call function with an invalid <location>. PASS
2N/A if DSVC_INVAL is returned. If this case fails, abort
2N/A Verify that list returns DSVC_NOENT.
2N/A Call function with DSVC_READ | DSVC_WRITE.
2N/A Verify that DSVC_NOENT is returned.
2N/A Using DSVC_CREATE | DSVC_READ | DSVC_WRITE,
2N/A call open_dt to create a dhcptab container. Call
2N/A close_dt to close the handle. Call open_dt with
2N/A DSVC_READ | DSVC_WRITE | DSVC_NONBLOCK. Depending on
2N/A whether the public module supports it (see module doc),
2N/A the function should return either DSVC_SUCCESS or
2N/A DSVC_UNSUPPORTED. If NON_BLOCK access is supported,
2N/A endeavor to make the underlying service temporarily
2N/A unavailable (
e.g: NIS+: checkpoint the database). Call
2N/A open_dt again with the same flags (read, write,
2N/A nonblock). open_dt must fail and return DSVC_BUSY.
2N/A Cleanup: re-enable underlying service, close the open
2N/A 3.3. Container exists
2N/A Call function with DSVC_CREATE | DSVC_READ |
2N/A DSVC_WRITE. Verify that the function returns
2N/A Cleanup: remove the dhcptab container using remove_dt.
2N/A Create and load the dhcptab as per Case #6 and Case #7.1
2N/A of the Basic Sanity Test.
2N/A Attempt to add a test dhcptab record to the
2N/A dhcptab. Verify that DSVC_EXISTS is returned.
2N/A Close open handle with close_dt. Reopen with
2N/A DSVC_NONBLOCK specified. If nonblocking semantics are
2N/A supported, then make the data service busy through the
2N/A use of a data service-specific technique and attempt to
2N/A add an additional dhcptab record. Verify that DSVC_BUSY
2N/A is returned. Remove the data service busy condition and
2N/A reattempt the add operation. Verify that DSVC_SUCCESS is
2N/A returned. close_dt the container.
2N/A Close any open handles. Reopen the dhcptab with
2N/A DSVC_READ access only. If success is returned, attempt
2N/A to add a new record to the dhcptab. Verify that
2N/A DSVC_ACCESS is returned. close_dt the handle. Note that
2N/A some data store modules may return DSVC_UNSUPPORTED for
2N/A Cleanup: Close open handles, remove the dhcptab using
2N/A Create and load the dhcptab as per Case #6 and Case #7.1
2N/A of the Basic Sanity Test.
2N/A 5.1. Record does not exist.
2N/A Produce a dhcptab container query that would not
2N/A be satisfied by the test data. Verify that DSVC_SUCCESS
2N/A is returned, and "records" is 0.
2N/A Close dhcptab handle with close_dt. Reopen with
2N/A DSVC_NONBLOCK specified. IF DSVC_SUCCESS is returned
2N/A (Nonblocking access is supported), using a data
2N/A service-specific technique for making the service busy,
2N/A attempt to perform a valid lookup of a dhcptab record.
2N/A Verify that DSVC_BUSY is returned. Remove the busy
2N/A condition, and reattempt the lookup. Verify that
2N/A DSVC_SUCCESS is returned, and that the data returned is
2N/A valid. close_dt the handle.
2N/A Reopen the dhcptab container with DSVC_WRITE
2N/A access only. If success is returned, attempt to perform
2N/A lookup_dt's using any syntactically legal query for the
2N/A dhcptab. Verify that DSVC_ACCESS is returned. close_dt
2N/A 5.4. Multiple matching records
2N/A Reopen the dhcptab container as per case
2N/A #6 and case #7.1 of the Basic Sanity Test. Using
2N/A modify_dt, change the dt_key for the SrootOpt symbol
2N/A such that the key value is now sun4u. Form a query which
2N/A simply specifies a DT_QKEY value of "sun4u". Verify that
2N/A exactly two records are returned, and that there values
2N/A are what is expected (one a macro, the other a symbol,
2N/A with the appropriate values).
2N/A Cleanup: Remove the dhcptab container using remove_dt.
2N/A Create and load the dhcptab container as per Case #6
2N/A and Case #7.1 of the Basic Sanity Test.
2N/A Fabricate dt_rec_t elements initialized with
2N/A data known not to exist in the dhcptab. Attempt to
2N/A modify these elements. Verify that DSVC_NOENT is
2N/A 6.2. Update Collision #1
2N/A Use lookup_dt to find a valid dhcptab record.
2N/A Change the signature on the resultant dt_rec_t. Attempt
2N/A to modify the record. Verify that DSVC_COLLISION is
2N/A 6.3. Update Collision #2
2N/A Use lookup_dt to find a valid dhcptab record.
2N/A Attempt to rename the record to one that already exists
2N/A (dt_key + dt_type). Verify that DSVC_EXISTS is returned.
2N/A Close the dhcptab with close_dt. Reopen with
2N/A DSVC_NONBLOCK specified. If DSVC_SUCCESS is returned (it
2N/A is supported), acquire a valid dhcptab record using
2N/A lookup_dt. Using a data service specific technique for
2N/A making the service busy, attempt to modify the value
2N/A (non-key fields) of the record. Verify that DSVC_BUSY is
2N/A returned. Remove the busy condition, and reattempt the
2N/A modify. Verify that DSVC_SUCCESS is returned.
2N/A Reacquire the record. Verify that the contents have been
2N/A suitably updated. close_dt the container.
2N/A Reopen the dhcptab with DSVC_READ access only.
2N/A If success is returned, locate a valid container record
2N/A using the appropriate query to lookup_dt. Modify the
2N/A contents of the record. Attempt to commit the modify to
2N/A the dhcptab. Verify that DSVC_ACCESS is returned.
2N/A close_dt the dhcptab handle.
2N/A Cleanup: Remove the dhcptab using remove_dt.
2N/A Case #7 free_dtrec_list:
2N/A This function should be used to release the results of
2N/A lookup_dt calls. Its operation must be validated by running this
2N/A test under bcheck with -memuse, and ensuring that no free blocks
2N/A remain after exit. Note that the test must be written with care
2N/A to make this case useful (free any allocated memory when it is
2N/A Create and load the dhcptab container as per Case #6 and
2N/A Case #7.1 of the Basic Sanity Test.
2N/A Fabricate dt_rec_t containing a record known
2N/A not to exist in the dhcptab. Attempt to delete the
2N/A record. Verify that DSVC_NOENT is returned.
2N/A Close the dhcptab with close_dt. Reopen with
2N/A DSVC_NONBLOCK specified. If DSVC_SUCCESS is returned,
2N/A acquire a valid dhcptab container record using
2N/A lookup_dt. Using a data service specific technique for
2N/A making the service busy, attempt to delete the record.
2N/A Verify that DSVC_BUSY is returned. Remove the busy
2N/A condition, and reattempt the delete. Verify that
2N/A DSVC_SUCCESS is returned. Attempt to reacquire the
2N/A record. Verify that the record has in fact been deleted.
2N/A Close the dhcptab using close_dt.
2N/A Reopen the dhcptab container with DSVC_READ
2N/A access only. If success is returned, locate a valid
2N/A dhcptab record using an appropriate query to lookup_dt.
2N/A Attempt to delete the record. Verify that DSVC_ACCESS is
2N/A returned. Close the dhcptab using close_dt.
2N/A Cleanup: Remove the dhcptab using remove_dt.
2N/A Verify that this function handles nonblocking semantics
2N/A correctly. Create a dhcptab as per case #6 of the Basic Sanity
2N/A Test, with the exception that DSVC_NONBLOCK is specified. If
2N/A nonblocking mode is supported, then using a data service
2N/A specific technique for making the service busy, attempt to close
2N/A the dhcptab handle returned by open_dt. Verify that DSVC_BUSY
2N/A is returned. Remove the busy condition, and reattempt the
2N/A close_dt. Verify that DSVC_SUCCESS is returned.
2N/A Cleanup: Remove the dhcptab container using remove_dt.
2N/A Verify that this function handles nonblocking semantics
2N/A correctly. Create a dhcptab container as per Case #6 of the Basic
2N/A Sanity Test. Close open handle using close_dt. Reopen with
2N/A DSVC_NONBLOCK specified. If nonblocking mode is supported, using
2N/A a data service specific technique for making the service busy,
2N/A attempt to remove the dhcptab container. Verify that DSVC_BUSY is
2N/A returned. Remove the busy condition, and reattempt the remove.
2N/A Verify that the dhcptab container is removed using list and that
2N/A the function returns DSVC_SUCCESS.
2N/A Cleanup: Close the open handle using close_dt (ignore result).
2N/A dhcp network Container API
2N/A ==========================
2N/A 11.1. Invalid Location
2N/A Call function with an invalid <location>. PASS
2N/A if DSVC_INVAL is returned. If this case fails, abort
2N/A Verify that list returns DSVC_NOENT.
2N/A Call function with DSVC_READ | DSVC_WRITE and
2N/A <network address>. Verify that DSVC_NOENT is returned.
2N/A Using the flag values of DSVC_CREATE |
2N/A DSVC_READ | DSVC_WRITE | DSVC_NONBLOCK, the function
2N/A to create a dhcp network container called <network
2N/A address>. Depending on whether the public module
2N/A supports nonblocking semantics (see module doc),
2N/A the function should return either DSVC_SUCCESS or
2N/A DSVC_UNSUPPORTED. If NON_BLOCK access is supported,
2N/A endeavor to make the underlying service temporarily
2N/A unavailable (
e.g: NIS+: checkpoint the database). Call
2N/A open_dn again with the same flags (read, write,
2N/A nonblock). open_dn must fail and return DSVC_BUSY.
2N/A Cleanup: re-enable underlying service, close the open
2N/A 12.3. Container exists.
2N/A Using the flag values DSVC_CREATE | DSVC_READ |
2N/A DSVC_WRITE, attempt to open <network address>. Verify
2N/A that the function returns DSVC_EXISTS.
2N/A Cleanup: Remove the <network address> dhcp network
2N/A container using remove_dn.
2N/A Create and load the <network address> dhcp network
2N/A container as per Case #13 and Case #14.1 of the Basic Sanity
2N/A Attempt to add a test dhcp network record to
2N/A the <network address> dhcp network container. Verify
2N/A that DSVC_EXISTS is returned.
2N/A Close open handle with close_dn. Reopen with
2N/A DSVC_NONBLOCK specified. If nonblocking semantics are
2N/A supported, then make the data service busy through the
2N/A use of a data service-specific technique and attempt to
2N/A add an additional dhcp network record. Verify that
2N/A DSVC_BUSY is returned. Remove the data service busy
2N/A condition and reattempt the add operation. Verify that
2N/A DSVC_SUCCESS is returned. close_dn the container.
2N/A Close any open handles. Reopen the <network
2N/A address> dhcp network container with DSVC_READ access
2N/A only. If success is returned, attempt to add a new
2N/A record to the dhcp network container. Verify that
2N/A DSVC_ACCESS is returned. close_dn the handle. Note that
2N/A some data store modules may return DSVC_UNSUPPORTED for
2N/A Cleanup: Close open handles, remove the <network
2N/A address> dhcp network container using remove_dn.
2N/A Create and load the <network address> dhcp network
2N/A container as per Case #13 and Case #14.1 of the Basic Sanity
2N/A 14.1. Record does not exist.
2N/A Produce a dhcp network container query that
2N/A would not be satisfied by the test data. Verify that
2N/A DSVC_SUCCESS is returned, and "records" is 0.
2N/A Close the <network address> dhcp network handle
2N/A with close_dn. Reopen with DSVC_NONBLOCK specified. If
2N/A DSVC_SUCCESS is returned (Nonblocking access is
2N/A supported), using a data service-specific technique for
2N/A making the service busy, attempt to perform a valid
2N/A lookup of a dhcp network record. Verify that DSVC_BUSY
2N/A is returned. Remove the busy condition, and reattempt
2N/A the lookup. Verify that DSVC_SUCCESS is returned, and
2N/A that the data returned is valid. close_dn the handle.
2N/A Reopen the dhcp network container with DSVC_WRITE
2N/A access only. If success is returned, attempt to perform
2N/A lookup_dn's using any syntactically legal query for the
2N/A <network address> dhcp network container. Verify that
2N/A DSVC_ACCESS is returned. close_dn the handle.
2N/A 14.4. Multiple matching records
2N/A Reopen the dhcp network container as per case
2N/A #13 and case #14.1 of the Basic Sanity Test. Using
2N/A modify_dn, change the dn_cid fields for records <network
2N/A address>+1 through <network address>+217 to 01BADDCAFE.
2N/A Form a query which simply specifies a DN_QCID of
2N/A 01BADDCAFE. Confirm that exactly 216 records are
2N/A returned, and that their CIP range is correct.
2N/A Cleanup: Remove the <network address> dhcp network
2N/A container using remove_dn.
2N/A Create and load the <network address> dhcp network
2N/A container as per Case #13 and Case #14.1 of the Basic Sanity
2N/A 15.1. Unknown record
2N/A Fabricate dn_rec_t elements initialized with
2N/A data known not to exist in the dhcp network container.
2N/A Attempt to modify these elements. Verify that DSVC_NOENT
2N/A 15.2. Update Collision #1
2N/A Use lookup_dn to find a valid dhcp network record.
2N/A Change the signature on the resultant dn_rec_t. Attempt
2N/A to modify the record. Verify that DSVC_COLLISION is
2N/A 15.3. Update Collision #2
2N/A Use lookup_dn to find a valid dhcp network record.
2N/A Attempt to rename the record to one that already exists
2N/A (dn_cid, dn_flags, dn_cip, dn_sip, dn_lease, dn_macro).
2N/A Verify that DSVC_EXISTS is returned.
2N/A Close the dhcp network container with close_dn.
2N/A Reopen with DSVC_NONBLOCK specified. If DSVC_SUCCESS is
2N/A returned (nonblocking semantics are supported), acquire
2N/A a valid dhcp network record using lookup_dn. Using a
2N/A data service specific technique for making the service
2N/A busy, attempt to modify the value (non-key fields) of
2N/A the record. Verify that DSVC_BUSY is returned. Remove
2N/A the busy condition, and reattempt the modify. Verify
2N/A that DSVC_SUCCESS is returned. Reacquire the record.
2N/A Verify that the contents have been suitably updated.
2N/A close_dn the container.
2N/A Reopen the dhcp network container with DSVC_READ
2N/A access only. If success is returned, locate a valid
2N/A container record using the appropriate query to
2N/A lookup_dn. Modify the contents of the record. Attempt
2N/A to commit the modify to the dhcp network container.
2N/A Verify that DSVC_ACCESS is returned. close_dn the
2N/A dhcp network container handle.
2N/A Cleanup: Remove the dhcp network container using
2N/A Case #16 free_dnrec_list:
2N/A This function should be used to release the results of
2N/A lookup_dn calls. Its operation must be validated by running this
2N/A test under bcheck with -memuse, and ensuring that no free blocks
2N/A remain after exit. Note that the test must be written with care
2N/A to make this case useful (free any allocated memory when it is
2N/A Create and load the <network address> dhcp network
2N/A container as per Case #13 and Case #14.1 of the Basic Sanity
2N/A Fabricate dn_rec_t containing a record known
2N/A not to exist in the dhcp network container. Attempt
2N/A to delete the record. Verify that DSVC_NOENT is returned.
2N/A Close the dhcp network container with close_dn.
2N/A Reopen with DSVC_NONBLOCK specified. If DSVC_SUCCESS is
2N/A returned, acquire a valid dhcp network container record
2N/A using lookup_dn. Using a data service specific technique
2N/A for making the service busy, attempt to delete the record.
2N/A Verify that DSVC_BUSY is returned. Remove the busy
2N/A condition, and reattempt the delete. Verify that
2N/A DSVC_SUCCESS is returned. Attempt to reacquire the
2N/A record. Verify that the record has in fact been deleted.
2N/A Close the dhcp network container using close_dn.
2N/A Reopen the dhcp network container with DSVC_READ
2N/A access only. If success is returned, locate a valid
2N/A dhcp network record using an appropriate query to
2N/A lookup_dn. Attempt to delete the record. Verify that
2N/A DSVC_ACCESS is returned. Close the dhcp network
2N/A container using close_dn.
2N/A Cleanup: Remove the dhcp network container using
2N/A Verify that this function handles nonblocking semantics
2N/A correctly. Create the <network address> dhcp network container
2N/A as per case #13 of the Basic Sanity Test, with the exception
2N/A that DSVC_NONBLOCK is specified. If nonblocking mode is
2N/A supported, then using a data service specific technique for
2N/A making the service busy, attempt to close the dhcp network
2N/A handle returned by open_dn. Verify that DSVC_BUSY is returned.
2N/A Remove the busy condition, and reattempt the close_dn. Verify
2N/A that DSVC_SUCCESS is returned.
2N/A Cleanup: Remove the dhcp network container using remove_dn.
2N/A Verify that this function handles nonblocking semantics
2N/A correctly. Create the <network address> dhcp network container
2N/A as per Case #13 of the Basic Sanity Test, with the exception
2N/A that DSVC_NONBLOCK is specified. If nonblocking mode is
2N/A supported, using a data service specific technique for making
2N/A the service busy, attempt to remove the dhcp network container.
2N/A Verify that DSVC_BUSY is returned. Remove the busy condition,
2N/A and reattempt the remove. Verify that the <network address> dhcp
2N/A network container is removed using list and that the function
2N/A returns DSVC_SUCCESS.
2N/A Cleanup: Close the open handle using close_dn (ignore result).
2N/A Case #20 Multi-access stress
2N/A Public layer modules are not required to manage reference
2N/A counts for open instances. So while individual handles are
2N/A considered to be MT-safe (and parallel access to containers is
2N/A suitably protected), an application using the service provider
2N/A layer API must synchronize close
and/or container remove
2N/A operations among threads such that no threads hold handles to a
2N/A container after the handle has been closed or the container has
2N/A This case assumes a test which is multi-threaded, and
2N/A can run the following test using from 1 to THREADS threads. The
2N/A test can also be run in multiple concurrent processes.
2N/A The goal of this test is to ensure that the API is
2N/A MT-safe with respect to the containers and the records contained
2N/A within those containers. This goal is accomplished by verifying
2N/A that the end result of the test is consistent.
2N/A Tunable default values:
2N/A 20.1 The dhcptab container test
2N/A Create a dhcptab using DSVC_CREATE |
2N/A DSVC_READ | DSVC_WRITE. If DSVC_EXISTS is
2N/A returned, retry the open attempt w/o the
2N/A DSVC_CREATE flag. Log that this event occurred.
2N/A Handle will be used for balance of test. If any
2N/A other error occurs, terminate the test as
2N/A Add the test data records to the dhcptab
2N/A container. If DSVC_EXISTS is returned, skip that
2N/A record, and continue attempting to add the other
2N/A records. Log that this event occurred. If any
2N/A other error occurs, terminate the test as
2N/A Using DT_QKEY of "atlantic" and DT_QTYPE
2N/A of "m", find the atlantic record. Compare its
2N/A value against the test data. If it has
2N/A changed, then output a message to this affect.
2N/A If any error occurs, terminate the test as failed.
2N/A Using the results of 20.1.3, change the
2N/A record as follows. If it is no different from
2N/A the test data, change the value to:
2N/A :Timeserv=129.148.174.28:LeaseTim=86400: \
2N/A If it doesn't match the test data
2N/A value, change the LeaseTim by incrementing it by
2N/A one. Attempt to update the record. If it fails
2N/A with DSVC_COLLISION, retry 20.1.3 and 20.1.4 for
2N/A three attempts. Log message if modify was
2N/A unsuccessful. If any other error occurs,
2N/A terminate the test as failed.
2N/A Use lookup_dt to find a DT_QKEY of
2N/A "SjumpsCF" and a DT_QTYPE of "s". If it does
2N/A not exist, log a message. If it does exist,
2N/A attempt to delete it. If DSVC_NOENT is returned,
2N/A Use close_dt to close the open handle.
2N/A If DSVC_NOENT is returned, log a message.
2N/A Compare the resultant dhcptab container
2N/A to the test data. The only differences should be
2N/A a changed value of the atlantic macro as
2N/A expected from 20.1.4 and the SjumpsCF symbol
2N/A should be removed. Any other inconsistency means
2N/A the test has failed.
2N/A Clean up: Remove the dhcptab container.
2N/A 20.2 The dhcp network table container test
2N/A Create a <network address> dhcp network
2N/A table using DSVC_CREATE | DSVC_READ | DSVC_WRITE.
2N/A If DSVC_EXISTS is returned, retry the open
2N/A attempt w/o the DSVC_CREATE flag. Log that this
2N/A event occurred. Handle will be used for balance
2N/A of test. If any other error occurs, terminate
2N/A Add the test data records to the dhcp
2N/A network table container. If DSVC_EXISTS is
2N/A returned, skip that record, and continue
2N/A attempting to add the other records. Log that
2N/A this event occurred. If any other error occurs,
2N/A terminate the test as failed.
2N/A Find the DN_QCIP of <network address>+102
2N/A record. Compare its value against the test data.
2N/A If it has changed, then output a message to this
2N/A affect. If any error occurs, terminate the test
2N/A Using the results of 20.2.3, change the
2N/A record as follows. If it is no different from
2N/A the test data, change the value to:
2N/A01DEADBEEF 03 <network address>+102 172.23.3.3 941619403 Solaris
2N/A If it doesn't match the test data
2N/A value, change dn_lease by incrementing it by
2N/A one. Attempt to update the record. If it fails
2N/A with DSVC_COLLISION, retry 20.2.3 and 20.2.4 for
2N/A three attempts. Log message if modify was
2N/A unsuccessful. If any other error occurs,
2N/A terminate the test as failed.
2N/A Use lookup_dn to find a DN_QCIP of
2N/A <network address>+1001. If it does not exist,
2N/A log a message. If it does exist, attempt to
2N/A delete it. If DSVC_NOENT is returned, log a
2N/A Use close_dn to close the open handle.
2N/A If DSVC_NOENT is returned, log a message.
2N/A The <network address> dhcp network
2N/A container should be consistent at the end of
2N/A a test run. The only differences should be a
2N/A changed value of the <network address>+102
2N/A record with the value as per 20.2.4 and the
2N/A lease time potentially incremented, as well as
2N/A the <network address>+1001 record missing.
2N/A Any other inconsistency means the test has
2N/A Cleanup: remove <network address> dhcp network
2N/A 20.3 Multi-process run
2N/A Run 20.1 and 20.2 in PROCESSES separate
2N/A 20.4 Multi-threaded run, single process
2N/A Run 20.1 and 20.2 in THREADS separate threads
2N/A within a single process.
2N/A 20.5 Multi-process, Multi-threaded run
2N/A Run 20.1 and 20.2 in PROCESSES separate
2N/A processes each spawning THREADS separate threads.
2N/A This test case endeavors to probe the stability and the
2N/A performance of the public module implementation when:
2N/A a) The data storage containers are filled to capacity.
2N/A b) The data storage containers are overfilled.
2N/A Note that while the number of records within a dhcptab
2N/A container could be infinite, the number of records within a dhcp
2N/A network container is bounded by the number of possible IP
2N/A addresses within the network represented by the container. If a
2N/A class A network is represented, there can be up to 16,777,215
2N/A possible records. The total number of records supported by a
2N/A public module (with some overhead for container information) is
2N/A the upper bound. That total number could be influenced by
2N/A settings in the underlying hosting data service, or by the
2N/A available memory or disk resources of the machine under test.
2N/A Since record sizes for dhcptab and dhcp network containers
2N/A differ, discovering the maximum number of possible records
2N/A requires some dynamic experimentation by the test itself.
2N/A Call capability. The max number of possible
2N/A records for the environment under test will be contained
2N/A within the returned structure as will some estimate of
2N/A the operations per second claimed by the public module
2N/A in the run environment. A dhcptab will be created with
2N/A contains 1/3 of the maximum number of records. One or
2N/A more dhcp network containers will be created to contain
2N/A the balance of the records. A multithreaded program can
2N/A create the containers and load them with single threads,
2N/A one for each container. A consistent series of records
2N/A must be added to the dhcptab (monotonically increasing
2N/A symbol / macro records created, each with unique value
2N/A portions which could be calculated by the key fields of
2N/A the record). dhcp network container records simply contain
2N/A records unique by client IP address.
2N/A Initialization will stop when no more records can be
2N/A added to the system (XXX - what sort of error code would
2N/A be returned? DSVC_INTERNAL?). Operations per second
2N/A must be measured during the initialization process to
2N/A determine whether it is close to the advertised number
2N/A (XXX - how could this be verified?).
2N/A For every existing dhcp network record, modify
2N/A the lease time such that it is set to the number of
2N/A modify operations done during this subcase (first one ==
2N/A 1, last 1+N). Measure operations per second during this
2N/A Attempt to add a new dhcptab and a new dhcp
2N/A network container(s) record. This operation should fail
2N/A (XXX expected results?).
2N/A Form a configured number of legal queries (TBD
2N/A tunable) for the dhcptab and dhcp network container(s).
2N/A Validate that the data returned is what is expected
2N/A based upon knowledge of relationship between the record
2N/A being searched for and the expected value based upon the
2N/A search parameters. PASS if queries are successful.
2N/A Measure operations per second during this process for
2N/A comparison against advertised number.
2N/A Using lookup and delete, find and delete every
2N/A single record added by the test. Confirm that the
2N/A containers contain no records. Measure operations per
2N/A second during this process for comparison against the
2N/A Cleanup: Remove the containers.
2N/A [1] "Enterprise DHCP Service Architecture Specification", mwc,
2N/A [2] "Enterprise Reference Hardware Platforms", mwc, 10/23/1999.