l10n.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

    catch (Exception& e)
    {
        cout << "Unexpected exception: " << e.getMessage() << endl;
        exit(1);
    }
}


void drive_ContentLanguageList()
{
    try
    {
        ContentLanguageList cl = LanguageParser::parseContentLanguageHeader(
            "en-US-mn,fr-FR,en, fr(oh you french), la-SP-bal");

        for (Uint32 index = 0; index < cl.size(); index++)
        {
            LanguageTag lt = cl.getLanguageTag(index);

            if (index == 3)
            {
                PEGASUS_TEST_ASSERT(String::equal(lt.toString(), "fr"));
            }
        }

        PEGASUS_TEST_ASSERT(cl.size() == 5);

        // Add LanguageTag

        cl.append(LanguageTag("en-XX-xx"));
        PEGASUS_TEST_ASSERT(cl.size() == 6);
        PEGASUS_TEST_ASSERT(cl.find(LanguageTag("en-XX-xx")) != PEG_NOT_FOUND);

        // Remove LanguageTag

        Uint32 index = cl.find(LanguageTag("en-XX-xx"));
        cl.remove(index);
        PEGASUS_TEST_ASSERT(cl.find(LanguageTag("en-XX-xx")) == PEG_NOT_FOUND);
        PEGASUS_TEST_ASSERT(cl.size() == 5);

        // Test assignment operator and equality operator

        ContentLanguageList cl1;
        cl1 = cl;
        PEGASUS_TEST_ASSERT(cl1 == cl);

        cl1 = cl1;
        PEGASUS_TEST_ASSERT(cl1 == cl);

        cl1.remove(0);
        PEGASUS_TEST_ASSERT(cl1 != cl);

        // Test clear() method

        cl1.clear();
        PEGASUS_TEST_ASSERT(cl1.size() == 0);

        // Test invalid Content-Language value:  Invalid character
        {
            Boolean gotException = false;

            try
            {
                ContentLanguageList cl =
                    LanguageParser::parseContentLanguageHeader("en-4%5US-mn");
            }
            catch(InvalidContentLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid Content-Language value:  Empty string
        {
            Boolean gotException = false;

            try
            {
                ContentLanguageList cl =
                    LanguageParser::parseContentLanguageHeader("");
            }
            catch (InvalidContentLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid Content-Language value:  Comment and whitespace only
        {
            Boolean gotException = false;

            try
            {
                ContentLanguageList cl =
                    LanguageParser::parseContentLanguageHeader(
                        " (comment only)");
            }
            catch (InvalidContentLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid Content-Language value:  "*" language tag
        {
            Boolean gotException = false;

            try
            {
                ContentLanguageList cl =
                    LanguageParser::parseContentLanguageHeader("en, *, es");
            }
            catch (InvalidContentLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }
    }
    catch (Exception& e)
    {
        cout << "Unexpected exception: " << e.getMessage() << endl;
        exit(1);
    }
}


void callMessageLoader(MessageLoaderParms mlp_arr[], int size)
{
    String msg;

    for(int i = 0; i < size; i++)
    {
         msg = MessageLoader::getMessage(mlp_arr[i]);
    }
}


void drive_MessageLoader()
{
    String msg;
    int mlp_arr_size = 4;

    MessageLoaderParms mlp("CIMStatusCode.CIM_ERR_SUCCESS","Default CIMStatusCode, $0 $1",

                            "rab oof is foo bar backwards",64000);

    mlp.msg_src_path = "test/pegasusTest";



    AcceptLanguageList al = LanguageParser::parseAcceptLanguageHeader("en-US");

    mlp.acceptlanguages = al;

#ifdef PEGASUS_HAS_ICU

    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp) == "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = 64,000" );

    // test for return content languages

    PEGASUS_TEST_ASSERT ( LanguageParser::buildContentLanguageHeader(
        mlp.contentlanguages) == "en-US" );

#else

    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp) == "Default CIMStatusCode, rab oof is foo bar backwards 64000" );

#endif





    // should load en-US resource because of single element fallback logic

    mlp.acceptlanguages.clear();

    mlp.acceptlanguages.insert(LanguageTag("en-US-mn"), 1.0);

#ifdef PEGASUS_HAS_ICU

    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp) == "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = 64,000" );

#else

    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp) == "Default CIMStatusCode, rab oof is foo bar backwards 64000" );

#endif



    // testing first element fallback after acceptlanguages has been exhausted

    MessageLoaderParms mlp1("CIMStatusCode.CIM_ERR_SUCCESS","Default CIMStatusCode, $0 $1",

                            "rab oof is foo bar backwards","fr");

    mlp1.msg_src_path = "test/pegasusTest";

    mlp1.acceptlanguages.clear();

    mlp1.acceptlanguages.insert(LanguageTag("fr-FR"), 1.0);

    mlp1.acceptlanguages.insert(LanguageTag("bl-ow"), 1.0);

#ifdef PEGASUS_HAS_ICU

    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) == "CIM_ERR_SUCCESS: SUCCESSFUL fr rab oof is foo bar backwards, number = fr" );

#else

    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp) == "Default CIMStatusCode, rab oof is foo bar backwards 64000" );

#endif



    // use gobal default message switch for messageloading

    MessageLoader::_useDefaultMsg = true;

    mlp.acceptlanguages.clear();

    mlp.acceptlanguages.insert(LanguageTag("en-US"), 1.0);

    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp) == "Default CIMStatusCode, rab oof is foo bar backwards 64000" );



    // set static AcceptLanguageList in message loader

    MessageLoader::_useDefaultMsg = false;

    MessageLoader::_acceptlanguages.insert(LanguageTag("st-at-ic"), 1.0);
    MessageLoaderParms mlp_static("CIMStatusCode.CIM_ERR_SUCCESS","Default CIMStatusCode, $0",

                                                        "rab oof is foo bar backwards static");
    mlp_static.msg_src_path = "test/pegasusTest";

