l10n.cpp

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

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test uninitialized object:  getVariant() method
        {
            Boolean gotException = false;
            LanguageTag lt;

            try
            {
                String variant = lt.getVariant();
            }
            catch (UninitializedObjectException&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test uninitialized object:  toString() method
        {
            Boolean gotException = false;
            LanguageTag lt;

            try
            {
                String languageString = lt.toString();
            }
            catch (UninitializedObjectException&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test uninitialized object:  equality operator
        {
            Boolean gotException = false;
            LanguageTag lt1;
            LanguageTag lt2("en-US-ca");

            try
            {
                Boolean test = (lt1 == lt2);
            }
            catch (UninitializedObjectException&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test uninitialized object:  assignment
        {
            LanguageTag lt1;
            LanguageTag lt2("en-US-ca");

            lt1 = lt2;

            PEGASUS_TEST_ASSERT(lt1.toString() == "en-US-ca");
        }

        // Test uninitialized object:  unassignment
        {
            Boolean gotException = false;
            LanguageTag lt1("en-US-ca");
            LanguageTag lt2;

            lt1 = lt2;

            try
            {
                String languageTag = lt1.toString();
            }
            catch (UninitializedObjectException&)
            {
                gotException = true;
            }

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


void drive_AcceptLanguageList()
{
    try
    {
        AcceptLanguageList al = LanguageParser::parseAcceptLanguageHeader(
            "en-US-mn;q=.9,fr-FR;q=.1,en, fr;q=.2,la-SP-bal;q=.7,*;q=.01");

        PEGASUS_TEST_ASSERT(al.size() == 6);

        PEGASUS_TEST_ASSERT(al.getLanguageTag(0).toString() == "en");
        PEGASUS_TEST_ASSERT(al.getLanguageTag(1).toString() == "en-US-mn");
        PEGASUS_TEST_ASSERT(al.getLanguageTag(2).toString() == "la-SP-bal");
        PEGASUS_TEST_ASSERT(al.getLanguageTag(3).toString() == "fr");
        PEGASUS_TEST_ASSERT(al.getLanguageTag(4).toString() == "fr-FR");
        PEGASUS_TEST_ASSERT(al.getLanguageTag(5).toString() == "*");

        PEGASUS_TEST_ASSERT(LanguageParser::buildAcceptLanguageHeader(al) ==
            "en,en-US-mn;q=0.900,la-SP-bal;q=0.700,fr;q=0.200,fr-FR;q=0.100,"
                "*;q=0.010");

        // Test insert() method

        al.insert(LanguageTag("en-XX-xx"), 1.0);
        PEGASUS_TEST_ASSERT(al.size() == 7);
        PEGASUS_TEST_ASSERT(al.find(LanguageTag("en-XX-xx")) != PEG_NOT_FOUND);
        PEGASUS_TEST_ASSERT(
            al.getQualityValue(al.find(LanguageTag("en-XX-xx"))) == 1.0);

        // Test remove() method

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

        // Test assignment operator and equality operator

        AcceptLanguageList al1;

        al1 = al;
        PEGASUS_TEST_ASSERT(al1 == al);

        al1 = al1;
        PEGASUS_TEST_ASSERT(al1 == al);

        al1.remove(0);
        PEGASUS_TEST_ASSERT(al1 != al);

        // Test inequality operator
        {
            AcceptLanguageList list1;
            AcceptLanguageList list2;

            list1.insert(LanguageTag("en-US"), 1);
            list1.insert(LanguageTag("fr"), Real32(0.8));
            list2 = list1;
            PEGASUS_TEST_ASSERT(list1 == list2);

            list2.remove(1);
            PEGASUS_TEST_ASSERT(list1 != list2);

            list2.insert(LanguageTag("fr"), Real32(0.7));
            PEGASUS_TEST_ASSERT(list1 != list2);

            list2.remove(1);
            list2.insert(LanguageTag("de"), Real32(0.8));
            PEGASUS_TEST_ASSERT(list1 != list2);
        }

        // Test clear() method

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

        // Test sorting of quality values
        {
            AcceptLanguageList al = LanguageParser::parseAcceptLanguageHeader(
                "de;q=0.000,it;q=0.50,*;q=0.25,en-US-ca;q=1.00");

            PEGASUS_TEST_ASSERT(al.getLanguageTag(0).toString() == "en-US-ca");
            PEGASUS_TEST_ASSERT(al.getQualityValue(0) == 1.0);
            PEGASUS_TEST_ASSERT(al.getLanguageTag(1).toString() == "it");
            PEGASUS_TEST_ASSERT(al.getQualityValue(1) == 0.5);
            PEGASUS_TEST_ASSERT(al.getLanguageTag(2).toString() == "*");
            PEGASUS_TEST_ASSERT(al.getQualityValue(2) == 0.25);
            PEGASUS_TEST_ASSERT(al.getLanguageTag(3).toString() == "de");
            PEGASUS_TEST_ASSERT(al.getQualityValue(3) == 0.0);

            PEGASUS_TEST_ASSERT(LanguageParser::buildAcceptLanguageHeader(al) ==
                "en-US-ca,it;q=0.500,*;q=0.250,de;q=0.000");
        }

        // Test invalid quality value syntax:  Missing "q"
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader("en-US-ca;");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid quality value syntax:  Missing "="
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader("en-US-ca;q");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid quality value syntax:  Unexpected character at "q"
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader("en-US-ca;r=.9");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid quality value syntax:  Unexpected character at "="
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca;q+0.1");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid quality value syntax:  Extra semicolon
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca;;q=0.1");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid quality value syntax:  Negative quality value
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca;q=-0.1");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid quality value syntax:  Quality value too large
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca;q=1.1");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid quality value syntax:  Invalid trailing characters
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca;q=0.1a");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid quality value syntax:  Quality value too long
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca;q=0.1110");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid comment syntax:  Missing closing parenthesis
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca(;q=0.1111");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test valid comment syntax
        {
            AcceptLanguageList al1 = LanguageParser::parseAcceptLanguageHeader(
                "en(english)-(\\(USA\\))US-\\c\\a;q(quality)=0.1(not much)");
            AcceptLanguageList al2 = LanguageParser::parseAcceptLanguageHeader(
                "en-US-ca;q=0.1");
            PEGASUS_TEST_ASSERT(al1 == al2);
        }

        // Test valid comment and whitespace syntax
        {
            AcceptLanguageList al1 = LanguageParser::parseAcceptLanguageHeader(
                "en (english)-(\\( USA \\))US-\\c \\a   ;q(quality) =0.1  "
                    "(not much) ");
            AcceptLanguageList al2 = LanguageParser::parseAcceptLanguageHeader(
                "en-US-ca;q=0.1");
            PEGASUS_TEST_ASSERT(al1 == al2);
        }

        // Test invalid whitespace syntax
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca\\ ;q=0.1");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

        // Test invalid language tag:  Trailing '-'
        {
            Boolean gotException = false;

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        "en-US-ca-;q=0.1");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

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

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader("");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }

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

            try
            {
                AcceptLanguageList al =
                    LanguageParser::parseAcceptLanguageHeader(
                        " (comment only)");
            }
            catch (InvalidAcceptLanguageHeader&)
            {
                gotException = true;
            }

            PEGASUS_TEST_ASSERT(gotException);
        }
    }