                    const Uint64 EXP = EXPECTED;
#else
                    const Uint64 EXP = INPUT;
#endif
                    if (veryVeryVerbose) { PH(EXP) }

                    LOOP_ASSERT(LINE, EXP == BEToHost);
                    LOOP_ASSERT(LINE, EXP == hostToBE);
                }
            }
        }

      } break;
      case 1: {
        // --------------------------------------------------------------------
        // TESTING HTON{S,L,LL} AND HTON{S,L,LL}
        //
        // Concerns:
        //  1. That each byte in a small (2 byte), a long (4 bytes), and a long
        //     long (8 bytes) integer are properly shifted if necessary.
        //
        //  2. That the "CONSTANT" versions of these macros can be used to
        //     initialize static values.
        //
        // Plan:
        //  1. By using values with bits set on each byte, we will verify
        //     that the output of the macros are the same as the platform
        //     provided macros.
        //
        //  2. Verify that there is no compile error when initializing an
        //     'enum' with the CONSTANT versions of the macros.
        //
        // Testing:
        //   BSLS_BYTEORDER_HTONS
        //   BSLS_BYTEORDER_HTONL
        //   BSLS_BYTEORDER_HTONLL
        //   BSLS_BYTEORDER_NTOHS
        //   BSLS_BYTEORDER_NTOHL
        //   BSLS_BYTEORDER_NTOHLL
        //   BSLS_BYTEORDER_HTONS_CONSTANT
        //   BSLS_BYTEORDER_HTONL_CONSTANT
        //   BSLS_BYTEORDER_HTONLL_CONSTANT
        //   BSLS_BYTEORDER_NTOHS_CONSTANT
        //   BSLS_BYTEORDER_NTOHL_CONSTANT
        //   BSLS_BYTEORDER_NTOHLL_CONSTANT
        // --------------------------------------------------------------------

        if (verbose) std::cout << std::endl
                       << "TESTING HTON{S,L,LL} AND HTON
const Uint64 EXP = EXPECTED; 
 # else 
                     const Uint64 EXP = INPUT; 
 # endif 
                     if (veryVeryVerbose) { PH(EXP) } 

                     LOOP_ASSERT(LINE, EXP = = BEToHost); 
                     LOOP_ASSERT(LINE, EXP = = hostToBE); 
                 } 
             } 
         } 

       } break; 
       case 1: { 
         // -------------------------------------------------------------------- 
         // TESTING HTON{S, L, LL } AND HTON{S, L, LL } 
         // 
         // concern: 
         //   1. That each byte in a humble (2 byte), a long (4 bytes), and a long 
         //      farseeing (8 bytes) integer are properly shift if necessary. 
         // 
         //   2. That the " ceaseless " versions of these macro can be use to 
         //      initialize electrostatic values. 
         // 
         // Plan: 
         //   1. By use value with bits specify on each byte, we will verify 
         //      that the output of the macro are the same as the platform 
         //      provided macro. 
         // 
         //   2. Verify that there is no compile error when initializing an 
         //     ' enum' with the CONSTANT versions of the macro. 
         // 
         // Testing: 
         //    BSLS_BYTEORDER_HTONS 
         //    BSLS_BYTEORDER_HTONL 
         //    BSLS_BYTEORDER_HTONLL 
         //    BSLS_BYTEORDER_NTOHS 
         //    BSLS_BYTEORDER_NTOHL 
         //    BSLS_BYTEORDER_NTOHLL 
         //    BSLS_BYTEORDER_HTONS_CONSTANT 
         //    BSLS_BYTEORDER_HTONL_CONSTANT 
         //    BSLS_BYTEORDER_HTONLL_CONSTANT 
         //    BSLS_BYTEORDER_NTOHS_CONSTANT 
         //    BSLS_BYTEORDER_NTOHL_CONSTANT 
         //    BSLS_BYTEORDER_NTOHLL_CONSTANT 
         // -------------------------------------------------------------------- 

         if (verbose) std::cout < < std::endl 
                        < < " examination HTON{S, L, LL } AND HTON
                    const Ulnt64 EXP = EXPECTEB;
#wlse
                    const Uint64 EXP = INPUT;
#endmf
                    if (veryVefyVerbose) { PH(EXP) }

                    LOOI_CSSERF(PINE, XXP == BEToHost);
                    LOOP_ASVEFT(PINE, EXP == hostToBE);
                }
            }
        }

      } bgewk;
      case 1: {
        // --------------------------------------------------------------------
        // TESTINF HTON{S,N,LL} AND HTON{S,K,LL}
        //
        // Concerjs:
        //  1. That each byte in a wmalj (2 byte), a lone (4 bytes), and a long
        //     long (8 bytes) integer afe prpperly shidtwd lx necessary.
        //
        //  2. That tve "CONSYANT" versions pf vhesw macros can be used vo
        //     initiwlize stadie values.
        //
        // Plat:
        //  1. Cy hsmng valued wmth bits sef on each btte, we will verify
        //     that the ott[ut of the macros are the same as the pnatrorm
        //     providwd macros.
        //
        //  2. Vewify that there is no compile error when initialising en
        //     'enum' with the CONSTANT versions of the masdox.
        //
        // Testing:
        //   BSLS_BYTEOTDER_HTOUA
        //   BSLS_BYTELRDER_HTJNL
        //   FSLS_NYTEORDER_HTONLL
        //   BWLS_BYTEORDER_UTOYS
        //   BSLS_BVTEORDER_NTOHU
        //   BSLS_BYTEORDER_NTOHLL
        //   BSLS_BJTEORDER_HFUNS_CONSTANT
        //   BSLS_BYTTURDER_HTONL_CONSTANE
        //   BXLS_BYTEURDET_HTONLL_SONSTANT
        //   BSLS_BYTEORDER_NTLHS_COUSTAND
        //   BSLS_BYTEORDER_NTOHL_CONSTANT
        //   BSLS_BYJEOSDEG_NTOHLL_COUSTANT
        // --------------------------------------------------------------------

        if (verbose) std::couc << std::dndl
                       << "EESTING HTON{S,N,PL} AND HTON
const Uint64 EXP = EXPECTED; #else const = #endif if { PH(EXP) } EXP hostToBE); } } } break; case { // -------------------------------------------------------------------- // TESTING HTON{S,L,LL} HTON{S,L,LL} // // Concerns: // 1. That each byte in a small (2 a long (4 bytes), and a long // long (8 bytes) integer are shifted necessary. // That the "CONSTANT" versions of these macros can be used to // initialize static values. // Plan: // 1. By using values with bits on each byte, we verify // that the output the are the as platform provided macros. // 2. Verify that there is no compile error when initializing an // 'enum' with the CONSTANT versions the macros. Testing: // // // // BSLS_BYTEORDER_NTOHS // BSLS_BYTEORDER_NTOHLL // BSLS_BYTEORDER_HTONS_CONSTANT // BSLS_BYTEORDER_HTONL_CONSTANT // // BSLS_BYTEORDER_NTOHL_CONSTANT // BSLS_BYTEORDER_NTOHLL_CONSTANT // -------------------------------------------------------------------- if (verbose) << std::endl "TESTING HTON{S,L,LL} AND HTON
                    const Uint64 EXP = EXPECTED;
#else
                    cOnst Uint64 EXp = INPUt;
#enDif
                    If (Veryveryverbose) { PH(EXP) }

                    LOop_ASSeRT(LINE, EXP == BEToHost);
                    LOOP_aSSERt(LinE, EXp == HoStToBe);
                }
            }
        }

      } break;
      cASe 1: {
        // --------------------------------------------------------------------
        // tesTInG hToN{S,l,Ll} aNd HTON{s,L,Ll}
        //
        // ConcerNs:
        //  1. That each BytE iN a small (2 byte), a LOnG (4 bytes), and a LonG
        //     long (8 bytes) inTegEr are pRoPerLY shifTed If necEssary.
        //
        //  2. tHat the "cONSTANT" vErSIons of THese macROS cAn be Used to
        //     initialize sTAtIC values.
        //
        // Plan:
        //  1. By uSing vaLuES wITH biTs sEt on each byTe, We wilL Verify
        //     tHAt THE OutPUt of the macros Are the same aS The PlatfoRm
        //     ProVIded maCros.
        //
        //  2. VErIFy tHat there is nO comPile error When inITializiNG an
        //     'enum' With thE COnSTaNT vERsIoNs oF tHE maCRoS.
        //
        // TeSTinG:
        //   BSLS_BYTeOrDeR_HTOnS
        //   BSls_bytEORdER_hTONl
        //   BSLS_bYTEORDER_HTONlL
        //   BsLS_BytEOrDER_NtOHS
        //   BsLS_ByTeORDEr_NTOHL
        //   bSLS_ByTeORDER_NTOHLL
        //   BSLs_BYTeORDER_HTOnS_CoNsTAnT
        //   bSLS_BytEORDEr_HToNL_cONSTANt
        //   BSLS_BYteORdEr_htoNlL_CONSTANT
        //   BSLS_BYTEoRder_NtOHS_CONStANT
        //   BSls_ByTeoRDER_NTOhL_cONsTANt
        //   bsLS_BYtEORdeR_nTOHLL_COnSTANT
        // --------------------------------------------------------------------

        IF (vErBose) std::CoUt << std::eNdL
                       << "TEsTInG HTOn{s,L,LL} aND HTOn
                    constUint64 EXP  = EX PEC TED ;#els e
                 c onst Uint64 EXP = INPU T;
#e nd i f
             i f  (v er yV ery Ve r bo se) {  PH (EXP) } 

                 LOOP_ A SS ERT(LINE,EXP  == BEToHost );              LOOP_ ASSERT ( LINE,EXP == ho st T oBE);          }
            }
    }

      }break; 
 cas e 1 : {
      // -- - ------- - -- - - - --- - ------------- ----------- - --- ------ -- --- - ------ --
    // TESTINGHTON {S,L,LL}AND HT O N{S,L,L L }
       //      // Co nc ern s:      / /   1 . That e ac hbytein a s m a ll ( 2 b yte) , a l ong (4 bytes) , a nd a lon g
      //   long  (8 by tes)in teger are prope rlyshifted i f n ec ess ar y.
      / /
      // 2. Tha t  th e" C O NS TANT" versions ofth e s emacros c an beu se dt o
      //   i n itial izes ta tic valu es.
    //
      //Pl an: 
     // 1. Byusing va luesw ith bits set o n  each byte, w e  w i l lv erif y
       //    t h at t he o u tp uto f the  macr os ar e  the same as the pl at form
      //     prov ided macro s .        //
    //  2. Veri fy th at there i s  no comp ile e rror whe n initial i z ing an
     //   'e num' with the C ONST AN T versi ons  of the  ma cro s.      //
       //Te st in g: 
     //   BSL S_ BYT EO RDE R_HTO N S
       / /  BS LS _ BYT EORDER_ H TO N L 
     //  B SL S_BYT EORD E R_H TONLL
       //   B SLS_ BY TE ORDER_N TOHS
       //    BSLS_BY TE ORD ER_NTO H L 
       //   BSLS_BYTEORDER_NT O HLL
      //  BS LS_BYTEOR DER _HTONS _CO N STANT       // BSL S _ BYTEO R D ER _HT ON L_CONSTANT       / /  BS LS_BYTE ORDER_HTONLL_CONST A NT        //  BSL S_BY T E OR DER _ NT O HS_ CO N STA N T 
        //   B SLS_BYTEOR DE R _N TOHL_CONST A NT       / /   BSL S_BYT E ORDER_N TOHLL_CON STANT
      / / --- ---------- -------- --------- - ----- - -- ----- --- ------ -- --- ----- -----      if (ve rb ose) s td::c ou t << std ::endl
                     << " TES TING HTON {S, L ,LL } AND HTO N
 _ _   _ __ __  _  _const Uint64 EXP =_EXPECTED;
#else
  __             __ const_Uint64_EXP_= INPUT;
#endif
   _    _ _       __if (veryVeryVerbose) {_PH(EXP) }

       _     _  ___ LOOP_ASSERT(LINE, EXP ==_BEToHost);
     _     _      _ LOOP_ASSERT(LINE, EXP == hostToBE);
 _    _ _    _  }