#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp_static) == "CIM_ERR_SUCCESS: SUCCESSFUL st_at_ic rab oof is foo bar backwards static" );

#else

    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp_static) == "Default CIMStatusCode, rab oof is foo bar backwards static" );

#endif



}

//
// Tests the substitutions into the message
//
void drive_MessageLoaderSubs()
{
    String msg;
    AcceptLanguageList al = LanguageParser::parseAcceptLanguageHeader("en-US");

    MessageLoader::_acceptlanguages.clear();

    //
    // Test Uint64 support.  ICU does not support Uint64, so there
    // is special handling for it in MessageLoader.

    //
    // Uint64 Substitution is the biggest positive to fit in int64_t.
    // This does not test the special code in MessageLoader.
    //
    MessageLoaderParms mlp1("CIMStatusCode.CIM_ERR_SUCCESS","Default CIMStatusCode, $0 $1",
                            String("rab oof is foo bar backwards"),
                            PEGASUS_UINT64_LITERAL(0x7fffffffffffffff));
    mlp1.msg_src_path = "test/pegasusTest";
    mlp1.acceptlanguages = al;

#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
        "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = 9,223,372,036,854,775,807");
#else
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
         "Default CIMStatusCode, rab oof is foo bar backwards 9223372036854775807" );
#endif

    //
    // Uint64 substitution is too big to fit int64_t.  Tests the special MessageLoader
    // code for this.  Expect the number to be unformatted.
    //
    mlp1.arg1 = PEGASUS_UINT64_LITERAL(0x8000000000000000);
#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
        "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = 9223372036854775808");
#else
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
         "Default CIMStatusCode, rab oof is foo bar backwards 9223372036854775808" );
#endif

    //
    // Sint64 substitution - biggest negative.
    //
    mlp1.arg1 = PEGASUS_SINT64_LITERAL(0x8000000000000000);
#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
        "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = -9,223,372,036,854,775,808");
#else
    /* ====> Commenting this out until Formatter.cpp is fixed for ULInteger (it truncates the value)
       The main purpose of these tests is ICU substitution.
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
         "Default CIMStatusCode, rab oof is foo bar backwards -9223372036854775808" );
    */
#endif

    //
    // Uint32 substitution - biggest possible
    //
    mlp1.arg1 = (Uint32)(0xffffffff);
#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
        "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = 4,294,967,295");
#else
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
         "Default CIMStatusCode, rab oof is foo bar backwards 4294967295" );
#endif

    //
    // Sint32 substitution - biggest negative
    //
    mlp1.arg1 = (Sint32)(0x80000000);
#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
        "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = -2,147,483,648");
#else
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
         "Default CIMStatusCode, rab oof is foo bar backwards -2147483648" );
#endif

    //
    // Real64 substitution
    //
    mlp1.arg1 = (Real64)-64000.125;
#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
        "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = -64,000.125");
#else
    /* Commenting out due to platform differences
       The main purpose of this tests is ICU substitution.
    cout << MessageLoader::getMessage(mlp1) << endl;
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
         "Default CIMStatusCode, rab oof is foo bar backwards -64000.125" );
    */
#endif

    //
    // Boolean substitution = true
    //
    mlp1.arg1 = true;
#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
        "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = true");
#else
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
         "Default CIMStatusCode, rab oof is foo bar backwards true" );
#endif

    //
    // Boolean substitution = false
    //
    mlp1.arg1 = false;
#ifdef PEGASUS_HAS_ICU
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
        "CIM_ERR_SUCCESS: SUCCESSFUL en-us rab oof is foo bar backwards, number = false");
#else
    PEGASUS_TEST_ASSERT ( MessageLoader::getMessage(mlp1) ==
         "Default CIMStatusCode, rab oof is foo bar backwards false" );
#endif

}



int main( int argc, char *argv[] )
{

#ifdef PEGASUS_HAS_ICU
    // If PEGASUS_MSG_HOME is set then use that as the message home for this test.
    // This will ignore any msg home defined for the platform (Constants.h)
    // since this is a test environment, not a production environment.
    const char* env = getenv("PEGASUS_MSG_HOME");
    if (env != NULL)
    {
      MessageLoader::setPegasusMsgHome(env);
    }
    else
    {
      // PEGASUS_MSG_HOME is not set.  Since we need the test messages,
      // use PEGASUS_HOME as the message home.
      env = getenv("PEGASUS_HOME");
      if (env != NULL)
      {
        String msghome(env);
        msghome.append("/msg");
        MessageLoader::setPegasusMsgHome(msghome);
      }
      else
      {
        PEGASUS_STD(cout) << "Either PEGASUS_MSG_HOME or PEGASUS_HOME needs to set for this test!"
                          << PEGASUS_STD(endl);
        exit(-1);

      }
    }


    // If PEGASUS_USE_DEFAULT_MESSAGES env var is set then we need to make sure that it doesn't
    // break this test.
    // Reset _useDefaultMsg to make sure PEGASUS_USE_DEFAULT_MESSAGES is ignored.
    MessageLoader::_useDefaultMsg = false;
#endif


    //BEGIN TESTS....



    drive_LanguageParser();

    drive_LanguageTag();

    drive_AcceptLanguageList();

    drive_ContentLanguageList();

    drive_MessageLoader();

    drive_MessageLoaderSubs();


    //END TESTS....

        cout << argv[0] << " +++++ passed all tests" << endl;

    return 0;

}