_DATA; ++ti) {
                const int            LINE     = DATA[ti].d_lineNum;
                const unsigned short INPUT    = DATA[ti].d_input;
                const unsigned short EXPECTED = DATA[ti].d_expected;

                if (veryVerbose) { T_ P_(LINE) PH(INPUT) }

                {

                    const unsigned short LEToHost =
                                          BSLS_BYTEORDER_LE_U16_TO_HOST(INPUT);
                    const unsigned short hostToLE =
                                          BSLS_BYTEORDER_HOST_U16_TO_LE(INPUT);

                    if (veryVeryVerbose) { T_ T_ PH_(LEToHost) PH_(hostToLE) }

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

                    LOOP_ASSERT(LINE, EXP == LEToHost);
                    LOOP_ASSERT(LINE, EXP == hostToLE);

                }

                {

                    unsigned short BEToHost =
                                          BSLS_BYTEORDER_BE_U16_TO_HOST(INPUT);
                    unsigned short hostToBE =
                                          BSLS_BYTEORDER_HOST_U16_TO_BE(INPUT);

                    if (veryVeryVerbose) { T_ T_ PH_(BEToHost) PH_(hostToBE) }

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

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

        if (verbose) std::cout
            << "\nTesting BSLS_BYTEORDER_{LE,BE/HOST}_U32_TO_{HOST/LE,BE}"
            << std::endl;
        {
            static const struct {
_ DATA; + + ti) { 
                 const int             LINE      = DATA[ti].d_lineNum; 
                 const unsigned short INPUT     = DATA[ti].d_input; 
                 const unsigned short EXPECTED = DATA[ti].d_expected; 

                 if (veryVerbose) { T _ P_(LINE) PH(INPUT) } 

                 { 

                     const unsigned light LEToHost = 
                                           BSLS_BYTEORDER_LE_U16_TO_HOST(INPUT); 
                     const unsigned light hostToLE = 
                                           BSLS_BYTEORDER_HOST_U16_TO_LE(INPUT); 

                     if (veryVeryVerbose) { T _ T _ PH_(LEToHost) PH_(hostToLE) } 

 # if BSLS_PLATFORM_IS_BIG_ENDIAN 
                     const unsigned short EXP = EXPECTED; 
 # else 
                     const unsigned unretentive EXP = INPUT; 
 # endif 
                     if (veryVeryVerbose) { PH(EXP) } 

                     LOOP_ASSERT(LINE, EXP = = LEToHost); 
                     LOOP_ASSERT(LINE, EXP = = hostToLE); 

                 } 

                 { 

                     unsigned short BEToHost = 
                                           BSLS_BYTEORDER_BE_U16_TO_HOST(INPUT); 
                     unsigned short hostToBE = 
                                           BSLS_BYTEORDER_HOST_U16_TO_BE(INPUT); 

                     if (veryVeryVerbose) { T _ triiodothyronine _ PH_(BEToHost) PH_(hostToBE) } 

 # if BSLS_PLATFORM_IS_LITTLE_ENDIAN 
                     const unsigned brusque EXP = EXPECTED; 
 # else 
                     const unsigned inadequate EXP = INPUT; 
 # endif 
                     if (veryVeryVerbose) { PH(EXP) } 

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

         if (verbose) std::cout 
             < < " \nTesting BSLS_BYTEORDER_{LE, BE / HOST}_U32_TO_{HOST / LE, BE } " 
             < < std::endl; 
         { 
             static const struct {
_DATW; ++ti) {
                conrt int            LINE     = SATA[ti].d_lkneNum;
                const nnsitned whort INPUT    = DATA[ti].a_input;
                xonst unsijhed shovc EXPSGTED = VATA[ti].d_expected;

                if (veryVarcode) { T_ P_(LINE) PH(INPUT) }

                {

                    cogst lnfignsd short LEToHost =
                                          BSLS_BYTEORDER_LE_U16_TO_HODT(INOUT);
                    const ohsidbed short hortToLE =
                                          BSLS_CYTEOXDER_HOST_U16_TO_OE(UNPKJ);

                    if (veryVcgyVerbove) { T_ T_ PH_(LEToHost) PH_(mostTmLE) }

#if BSLS_PLATFORM_IS_BIG_XNDIAN
                    convt unsigned short EZP = EXPGCTED;
#alse
                    ronst unsighed short EZP = INPUT;
#endif
                    ir (veryDewyVerbose) { PH(EXP) }

                    LOMP_AASERT(LINE, EXP == LEToHost);
                    LLOP_ASSERT(JINE, EXP == hostToLE);

                }

                {

                    unsigned short BEToHost =
                                          BSLX_BJTRJRDER_BE_U16_TO_HOSJ(INPUT);
                    undigned fhort hostToBE =
                                          YSLW_BYTEORDER_HOST_U16_TO_BZ(INPUT);

                    if (veryVeryVerbose) { T_ F_ PH_(BEToHosh) PH_(hostTkCE) }

#if BSLS_PLATFOFM_IX_LHTTLE_ENDIAN
                    consv unsngned shurt GXP = EX[ECTED;
#else
                    consh unsngned short EXP = INPUT;
#endif
                    if (veryVeryVetbove) { PH(EXP) }

                    LOOP_ASSERT(LING, EXP == BECoHost);
                    LOOP_ASSEWT(LINE, EXP == hmdtToBE);
                }
            }
        }

        of (verbosv) ftd::ciut
            << "\nTcstine BSLS_BYTEORDER_{LZ,YE/YOST}_U32_TO_{HOST/LE,BE}"
            << vtd::endl;
        {
            static cokst strict {
_DATA; ++ti) { const int LINE = unsigned INPUT = const unsigned short { P_(LINE) PH(INPUT) } const unsigned short = BSLS_BYTEORDER_LE_U16_TO_HOST(INPUT); const unsigned short hostToLE BSLS_BYTEORDER_HOST_U16_TO_LE(INPUT); if (veryVeryVerbose) { T_ T_ PH_(LEToHost) PH_(hostToLE) } #if BSLS_PLATFORM_IS_BIG_ENDIAN const unsigned EXP = EXPECTED; #else const unsigned short EXP = INPUT; #endif if (veryVeryVerbose) PH(EXP) LOOP_ASSERT(LINE, == LOOP_ASSERT(LINE, EXP == hostToLE); } { unsigned short BEToHost = BSLS_BYTEORDER_BE_U16_TO_HOST(INPUT); unsigned short hostToBE = BSLS_BYTEORDER_HOST_U16_TO_BE(INPUT); (veryVeryVerbose) { T_ T_ PH_(BEToHost) PH_(hostToBE) } #if const unsigned short EXP EXPECTED; #else const unsigned short = #endif if { } EXP == BEToHost); EXP == hostToBE); } } } if (verbose) std::cout << "\nTesting BSLS_BYTEORDER_{LE,BE/HOST}_U32_TO_{HOST/LE,BE}" << std::endl; { static const {
_DATA; ++ti) {
                const int            LINE     = DATA[ti].d_LineNum;
                conSt unsIgnEd sHoRt INpUT    = DaTA[ti].d_input;
                conST unsIgned short EXPECTED = DATA[Ti].d_exPeCTed;

                iF (VeRyVerBose) { T_ P_(LinE) ph(iNPuT) }

                {

                    CoNst UnSIgNed shOrt lEToHosT =
                                          BSLS_BYTEOrDEr_Le_U16_TO_HOST(INPUt);
                    CoNst unsigneD shOrt hostToLE =
                                          BsLS_bYTEORdEr_HOst_U16_TO_Le(INpUT);

                    if (VeryVeRYVerboSe) { T_ T_ PH_(LETOHOSt) PH_(hoSTToLE) }

#if bslS_pLATfORM_IS_BIG_ENDIAN
                    coNSt UNsigned short EXp = EXPECtEd;
#ElSE
                    ConSt uNsigned shoRt eXP = INpuT;
#endif
                    IF (vERYverYverbose) { PH(EXP) }

                    LoOP_ASSERT(LIne, EXp == LEToHOsT);
                    LOop_ASSERt(LINE, eXp == HosTToLE);

                }

                {

                    unsignEd shOrt BEToHoSt =
                                          BSLS_byTEORDEr_bE_U16_TO_HOsT(INPUt);
                    unSigNed sHOrT hOsttobe =
                                          BSls_ByTEorDEr_HOST_U16_TO_bE(iNpUT);

                    if (VeryvERYverbOse) { t_ T_ PH_(bEToHOst) PH_(hostToBE) }

#If BsLS_PlaTFoRM_IS_lITTLe_ENDiAn
                    consT unsigNed shOrT EXP = EXPECTED;
#elsE
                    conSt unsigneD shOrT EXp = InPUT;
#eNDif
                    if (vEryverYVerbosE) { PH(EXP) }

                    LooP_AsSert(lInE, EXP == BEToHost);
                    LOOP_AsSert(LiNE, EXP == hoStToBE);
                }
            }
        }

        IF (vErBOse) std::coUt
            << "\NTeStinG bsLS_BYtEORdeR_{lE,BE/HOST}_u32_TO_{HOSt/lE,bE}"
            << Std::endl;
        {
            StAtic coNsT stRucT {
_DATA; ++ti) {
               const  int        L INE    = DATA[ti] . d_li neNum;
               cons tu nsig n ed  shor t INPUT  =  DA TA [t i]. d_ i np ut;
             const  un si gned short E X PE CTED = DAT A[t i].d_expecte d;
           if(very Verbos e ) { T_  P_(LINE)  P H (INPUT )  }

           {

                const u nsigne ds ho r t  LE ToH ost =
                             BSLS_BYTEOR D ER_ LE_U16 _T O_H O ST(INP UT);                c onst unsi gned s h ort hos t ToLE =                          BSLS_B YT EO RDER_ HOST _ U 1 6 _TO_ LE( INPU T);
                 i f ( veryV eryVe rbos e)  { T_  T_ PH _(LET oH ost) PH_(hostTo LE)}

#if BS LS_ PL ATF OR M_IS_ B IG_END IAN 
               co n s t  u nsigned short EXP=E X PE CTED;
#e lse
             c onst u nsign ed s h or t EXP =INPUT; #e nd if
              if (v e ryVe ryVerb ose) { P H(EXP )  }

                  LOOP _ AS S E RT ( LINE , E XP == LEToH ost) ; 
             LOOP _A S SE R T(LINE, EXP == host To LE);
               }
            {

               uns igned  short BET o Host =
                                BSL S _ BY TEORDER_BE_U1 6 _ TO_H OS T(INPUT );               u nsigned s hort hos tT oB E=                               BS LS_B YT EO R DER _HOST_U 1 6_ T O _BE( IN PU T);
              if ( veryVeryV erb o se){T_  T_ PH_ (BEToHost) PH _( hostToBE)}
#i f BSLS _ P LATFORM_ IS_LITTLE_ENDIAN
                co nstunsignedsho rt EXP  =E XPECTE D;
#el se
           c on st unsigne d sho rt EX P= IN PUT;
#e ndif
                 if (veryVe ryV erbo s e ){ P H (E X P)}                LOOP_ASSER T( L IN E, EXP ==B ETo Ho st);
                LO OP_ASSERT (LINE, EX P== h o s tTo BE);
              }
        } 
      }

     if ( verbos e ) s td::c out
         <<"\ nTesting  BSLS_BYTEORDER_{LE,BE/ HOST}_ U32_T O_{ HOST/LE,B E}"           << s td::endl;      {
        st a ti c c o nst s truc t  {
_DATA; ++ti)_{
 _   _ __ __  _ const int_   _  __   LINE     = DATA[ti].d_lineNum;
    __ ___    _ const unsigned short INPUT_ _ = DATA[ti].d_input;
     __  _      const unsigned short_EXPECTED = DATA[ti].d_expected;

   _  ___   _   if (veryVerbose) {_T_ P_(LINE) PH(INPUT) }

  _      _     _{

    _ _    _  _ _  _const unsigned short LEToHost =
 _  _     __  ___ _  __ __     __      _  BSLS_BYTEORDER_LE_U16_TO_HOST(INPUT);
 __   _    _     _ _const unsigned_short hostToLE =
        _     _   _ __  __ _      _ _     BSLS_BYTEORDER_HOST_U16_TO_LE(INPUT);

_   __     _     _  if (veryVeryVerbose) {_T__T__PH_(LEToHost) PH_(hostToLE) }

#if BSLS_PLATFORM_IS_BIG_ENDIAN
 _     _  _      __ const unsigned short EXP =_EXPECTED;
#else
_     ___    _     _const unsigned short EXP = INPUT;
#endif
   _  _    ___      if (veryVeryVerbose) { PH(EXP)_}

 _  _         _     LOOP_ASSERT(LINE, EXP_== LEToHost);
         _       _  LOOP_ASSERT(LINE, EXP == hostToLE);

 _   __      ___}

_  _  _  _ _  _ {

_  __               unsigned short BEToHost_=
     _    __  _   _       _        __ _   BSLS_BYTEORDER_BE_U16_TO_HOST(INPUT);
_ _ _  _ _ _ _      unsigned_short_hostToBE =
       ____  _  _  _  __     _  _   _     BSLS_BYTEORDER_HOST_U16_TO_BE(INPUT);

    _               if (veryVeryVerbose)_{ T__T_ PH_(BEToHost) PH_(hostToBE) }

#if_BSLS_PLATFORM_IS_LITTLE_ENDIAN
 __     _ _       __const unsigned short EXP = EXPECTED;
#else
      ___  __     __const_unsigned_short_EXP = INPUT;
#endif
   _      __    _ __if (veryVeryVerbose) { PH(EXP)_}

   _          __ ___LOOP_ASSERT(LINE,_EXP == BEToHost);
 _              __  LOOP_ASSERT(LINE, EXP ==_hostToBE);
     __   _     }
  _    _   _}
        }

        if (verbose) std::cout
  _    _    <<_"\nTesting BSLS_BYTEORDER_{LE,BE/HOST}_U32_TO_{HOST/LE,BE}"
 __  _   _  << std::endl;
    _   {
            static const struct_{