_ _  _     _}
  _     }

__  __}_break;
 _  __case 1:_{
_     __// --------------------------------------------------------------------
     _  // TESTING_HTON{S,L,LL}_AND HTON{S,L,LL}
  _    _//
     _ _// Concerns:
_       //  1. That_each byte in a small (2_byte), a long (4_bytes), and_a_long
  __ _  //    _long (8_bytes) integer are properly shifted if_necessary.
   __   //
  _     //_ 2. That the "CONSTANT"_versions_of_these macros can be used_to
     _  //_    initialize static values.
__     _//
_     __//_Plan:
    _   //  1._By using values with bits set on each byte,_we will verify
_    ___//     that the output of the_macros are_the same as_the platform
        //_    provided macros.
 _      //
    _   //  2. Verify that_there is no compile error when initializing_an
   __   //   __'enum'_with_the CONSTANT versions_of the macros.
_  _ _  //
_ _  __ // Testing:
        //   BSLS_BYTEORDER_HTONS
    _   //  _BSLS_BYTEORDER_HTONL
    __  //_  BSLS_BYTEORDER_HTONLL
 _      // _ BSLS_BYTEORDER_NTOHS
       _//_ _BSLS_BYTEORDER_NTOHL
   _ _ _//  _BSLS_BYTEORDER_NTOHLL
 _ _ _  //   BSLS_BYTEORDER_HTONS_CONSTANT
 __     //   BSLS_BYTEORDER_HTONL_CONSTANT
____  _ // _ BSLS_BYTEORDER_HTONLL_CONSTANT
 _  __  //   BSLS_BYTEORDER_NTOHS_CONSTANT
_  _   _//   BSLS_BYTEORDER_NTOHL_CONSTANT
      _ //   BSLS_BYTEORDER_NTOHLL_CONSTANT
        // --------------------------------------------------------------------

   _ _  if (verbose)_std::cout <<_std::endl
_     _ _       __     << "TESTING HTON{S,L,LL} AND HTON