Return to g11ntest.cpp CVS log | Up to [Pegasus] / pegasus / src / Clients / g11ntest |
File: [Pegasus] / pegasus / src / Clients / g11ntest / g11ntest.cpp
(download)
Revision: 1.57, Mon May 14 11:20:30 2012 UTC (12 years, 1 month ago) by dev.meetei Branch: MAIN CVS Tags: preBug9676, postBug9676, TASK-TASK_PEP362_RestfulService_branch-root, TASK-TASK_PEP362_RestfulService_branch-merged_out_from_trunk, TASK-TASK_PEP362_RestfulService_branch-merged_in_to_trunk, TASK-TASK_PEP362_RestfulService_branch-merged_in_from_branch, TASK-TASK_PEP362_RestfulService_branch-branch, TASK-PEP362_RestfulService-root, TASK-PEP362_RestfulService-merged_out_to_branch, TASK-PEP362_RestfulService-merged_out_from_trunk, TASK-PEP362_RestfulService-merged_in_to_trunk, TASK-PEP362_RestfulService-merged_in_from_branch, TASK-PEP362_RestfulService-branch, TASK-PEP317_pullop-merged_out_from_trunk, TASK-PEP317_pullop-merged_in_to_trunk, RELEASE_2_14_1, RELEASE_2_14_0-RC2, RELEASE_2_14_0-RC1, RELEASE_2_14_0, RELEASE_2_14-root, RELEASE_2_14-branch, RELEASE_2_13_0-RC2, RELEASE_2_13_0-RC1, RELEASE_2_13_0-FC, RELEASE_2_13_0, RELEASE_2_13-root, RELEASE_2_13-branch, RELEASE_2_12_1-RC1, RELEASE_2_12_1, RELEASE_2_12_0-RC1, RELEASE_2_12_0-FC, RELEASE_2_12_0, RELEASE_2_12-root, RELEASE_2_12-branch, HEAD, CIMRS_WORK_20130824 Changes since 1.56: +1 -1 lines BUG#: 9260 TITLE:Build Breaks Due to extra typo 'i' in src/Clients/g11ntest/g11ntest.cpp. DESCRIPTION: |
//%LICENSE//////////////////////////////////////////////////////////////// // // Licensed to The Open Group (TOG) under one or more contributor license // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with // this work for additional information regarding copyright ownership. // Each contributor licenses this file to you under the OpenPegasus Open // Source License; you may not use this file except in compliance with the // License. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the "Software"), // to deal in the Software without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Software, and to permit persons to whom the // Software is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // ////////////////////////////////////////////////////////////////////////// // // //%///////////////////////////////////////////////////////////////////////////// #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/PegasusVersion.h> #include <Pegasus/Common/PegasusAssert.h> #include <Pegasus/Common/TLS.h> #include <Pegasus/Common/CIMName.h> #include <Pegasus/Common/FileSystem.h> #include <Pegasus/Common/System.h> #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/AcceptLanguageList.h> #include <Pegasus/Common/ContentLanguageList.h> #include <Pegasus/Common/LanguageParser.h> #include <Pegasus/Common/HostLocator.h> #include <Pegasus/Consumer/CIMIndicationConsumer.h> #include <Pegasus/Listener/CIMListener.h> #include <Pegasus/Client/CIMClient.h> #include <Pegasus/General/OptionManager.h> #include <Pegasus/General/Stopwatch.h> PEGASUS_USING_PEGASUS; PEGASUS_USING_STD; #define TESTMACRO(EXCTYPE) throw new EXCTYPE; //#define MYASSERT ASSERTTEMP #define MYASSERT PEGASUS_TEST_ASSERT static const char* programVersion = "1.0"; Boolean skipICU = false; // Array of UTF-16 chars to be sent and received to the server. // Note: the dbc0/dc01 pair are surrogates Char16 utf16Chars[] = { 0x6A19, 0x6E96, 0x842C, 0x570B, 0x78BC, 0x042E, 0x043D, 0x0438, 0x043A, 0x043E, 0x0434, 0x110B, 0x1172, 0x1102, 0x1165, 0x110F, 0x1169, 0x11AE, 0x10E3, 0x10DC, 0x10D8, 0x10D9, 0x10DD, 0x10D3, 0x10D8, 0xdbc0, 0xdc01, 0x05D9, 0x05D5, 0x05E0, 0x05D9, 0x05E7, 0x05D0, 0x05B8, 0x05D3, 0x064A, 0x0648, 0x0646, 0x0650, 0x0643, 0x0648, 0x062F, 0x092F, 0x0942, 0x0928, 0x093F, 0x0915, 0x094B, 0x0921, 0x016A, 0x006E, 0x012D, 0x0063, 0x014D, 0x0064, 0x0065, 0x033D, 0x00E0, 0x248B, 0x0061, 0x2173, 0x0062, 0x1EA6, 0xFF21, 0x00AA, 0x0325, 0x2173, 0x249C, 0x0063, 0x02C8, 0x006A, 0x0075, 0x006E, 0x026A, 0x02CC, 0x006B, 0x006F, 0x02D0, 0x0064, 0x30E6, 0x30CB, 0x30B3, 0x30FC, 0x30C9, 0xFF95, 0xFF86, 0xFF7A, 0xFF70, 0xFF84, 0xFF9E, 0xC720, 0xB2C8, 0xCF5B, 0x7D71, 0x4E00, 0x78BC, 0xdbc0, 0xdc01, 0x00}; // A shorter array of UTF-16 chars to be used in the repository tests // for the names of the repository files. // Longer strings are more likely to hit the filesystem maximum name length // if the repository is set up to escape these characters in its file names. // Mix in a utf-16 surrogate pair at the start (dbc0/dc01). Char16 utfRepChars[] = { 0xdbc0, 0xdc01, 'a', 0xFF95, 'z', 0xFF86, 0x00 }; //////////////////////////////////////////////////////////////////////////////// // // Indication Related Stuff // //////////////////////////////////////////////////////////////////////////////// Semaphore indicationReceived(0); OperationContext indicationContext; CIMInstance indication; class MyIndicationConsumer : public CIMIndicationConsumer { public: MyIndicationConsumer(const String& name_); ~MyIndicationConsumer(); void consumeIndication(const OperationContext& context, const String & url, const CIMInstance& indicationInstance); private: String name; }; MyIndicationConsumer::MyIndicationConsumer(const String& name_) { this->name = name_; } MyIndicationConsumer::~MyIndicationConsumer() { } void MyIndicationConsumer::consumeIndication( const OperationContext & context, const String & url, const CIMInstance& indicationInstance) { // Save the objects for the main code to verify indication = indicationInstance; indicationContext = context; // Signal the main code that the indication was received indicationReceived.signal(); } /////////////////////////////////////////////////////////////////////////// /** ErrorExit - Print out the error message as an and get out. @param - Text for error message @return - None, Terminates the program @execption - This function terminates the program ATTN: Should write to stderr */ void ErrorExit(const String& message) { cout << message << endl; exit(1); } /* Status display of the various steps. Shows message of function and time to execute. Grow this to a class so we have start and stop and time display with success/failure for each function. */ static void testStart(const String& message) { cout << "++++ " << message << " ++++" << endl; } static void testEnd(const double elapsedTime) { cout << "In " << elapsedTime << " Seconds\n\n"; } /* Tests the UTF support in the repository */ static void TestUTFRepository( CIMClient& client, Boolean utfRepNames, Boolean activeTest, Boolean verboseTest ) { if (!activeTest) { cout << "Active tests are disabled." " Nothing to do for this set of tests." << endl; return; } const CIMNamespaceName NAMESPACE = CIMNamespaceName ("test/TestProvider"); const CIMNamespaceName ROOT_NAMESPACE = CIMNamespaceName ("root"); try { // The repository does not support these headers and will throw errors // if they are used. client.setRequestAcceptLanguages(AcceptLanguageList()); client.setRequestContentLanguages(ContentLanguageList()); String utf16String(utf16Chars); String utf16FileName(utfRepChars); // // TEST 1 - Create qualifier // Create a qualifier with UTF-16 in the qualifier name, // and value // This will test UTF support in the repository. // cout << endl << "REPOSITORY TEST 1: Create Qualifier containing UTF-16 chars" << endl; // Decide whether to use UTF-16 in the name of the qualifier CIMName qualDeclName("UTFTestQualifier"); if (!utfRepNames) { cout<< "Note: utfrep option was not set." " Not using UTF-16 in the qualifier name" << endl; } else { if (verboseTest) cout << "Using UTF-16 in the qualifier name" << endl; // This will create a repository file with UTF-8 chars in the name qualDeclName = utf16FileName; } // First, delete the qualifier if it was there from before if (verboseTest) cout << "Deleting the qualifier in case it was there from before" << endl; try { client.deleteQualifier(NAMESPACE, qualDeclName); } catch (CIMException & e) { if (e.getCode() != CIM_ERR_NOT_FOUND) throw; } if (verboseTest) cout << "Creating the qualifier" << endl; CIMQualifierDecl qualDecl(qualDeclName, utf16String, CIMScope::PROPERTY + CIMScope::CLASS, CIMFlavor::OVERRIDABLE); client.setQualifier(NAMESPACE, qualDecl); if (verboseTest) cout << "Getting the qualifier that was just created" << endl; CIMQualifierDecl rtnQualDecl = client.getQualifier( NAMESPACE, qualDeclName); if (verboseTest) cout << "Checking that UTF-16 was preserved" << endl; MYASSERT(qualDecl.identical(rtnQualDecl)); if (verboseTest) cout << "Enumerating qualifiers, and looking for the UTF-16 one" << endl; Array<CIMQualifierDecl> rtnQualDeclArray = client.enumerateQualifiers( NAMESPACE ); Boolean foundQualDecl = false; for (Uint32 i = 0; i < rtnQualDeclArray.size(); i++) { if (qualDecl.identical(rtnQualDeclArray[i])) foundQualDecl = true; } MYASSERT(foundQualDecl == true); // // TEST 2 - Create class // Create a class with UTF-16 in the class name, // property names, and qualifiers. // // We will use the UTF16 qualifier created above // in this class. // // This will test UTF support in the repository. // cout << endl << "REPOSITORY TEST 2: Create Class containing UTF-16 chars" << endl; // Decide whether to use UTF-16 in the name of the class CIMName className("UTFTestClass"); if (!utfRepNames) { cout << "Note: utfrep option was not set." " Not using UTF-16 in the class name" << endl; } else { if (verboseTest) cout << "Using UTF-16 in the class name" << endl; // This will create a repository file with UTF-8 chars in the name className = utf16FileName; } // First, delete the class if it was there from before if (verboseTest) cout << "Deleting the class in case it was there from before" << endl; try { client.deleteClass(NAMESPACE, className); } catch (CIMException & e) { if (e.getCode() != CIM_ERR_NOT_FOUND) throw; } if (verboseTest) cout << "Creating the class" << endl; // How did this get so ugly? CIMClass cimClass(className, CIMName ("CIM_ManagedElement")); CIMName name1("fred"); CIMName name2(utf16String); CIMValue fred("fred"); CIMName key("key"); CIMProperty prop1(name1, fred); CIMQualifier qual1(key, true); CIMProperty prop2 = prop1.addQualifier(qual1); cimClass.addProperty(prop2); CIMProperty prop3(name2, fred); // UTF16 prop name CIMQualifier qual2(qualDecl.getName(), // UTF16 qualifier qualDecl.getValue(), qualDecl.getFlavor()); CIMProperty prop4 = prop3.addQualifier(qual2); cimClass.addProperty(prop4); client.createClass(NAMESPACE, cimClass); if (verboseTest) cout << "Getting the class that was just created" << endl; CIMClass rtnClass = client.getClass( NAMESPACE, className, true, true); if (verboseTest) cout << "Checking that the UTF-16 was preserved in the property" " name" << endl; Uint32 idx = rtnClass.findProperty(name2); // name2 is UTF16 MYASSERT(idx != PEG_NOT_FOUND); if (verboseTest) cout << "Checking that the UTF-16 was preserved in the qualifier" << endl; CIMProperty rtnProp = rtnClass.getProperty(idx); idx = rtnProp.findQualifier(qualDecl.getName()); MYASSERT(idx != PEG_NOT_FOUND); CIMQualifier rtnQual = rtnProp.getQualifier(idx); MYASSERT(rtnQual.getValue() == utf16String); if (verboseTest) cout << "Modifying the class" << endl; CIMName name3("anotherprop"); CIMProperty prop5(name3, fred); CIMQualifier qual3(qualDecl.getName(), // UTF16 qualifier qualDecl.getValue(), qualDecl.getFlavor()); CIMProperty prop6 = prop5.addQualifier(qual3); cimClass.addProperty(prop6); client.modifyClass(NAMESPACE,cimClass); if (verboseTest) cout << "Getting the class that was just modified" << endl; rtnClass = client.getClass( NAMESPACE, className, true, true); if (verboseTest) cout << "Checking that the UTF-16 was preserved in the property" " name" << endl; idx = rtnClass.findProperty(name2); // name2 is UTF16 MYASSERT(idx != PEG_NOT_FOUND); idx = rtnClass.findProperty(name3); MYASSERT(idx != PEG_NOT_FOUND); if (verboseTest) cout << "Checking that the UTF-16 was preserved in the qualifier" << endl; rtnProp = rtnClass.getProperty(idx); idx = rtnProp.findQualifier(qualDecl.getName()); MYASSERT(idx != PEG_NOT_FOUND); rtnQual = rtnProp.getQualifier(idx); MYASSERT(rtnQual.getValue() == utf16String); // // Clean up the repository // if (verboseTest) cout << endl << "Cleaning up the repository" << endl; if (verboseTest) cout << "Deleting the class" << endl; client.deleteClass(NAMESPACE, className); if (verboseTest) cout << "Delete the qualifier" << endl; client.deleteQualifier(NAMESPACE, qualDeclName); // // TEST 3 - Create namespace // // Create a namespace with UTF-16 in the namespace name, and // add class to the namespace. // cout << endl << "REPOSITORY TEST 3: Create Namespace with UTF-16 chars in the" " name" << endl; if (!utfRepNames) { // Since namespaces are only directory names, no point in doing this // if the utfrep option wasn't set. cout << "Note: Skipping this test because the utfrep option was" " not used" << endl; } else { if (verboseTest) cout << endl << "Deleting the old namespace in case it was there from" " before." << endl; CIMName __nameSpace = "__NameSpace"; Array<CIMObjectPath> enumNamespaces = client.enumerateInstanceNames( CIMNamespaceName("root"), __nameSpace); for (Uint32 i = 0; i < enumNamespaces.size(); i++) { Array<CIMKeyBinding> kb = enumNamespaces[i].getKeyBindings(); if (kb[0].getValue() == utf16FileName) { client.deleteInstance(ROOT_NAMESPACE, enumNamespaces[i]); } } if (verboseTest) cout << endl << "Creating the namespace" << endl; CIMInstance nsInstance(__nameSpace); CIMName nsPropName("Name"); CIMProperty nsProp(nsPropName, CIMValue(utf16FileName)); nsInstance.addProperty(nsProp); CIMObjectPath nsInstanceName = client.createInstance(ROOT_NAMESPACE, nsInstance); if (verboseTest) cout << endl << "Getting the namespace just created" << endl; CIMInstance rtnNSInst = client.getInstance(ROOT_NAMESPACE, nsInstanceName); idx = rtnNSInst.findProperty(nsPropName); MYASSERT(idx != PEG_NOT_FOUND); CIMProperty rtnNSProp = rtnNSInst.getProperty(idx); String rtnNSName; rtnNSProp.getValue().get(rtnNSName); MYASSERT(rtnNSName == utf16FileName); if (verboseTest) cout << endl << "Creating classes in that namespace" << endl; String root("root/"); root.append(utf16FileName); CIMNamespaceName ns(root); // Do a little inheriting with UTF-16 class names CIMName baseClassName(utf16FileName); CIMClass baseClass(baseClassName); CIMName basePropName("baseProp1"); CIMValue basePropValue("fred"); CIMProperty baseProp(basePropName, basePropValue); baseClass.addProperty(baseProp); CIMName inhClassName(&utf16Chars[1]); CIMClass inhClass(inhClassName, baseClassName); CIMName inhPropName("inhProp1"); CIMValue inhPropValue("fred"); CIMProperty inhProp(inhPropName, inhPropValue); inhClass.addProperty(inhProp); client.createClass(ns, baseClass); client.createClass(ns, inhClass); if (verboseTest) cout << endl << "Deleting classes in that namespace" << endl; client.deleteClass(ns, inhClassName); client.deleteClass(ns, baseClassName); if (verboseTest) cout << endl << "Deleting the namespace" << endl; client.deleteInstance(ROOT_NAMESPACE, nsInstanceName); } // endif utfrep } catch(Exception& e) { PEGASUS_STD(cerr) << "Error in TestLocalizedRepository: " << e.getMessage() << PEGASUS_STD(endl); throw; } } /* Tests the globalization support of the LocalizedProvider for the method operations */ static void TestLocalizedMethods( CIMClient& client, Boolean activeTest, Boolean verboseTest ) { const CIMNamespaceName NAMESPACE = CIMNamespaceName ("test/TestProvider"); const CIMName CLASSNAME = CIMName ("Test_LocalizedProviderClass"); const String INPARAM1 = "inStr"; const String INPARAM2 = "inChar16"; const CIMName METHOD = CIMName("UTFMethod"); const CIMObjectPath REFERENCE = CIMObjectPath("Test_LocalizedProviderClass.Identifier=0"); // Array of UTF-16 chars to be sent and received to the server. // Note: the first 3 chars are taken from section 3.3.2 of the // CIM-over-HTTP spec. // The next 2 chars are a UTF-16 surrogate pair Char16 hangugo[] = {0xD55C, 0xAD6D, 0xC5B4, 0xdbc0, 0xdc01, 'g','l','o','b','a','l', 0x00}; try { // Before we begin, set the language objects to be sent to the provider AcceptLanguageList AL_DE; AL_DE.insert(LanguageTag("de"), Real32(0.8)); ContentLanguageList CL_DE; CL_DE.append(LanguageTag("de")); client.setRequestAcceptLanguages(AL_DE); client.setRequestContentLanguages(CL_DE); // // TEST 1 - Invoke Method with UTF-16 in input parameters, // output parameters and return value. // // This will also check that Accept-Language and Content-Language are // are sent to and received from a Method Provider. cout << endl << "METHOD TEST 1: Invoke Method with UTF-16 parameters" << endl; // Strings sent to the provider String inString(utf16Chars); Char16 inChar16 = utf16Chars[1]; // Expected strings from the provider String outString(utf16Chars); Char16 outChar16 = utf16Chars[2]; String expectedRtnString(utf16Chars); // Strings returned by the provider String rtnString; String outParam1; Char16 outParam2; Array<CIMParamValue> inParams; Array<CIMParamValue> outParams; inParams.append( CIMParamValue( INPARAM1, CIMValue( inString ) ) ); inParams.append( CIMParamValue( INPARAM2, CIMValue( inChar16 ) ) ); if (verboseTest) cout << "Invoking the method" << endl; CIMValue retValue = client.invokeMethod( NAMESPACE, REFERENCE, METHOD, inParams, outParams); if (verboseTest) cout << "Checking for UTF-16 chars returned" << endl; retValue.get(rtnString); MYASSERT (expectedRtnString == rtnString); CIMValue paramVal = outParams[0].getValue(); paramVal.get( outParam1 ); MYASSERT (outString == outParam1); paramVal = outParams[1].getValue(); paramVal.get( outParam2 ); MYASSERT (outChar16 == outParam2); if (verboseTest) cout << "Checking returned Content-Language = " << LanguageParser::buildContentLanguageHeader(CL_DE) << endl; MYASSERT(CL_DE == client.getResponseContentLanguages()); // // TEST 2 - Invoke method with UTF-16 in the method name. // // This will test the URI encoding and decoding of UTF-8 in the // CIMMethod HTTP header cout << endl << "METHOD TEST 2: Invoke Method with UTF-16 method name" << endl; String methodName(hangugo); if (verboseTest) cout << "Invoking the method" << endl; CIMValue retValue1 = client.invokeMethod( NAMESPACE, REFERENCE, methodName, inParams, outParams); // Check UTF-16 in the return value just to make sure that the method // was called on the provider. String expectedRtnString1(hangugo); String rtnString1; if (verboseTest) cout << "Checking for UTF-16 chars returned" << endl; retValue1.get(rtnString1); MYASSERT (expectedRtnString1 == rtnString1); } catch(Exception& e) { PEGASUS_STD(cerr) << "Error in TestLocalizedMethod: " << e.getMessage() << PEGASUS_STD(endl); throw; } } /* Enumerates instances of the sample classes using a given AcceptLanguageList, and checks the language of the response. */ static Array<CIMInstance> EnumerateTestInstances(CIMClient &client, AcceptLanguageList & acceptLangs, ContentLanguageList & contentLangs, String & expectedStr, Boolean verboseTest) { const CIMNamespaceName NAMESPACE = CIMNamespaceName ("test/TestProvider"); const CIMName CLASSNAME = CIMName ("Test_LocalizedProviderClass"); Boolean deepInheritance = false; Boolean localOnly = false; Boolean includeQualifiers = true; Boolean includeClassOrigin = false; ContentLanguageList CL_EN; CL_EN.append(LanguageTag("en")); const String RBPROP = "ResourceBundleString"; String expectedDftString = "ResourceBundleString DEFAULT"; client.setRequestAcceptLanguages(acceptLangs); Array<CIMInstance> cimNInstances = client.enumerateInstances(NAMESPACE, CLASSNAME, deepInheritance, localOnly, includeQualifiers, includeClassOrigin ); if (verboseTest) cout << "Found " << cimNInstances.size() << " Instances of " << CLASSNAME.getString() << endl; MYASSERT(cimNInstances.size() == 3); if (skipICU) { if (verboseTest) cout << "Checking expected response ContentLanguageList: " << LanguageParser::buildContentLanguageHeader(CL_EN) << endl; // Note - the LocalizedProvider is setting en in Content-Languages // to override the MessageLoader. // Otherwise, Content-Languages would be empty since Accept-Languages // was empty. MYASSERT(CL_EN == client.getResponseContentLanguages()); } else { if (verboseTest) cout << "Checking expected response ContentLanguageList: " << LanguageParser::buildContentLanguageHeader(contentLangs) << endl; MYASSERT(contentLangs == client.getResponseContentLanguages()); } if (verboseTest) cout << "Checking the returned string in each instance" << endl; for (Uint32 k = 0; k < cimNInstances.size(); k++) { String enumString; cimNInstances[k].getProperty (cimNInstances[k].findProperty(RBPROP)). getValue(). get(enumString); if (skipICU) { MYASSERT(expectedDftString == enumString); } else { MYASSERT(expectedStr == enumString); } } return cimNInstances; } /* Tests the globalization support of the LocalizedProvider for the instance operations */ static void TestLocalizedInstances( CIMClient& client, Boolean activeTest, Boolean verboseTest ) { const CIMNamespaceName NAMESPACE = CIMNamespaceName ("test/TestProvider"); const CIMName CLASSNAME = CIMName ("Test_LocalizedProviderClass"); const CIMName SUBCLASSNAME = CIMName ("Test_LocalizedProviderSubClass"); const String INSTANCE0 = "instance 0Test_LocalizedProviderClass"; const String INSTANCE1 = "instance 1Test_LocalizedProviderClass"; const String RBPROP = "ResourceBundleString"; const String ROUNDTRIPSTRINGPROP = "RoundTripString"; const String ROUNDTRIPCHARPROP = "RoundTripChar"; const String CLPROP = "ContentLanguageString"; const String TESTSTRINGPROP = "TestString"; const String IDPROP = "Identifier"; ContentLanguageList CL_DE; CL_DE.append(LanguageTag("de")); String expectedDEString = "ResourceBundleString DE"; ContentLanguageList CL_FR; CL_FR.append(LanguageTag("fr")); String expectedFRString = "ResourceBundleString FR"; ContentLanguageList CL_Dft; ContentLanguageList CL_EN; CL_EN.append(LanguageTag("en")); String expectedDftString = "ResourceBundleString DEFAULT"; ContentLanguageList CL_HOMER; CL_HOMER.append(LanguageTag("x-homer")); ContentLanguageList CL_ES; CL_ES.append(LanguageTag("es")); String expectedUTF16String(utf16Chars); try { const CIMName className = CLASSNAME; Boolean localOnly = false; Boolean includeQualifiers = true; Boolean includeClassOrigin = false; Uint32 testRepeat = 1; if (verboseTest) cout << "Getting class: " << CLASSNAME.getString() << endl; CIMClass sampleClass = client.getClass( NAMESPACE, CLASSNAME, localOnly, includeQualifiers, includeClassOrigin); CIMClass sampleSubClass = client.getClass( NAMESPACE, SUBCLASSNAME, localOnly, includeQualifiers, includeClassOrigin); // Note: When Pegasus has external message files enabled, // then the provider has message files for fr, de, // and es, but no root message file. The missing root // message file will cause us to test the default message // strings compiled into the code. for (Uint32 q = 0; q < testRepeat; q++) // repeat the test x time { // // TEST 1 - Enumerate Instances of the base class, // deepInheritance == false. // de is supported by the provider, and is the most preferred // by us. // AcceptLanguageList acceptLangs1; if (skipICU) { // Not requesting translated messages from the provider acceptLangs1.clear(); } else { acceptLangs1.insert(LanguageTag("fr"), Real32(0.5)); acceptLangs1.insert(LanguageTag("de"), Real32(0.8)); acceptLangs1.insert(LanguageTag("es"), Real32(0.4)); } cout << endl << "INSTANCE TEST 1: Enumerate Instances with" " AcceptLanguageList = " << LanguageParser::buildAcceptLanguageHeader(acceptLangs1) << endl; Array<CIMInstance> cimNInstances = EnumerateTestInstances( client, acceptLangs1, CL_DE, expectedDEString, verboseTest); // // TEST 2 - Aggregation Test - // Enumerate Instances starting at the base class, // with deep inheritance, where each instance has // the same language. // This will test that the languages of the instances are // aggregated into the Content-Language of the whole response. // // (tests ContentLanguage aggregation in // CIMOperationRequestDispatcher) cout << endl << "INSTANCE TEST 2: Enumerate Instances with" " Content-Language match" << endl; AcceptLanguageList acceptLangs2; if (skipICU) { // Not requesting translated messages from the provider acceptLangs2.clear(); } else { acceptLangs2.insert(LanguageTag("de"), Real32(0.8)); } client.setRequestAcceptLanguages(acceptLangs2); Array<CIMInstance> cimNInstances2 = client.enumerateInstances(NAMESPACE, className, true, false, includeQualifiers, includeClassOrigin); if (verboseTest) cout << "Found " << cimNInstances2.size() << " Instances of " << className.getString() << endl; MYASSERT(cimNInstances2.size() == 3); if (skipICU) { if (verboseTest) cout << "Checking expected response ContentLanguageList: " << LanguageParser::buildContentLanguageHeader(CL_EN) << endl; MYASSERT(CL_EN == client.getResponseContentLanguages()); } else { if (verboseTest) cout << "Checking expected response ContentLanguageList: " << LanguageParser::buildContentLanguageHeader(CL_DE) << endl; MYASSERT(CL_DE == client.getResponseContentLanguages()); } // // TEST 3 - Aggregation Test - Enumerate Instances with deep // inheritance, where the instances do not have the same language. // Since the languages of the instances // do not match, we expect the ContentLanguage of the // whole response to be empty. // This will test that the languages of the instances are // aggregated into the Content-Language of the whole response. // // We will modify the language of the sub-class instance, // and then do the enumerate. // // (tests ContentLanguage aggregation in // CIMOperationRequestDispatcher) // cout << endl << "INSTANCE TEST 3: Enumerate Instances with" " Content-Language mismatch" << endl; if (!activeTest) { cout << "Active tests are disabled. Nothing to do for" " this test." << endl; } else { // First, find the instance of the sub-class Uint32 i = 0; for (; i < cimNInstances2.size(); i++) { if (cimNInstances2[i].getClassName() == SUBCLASSNAME) { break; } } MYASSERT(i != cimNInstances2.size()); if (verboseTest) cout << "Modifying the language of an instance of the" " subclass to " << LanguageParser::buildContentLanguageHeader(CL_HOMER) << endl; client.setRequestContentLanguages(CL_HOMER); client.modifyInstance(NAMESPACE, cimNInstances2[i], includeQualifiers); // Enumerate the instances starting at the base class, // with deep inheritance. AcceptLanguageList acceptLangs3; acceptLangs3.insert(LanguageTag("x-homer"), Real32(0.8)); client.setRequestAcceptLanguages(acceptLangs3); Array<CIMInstance> cimNInstances3 = client.enumerateInstances(NAMESPACE, className, true, false, includeQualifiers, includeClassOrigin ); if (verboseTest) cout << "Found " << cimNInstances3.size() << " Instances of " << className.getString() << endl; MYASSERT(cimNInstances3.size() == 3); if (verboseTest) cout << "Checking expected empty response" " ContentLanguageList" << endl; MYASSERT(client.getResponseContentLanguages().size() == 0); } // else active tests // // TEST 4 - Get Instance, check default language returned. // None of our preferred languages is supported by the // provider, and the root message file is empty. Expect // the compiled-in default strings from the provider. // AcceptLanguageList acceptLangs4; acceptLangs4.insert(LanguageTag("x-martian"), Real32(0.8)); acceptLangs4.insert(LanguageTag("x-pig-latin"), Real32(0.1)); acceptLangs4.insert(LanguageTag("x-men"), Real32(0.4)); client.setRequestAcceptLanguages(acceptLangs4); cout << endl << "INSTANCE TEST 4: Get Instance with AcceptLanguageList = " << LanguageParser::buildAcceptLanguageHeader(acceptLangs4) << endl; // Find an instance of the base-class from the first enumerate Uint32 j = 0; for (; j < cimNInstances.size(); j++) { if (cimNInstances[j].getClassName() == CLASSNAME) { break; } } MYASSERT(j != cimNInstances.size()); // Get the instance. Note, baseInstance is used later CIMObjectPath baseObjectPath = cimNInstances[j].buildPath(sampleClass); CIMInstance baseInstance = client.getInstance( NAMESPACE, baseObjectPath, localOnly, includeQualifiers, includeClassOrigin); // update base instance object path // (it's not set by the cimom or client) baseInstance.setPath(baseObjectPath); String returnedString; Char16 returnedChar16; baseInstance.getProperty (baseInstance.findProperty(RBPROP)). getValue(). get(returnedString); if (verboseTest) cout << "Checking for default language returned" << endl; MYASSERT(expectedDftString == returnedString); // // TEST 5 - Get Instance, check fr language returned. // fr is the lowest preferred language from us, but // is the only one in the list supported by the provider. // AcceptLanguageList acceptLangs5; if (skipICU) { // Not requesting translated messages from the provider acceptLangs5.clear(); } else { acceptLangs5.insert(LanguageTag("x-martian"), Real32(0.8)); acceptLangs5.insert(LanguageTag("fr"), Real32(0.1)); acceptLangs5.insert(LanguageTag("x-men"), Real32(0.4)); } client.setRequestAcceptLanguages(acceptLangs5); cout << endl << "INSTANCE TEST 5: Get Instance with AcceptLanguageList = " << LanguageParser::buildAcceptLanguageHeader(acceptLangs5) << endl; CIMInstance instance5 = client.getInstance( NAMESPACE, cimNInstances[1].buildPath(sampleClass), localOnly, includeQualifiers, includeClassOrigin); instance5.getProperty (instance5.findProperty(RBPROP)). getValue(). get(returnedString); if (skipICU) { if (verboseTest) cout << "Checking for default language returned" << endl; MYASSERT(CL_EN == client.getResponseContentLanguages()); MYASSERT(expectedDftString == returnedString); } else { if (verboseTest) cout << "Checking for fr returned" << endl; MYASSERT(CL_FR == client.getResponseContentLanguages()); MYASSERT(expectedFRString == returnedString); } // // TEST 6 - Round trip Test. // Create Instance followed by Get Instance. // // Create with an fr string and expect that // the fr string is preserved on get instance. // (fr is one of the supported languages of the provider) // // Create with a UTF-16 string and char16 and expect that they // are preserved on get instance // cout << endl << "INSTANCE TEST 6: Create Instance with" " ContentLanguageList = " << LanguageParser::buildContentLanguageHeader(CL_FR) << " and UTF-16 string." << endl; if (!activeTest) { cout << "Active tests are disabled. Nothing to do for" " this test." << endl; } else { String oui = "Oui"; CIMInstance frInstance(CLASSNAME); frInstance.addProperty(CIMProperty(CIMName(CLPROP), oui)); frInstance.addProperty( CIMProperty( CIMName(ROUNDTRIPSTRINGPROP), String(utf16Chars))); frInstance.addProperty( CIMProperty(CIMName(ROUNDTRIPCHARPROP), utf16Chars[0])); frInstance.addProperty(CIMProperty(CIMName(IDPROP), Uint8(3))); CIMObjectPath frInstanceName = frInstance.buildPath(sampleClass); frInstance.setPath(frInstanceName); client.setRequestContentLanguages(CL_FR); if (verboseTest) cout << "Creating the instance" << endl; client.createInstance(NAMESPACE, frInstance); AcceptLanguageList acceptLangs6; acceptLangs6.insert(LanguageTag("x-martian"), Real32(0.8)); acceptLangs6.insert(LanguageTag("fr"), Real32(0.1)); acceptLangs6.insert(LanguageTag("x-men"), Real32(0.4)); client.setRequestAcceptLanguages(acceptLangs6); if (verboseTest) cout << "Getting the instance just created," " using AcceptLanguageList = " << LanguageParser::buildAcceptLanguageHeader( acceptLangs6) << endl; CIMInstance instance6 = client.getInstance( NAMESPACE, frInstanceName, localOnly, includeQualifiers, includeClassOrigin); instance6.getProperty ( instance6.findProperty(ROUNDTRIPSTRINGPROP)). getValue(). get(returnedString); instance6.getProperty ( instance6.findProperty(ROUNDTRIPCHARPROP)). getValue(). get(returnedChar16); if (verboseTest) cout << "Checking the UTF-16 chars were preserved" << endl; MYASSERT(expectedUTF16String == returnedString); MYASSERT(utf16Chars[0] == returnedChar16); instance6.getProperty (instance6.findProperty(CLPROP)). getValue(). get(returnedString); if (verboseTest) cout << "Checking for fr returned" << endl; MYASSERT(oui == returnedString); MYASSERT(CL_FR == client.getResponseContentLanguages()); // Delete the instance for the next pass if (verboseTest) cout << "Deleting the instance" << endl; client.deleteInstance( NAMESPACE, frInstanceName); } // end else active tests // // TEST 7 - Round trip Test. // Modify Instance followed by Get Instance. // // Modify an instance of the base class with an x-homer language // string and expect that the x-homer string is preserved on get // instance. // (x-homer is not one of the supported languages of the provider // but still should be returned when asked for) // // Modify baseInstance with a UTF-16 string and // char16 and expect that they are preserved on get instance // cout << endl << "INSTANCE TEST 7: Modify Instance with" " ContentLanguageList = " << LanguageParser::buildContentLanguageHeader(CL_HOMER) << " and UTF-16 string." << endl; if (!activeTest) { cout << "Active tests are disabled. Nothing to do for this test." << endl; } else { String doh = "doh!"; baseInstance.removeProperty (baseInstance.findProperty(CLPROP)); baseInstance.addProperty(CIMProperty(CIMName(CLPROP), doh)); baseInstance.removeProperty ( baseInstance.findProperty(ROUNDTRIPSTRINGPROP)); baseInstance.addProperty(CIMProperty( CIMName(ROUNDTRIPSTRINGPROP), String(utf16Chars))); baseInstance.removeProperty ( baseInstance.findProperty(ROUNDTRIPCHARPROP)); baseInstance.addProperty( CIMProperty(CIMName(ROUNDTRIPCHARPROP),utf16Chars[0])); client.setRequestContentLanguages(CL_HOMER); if (verboseTest) cout << "Modifying the instance" << endl; client.modifyInstance(NAMESPACE, baseInstance, includeQualifiers); AcceptLanguageList acceptLangs7; acceptLangs7.insert(LanguageTag("x-homer"), Real32(0.8)); client.setRequestAcceptLanguages(acceptLangs7); if (verboseTest) cout << "Getting the instance just modified," " using AcceptLanguageList = " << LanguageParser::buildAcceptLanguageHeader( acceptLangs7) << endl; CIMInstance instance7 = client.getInstance( NAMESPACE, baseInstance.buildPath(sampleClass), localOnly, includeQualifiers, includeClassOrigin); instance7.getProperty ( instance7.findProperty(ROUNDTRIPSTRINGPROP)). getValue(). get(returnedString); instance7.getProperty ( instance7.findProperty(ROUNDTRIPCHARPROP)). getValue(). get(returnedChar16); if (verboseTest) cout << "Checking the UTF-16 chars were preserved" << endl; MYASSERT(expectedUTF16String == returnedString); MYASSERT(utf16Chars[0] == returnedChar16); instance7.getProperty ( instance7.findProperty(CLPROP)). getValue(). get(returnedString); if (verboseTest) cout << "Checking for x-homer returned" << endl; MYASSERT(returnedString == doh); MYASSERT(CL_HOMER == client.getResponseContentLanguages()); } // end else active tests // // TEST 8 - Exception test. // Expect an exception to be returned from the server // with a localized message in es locale. // // Note: the provider will throw a not-supported exception // on delete instance requests. // AcceptLanguageList acceptLangs8; if (skipICU) { // Not requesting translated messages from the provider acceptLangs8.clear(); } else { acceptLangs8.insert(LanguageTag("es"), Real32(1.0)); acceptLangs8.insert(LanguageTag("fr"), Real32(0.9)); } client.setRequestAcceptLanguages(acceptLangs8); cout << endl << "INSTANCE TEST 8: Delete Instance with" " AcceptLanguageList = " << LanguageParser::buildAcceptLanguageHeader(acceptLangs8) << endl; // Try to delete baseInstance, expect an exception if (verboseTest) cout << "Deleting the instance, expecting to get a CIMException" << endl; Boolean gotException = false; try { client.deleteInstance( NAMESPACE, baseInstance.buildPath(sampleClass)); } catch (CIMException & ce) { if (verboseTest) cout << "Got the CIMException" << endl; String message = ce.getMessage(); if(skipICU) { if (verboseTest) cout << "Checking for default language returned in the " "exception" << endl; MYASSERT(CL_Dft == client.getResponseContentLanguages()); Uint32 n = message.find("default"); MYASSERT(n != PEG_NOT_FOUND); } else { if (verboseTest) cout << "Checking for es returned in the exception" << endl; MYASSERT(CL_ES == client.getResponseContentLanguages()); MYASSERT(CL_ES == ce.getContentLanguages()); Uint32 n = message.find("ES"); MYASSERT(n != PEG_NOT_FOUND); } gotException = true; } MYASSERT(gotException == true); } // end for } catch(Exception& e) { PEGASUS_STD(cerr) << "Error in TestLocalizedInstances: " << e.getMessage() << PEGASUS_STD(endl); throw; } } /* Tests the globalization support of the Pegasus server by sending requests that cause error messages to be returned. */ static void TestServerMessages( CIMClient& client, String reqLang, String rspLang, Boolean activeTest, Boolean verboseTest ) { try { // // Vars for the getClass test // // Build the Accept-Languages for the getClass request using the lang // specified by the user AcceptLanguageList acceptLangs1; if (reqLang.size() > 0) { acceptLangs1 = LanguageParser::parseAcceptLanguageHeader(reqLang); } // This is the "class not found" message expected back from the server. // Since we don't know what the message text will be for a given // langauge, we will use the message returned on the first request // as the expected message for subsequent requests. String expectedMsg; // This is the language of the "class not found" message back // from the server, as specified by the user ContentLanguageList expectedCL; if (rspLang.size() > 0) { expectedCL = LanguageParser::parseContentLanguageHeader(rspLang); } // // Vars for enumerate sample instances test // // Build the Accept-Languages for the enumerate sample instances test AcceptLanguageList acceptLangsDE; if (skipICU) { // Not requesting translated messages from the provider acceptLangsDE.clear(); } else { acceptLangsDE.insert(LanguageTag("de"), Real32(0.1)); acceptLangsDE.insert(LanguageTag("x-aa"), Real32(0.2)); acceptLangsDE.insert(LanguageTag("x-bb"), Real32(0.3)); } AcceptLanguageList acceptLangsFR; if (skipICU) { // Not requesting translated messages from the provider acceptLangsFR.clear(); } else { acceptLangsFR.insert(LanguageTag("fr"), Real32(0.1)); acceptLangsFR.insert(LanguageTag("x-aa"), Real32(0.2)); acceptLangsFR.insert(LanguageTag("x-bb"), Real32(0.3)); } AcceptLanguageList acceptLangsES; if (skipICU) { // Not requesting translated messages from the provider acceptLangsES.clear(); } else { acceptLangsES.insert(LanguageTag("es"), Real32(0.1)); acceptLangsES.insert(LanguageTag("x-aa"), Real32(0.2)); acceptLangsES.insert(LanguageTag("x-bb"), Real32(0.3)); } // The expected results from the enumerate ContentLanguageList CL_DE; CL_DE.append(LanguageTag("de")); String expectedDEString = "ResourceBundleString DE"; ContentLanguageList CL_FR; CL_FR.append(LanguageTag("fr")); String expectedFRString = "ResourceBundleString FR"; ContentLanguageList CL_ES; CL_ES.append(LanguageTag("es")); String expectedESString = "ResourceBundleString ES"; cout << endl << "SERVER MESSAGE TESTS: Send requests that test" " server language support" << endl; // Do a loop of requests. This is useful when several instances of this // program are run simultaneously, each with a different language. for (int i = 0; i < 100; i ++) { // // TEST 1 - Cause localized error message. // // Attempt to create a PG_ProviderModule instance with no Name // property. Expect the error message to be returned in the // language specified by the user. // try { client.setRequestAcceptLanguages(acceptLangs1); CIMInstance inst("PG_ProviderModule"); client.createInstance( PEGASUS_NAMESPACENAME_INTEROP.getString(), inst); // should not get here throw Exception( "did not get expected exception for missing Name property"); } catch (CIMException& ce) { if (ce.getCode() == CIM_ERR_INVALID_PARAMETER) { if ((String::compare( ce.getMessage(), "CIM_ERR_INVALID_PARAMETER", strlen("CIM_ERR_INVALID_PARAMETER")) != 0) || (ce.getMessage().size() == strlen("CIM_ERR_INVALID_PARAMETER"))) { throw; } if (i == 0) { // Since we don't know the text of the server message in // each language, save the message on the first request expectedMsg = ce.getMessage(); if (verboseTest) cout << "Note: Expecting message = " << expectedMsg << " from the server" << endl; } // Verify the message and the content languages returned MYASSERT(expectedMsg == ce.getMessage()); MYASSERT(expectedCL == client.getResponseContentLanguages()); MYASSERT(expectedCL == ce.getContentLanguages()); } else { // Didn't get the expected error for "class not found" throw; } } // end catch // // TEST 2 - Enumerate instances of the sample classes using // differentlanguages. // // Enumerate instances of the sample classes, alternating the // Accept-Language used among the languages supported by the // LocalizedProvider. When multiple instance of this program // are run simultaneously, this test // will exercise multi-language support in the server. // switch (i % 3) { case 0: // if (verboseTest) // cout << "Sending the enumerate instance request " << i << // ". Lang = " << acceptLangsDE.toString() << endl; EnumerateTestInstances( client, acceptLangsDE, CL_DE, expectedDEString, false); // don't get too verbose break; case 1: // if (verboseTest) // cout << "Sending the enumerate instance request " << i << // ". Lang = " << acceptLangsFR.toString() << endl; EnumerateTestInstances( client, acceptLangsFR, CL_FR, expectedFRString, false); // don't get too verbose break; case 2: // if (verboseTest) // cout << "Sending the enumerate instance request " << i << // ". Lang = " << acceptLangsES.toString() << endl; EnumerateTestInstances( client, acceptLangsES, CL_ES, expectedESString, false); // don't get too verbose break; } } // endfor } catch (InvalidAcceptLanguageHeader& ialh) { PEGASUS_STD(cerr) << "Invalid lang parameter was entered: " << ialh.getMessage() << PEGASUS_STD(endl); throw; } catch (InvalidContentLanguageHeader& iclh) { PEGASUS_STD(cerr) << "Invalid expectlang parameter was entered: " << iclh.getMessage() << PEGASUS_STD(endl); throw; } catch(Exception& e) { PEGASUS_STD(cerr) << "Error in TestServerMessages: " << e.getMessage() << PEGASUS_STD(endl); throw; } } /* Builds a filter or handler object path */ static CIMObjectPath buildFilterOrHandlerPath (const CIMName & className, const String & name) { CIMObjectPath path; Array <CIMKeyBinding> keyBindings; keyBindings.append (CIMKeyBinding ("SystemCreationClassName", System::getSystemCreationClassName (), CIMKeyBinding::STRING)); keyBindings.append (CIMKeyBinding ("SystemName", System::getFullyQualifiedHostName (), CIMKeyBinding::STRING)); keyBindings.append (CIMKeyBinding ("CreationClassName", className.getString(), CIMKeyBinding::STRING)); keyBindings.append (CIMKeyBinding ("Name", name, CIMKeyBinding::STRING)); path.setClassName (className); path.setKeyBindings (keyBindings); return path; } /* Builds a subscription object path */ static CIMObjectPath buildSubscriptionObjectPath (const CIMObjectPath & filterPath, const CIMObjectPath & handlerPath) { CIMObjectPath path; Array <CIMKeyBinding> keyBindings; keyBindings.append (CIMKeyBinding ("Filter", filterPath.toString (), CIMKeyBinding::REFERENCE)); keyBindings.append (CIMKeyBinding ("Handler", handlerPath.toString (), CIMKeyBinding::REFERENCE)); path.setClassName (PEGASUS_CLASSNAME_INDSUBSCRIPTION); path.setKeyBindings (keyBindings); return path; } /* Creates the subscriptions, filters, and handlers for the indication tests */ static void createSubscriptions(CIMClient& client, CIMObjectPath & g11ntestHandlerRef, CIMObjectPath & providerHandlerRef, CIMObjectPath & filterRef, CIMObjectPath & g11ntestSubscriptionRef, CIMObjectPath & providerSubscriptionRef, String & listenerDest, Boolean skipListener, Boolean verboseTest) { const CIMNamespaceName TEST_NAMESPACE = CIMNamespaceName ("test/TestProvider"); // Interop namespace used with PEGASUS_NAMESPACENAME_INTEROP in Constants.h const CIMName METHOD = CIMName("getIndicationResult"); const CIMObjectPath REFERENCE = CIMObjectPath("Test_LocalizedProviderClass.Identifier=0"); try { //--------------------------------------------------------- // Build the paths to the handlers, filter, and subscription //--------------------------------------------------------- // The handler that will have program as the destination CIMObjectPath g11ntestHandlerPath = buildFilterOrHandlerPath (PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "g11ntest_Handler"); // The handler that will have LocalizedProvider as the destination CIMObjectPath providerHandlerPath = buildFilterOrHandlerPath (PEGASUS_CLASSNAME_INDHANDLER_CIMXML, "provider_Handler"); // The filter CIMObjectPath filterPath = buildFilterOrHandlerPath (PEGASUS_CLASSNAME_INDFILTER, "g11ntest_Filter"); // The subscription that will have this program as the destination CIMObjectPath g11ntestSubscriptionPath = buildSubscriptionObjectPath (filterPath, g11ntestHandlerPath); // The subscription that will have LocalizedProvider as the destination CIMObjectPath providerSubscriptionPath = buildSubscriptionObjectPath (filterPath, providerHandlerPath); // Need to delete the old subscription and handler that have this // program as the destination. This is done in case the port changed // since the last time. if (verboseTest) cout << "Deleting the old subscription" << endl; try { client.deleteInstance(PEGASUS_NAMESPACENAME_INTEROP, CIMObjectPath(g11ntestSubscriptionPath)); } catch (CIMException & ce) { if (ce.getCode() != CIM_ERR_NOT_FOUND) { throw; } } if (verboseTest) cout << "Deleting the old handler" << endl; try { client.deleteInstance(PEGASUS_NAMESPACENAME_INTEROP, CIMObjectPath(g11ntestHandlerPath)); } catch (CIMException & ce) { if (ce.getCode() != CIM_ERR_NOT_FOUND) { throw; } } // Create the new handler instance with this program as the destination if (verboseTest) cout << "Creating the handlers" << endl; if (!skipListener) { CIMInstance g11ntestHandlerInstance(PEGASUS_CLASSNAME_INDHANDLER_CIMXML); g11ntestHandlerInstance.addProperty( CIMProperty (CIMName("SystemCreationClassName"), System::getSystemCreationClassName ())); g11ntestHandlerInstance.addProperty(CIMProperty(CIMName ("SystemName"), System::getFullyQualifiedHostName ())); g11ntestHandlerInstance.addProperty( CIMProperty(CIMName ("CreationClassName"), PEGASUS_CLASSNAME_INDHANDLER_CIMXML.getString())); g11ntestHandlerInstance.addProperty(CIMProperty(CIMName ("Name"), String("g11ntest_Handler"))); g11ntestHandlerInstance.addProperty( CIMProperty(CIMName ("Destination"), listenerDest)); g11ntestHandlerRef = client.createInstance( PEGASUS_NAMESPACENAME_INTEROP, g11ntestHandlerInstance); } // Create the new handler instance with LocalizedProvider as the destination CIMInstance providerHandlerInstance(PEGASUS_CLASSNAME_INDHANDLER_CIMXML); providerHandlerInstance.addProperty( CIMProperty (CIMName("SystemCreationClassName"), System::getSystemCreationClassName ())); providerHandlerInstance.addProperty(CIMProperty(CIMName ("SystemName"), System::getFullyQualifiedHostName ())); providerHandlerInstance.addProperty( CIMProperty(CIMName ("CreationClassName"), PEGASUS_CLASSNAME_INDHANDLER_CIMXML.getString())); providerHandlerInstance.addProperty(CIMProperty(CIMName ("Name"), String("provider_Handler"))); providerHandlerInstance.addProperty(CIMProperty(CIMName ("Destination"), String("http://localhost:5988/CIMListener/localizedprovider"))); try { providerHandlerRef = client.createInstance(PEGASUS_NAMESPACENAME_INTEROP, providerHandlerInstance); } catch (CIMException& ce) { if (ce.getCode() != CIM_ERR_ALREADY_EXISTS) throw; providerHandlerRef = CIMObjectPath(providerHandlerPath); } // Create the filter instance if (verboseTest) cout << "Creating the filter" << endl; CIMInstance filterInstance(PEGASUS_CLASSNAME_INDFILTER); filterInstance.addProperty(CIMProperty (CIMName ("SystemCreationClassName"), System::getSystemCreationClassName ())); filterInstance.addProperty(CIMProperty(CIMName ("SystemName"), System::getFullyQualifiedHostName ())); filterInstance.addProperty(CIMProperty(CIMName ("CreationClassName"), PEGASUS_CLASSNAME_INDFILTER.getString())); filterInstance.addProperty(CIMProperty(CIMName ("Name"), String("g11ntest_Filter"))); filterInstance.addProperty (CIMProperty(CIMName ("SourceNamespace"), String("test/TestProvider"))); filterInstance.addProperty (CIMProperty(CIMName ("Query"), String("SELECT * FROM LocalizedProvider_TestIndication"))); filterInstance.addProperty (CIMProperty(CIMName ("QueryLanguage"), String("WQL"))); try { filterRef = client.createInstance(PEGASUS_NAMESPACENAME_INTEROP, filterInstance); } catch (CIMException& ce) { if (ce.getCode() != CIM_ERR_ALREADY_EXISTS) throw; filterRef = CIMObjectPath(filterPath); } // Create the subscription if (verboseTest) cout << "Creating the subscription" << endl; if (!skipListener) { // The subscription with this program as the destination CIMInstance g11ntestSubscriptionInstance( PEGASUS_CLASSNAME_INDSUBSCRIPTION); g11ntestSubscriptionInstance.addProperty(CIMProperty(CIMName ("Filter"), filterRef, 0, PEGASUS_CLASSNAME_INDFILTER)); g11ntestSubscriptionInstance.addProperty(CIMProperty(CIMName ("Handler"), g11ntestHandlerRef, 0, PEGASUS_CLASSNAME_INDHANDLER_CIMXML)); g11ntestSubscriptionInstance.addProperty (CIMProperty (CIMName ("SubscriptionState"), CIMValue ((Uint16) 2))); try { g11ntestSubscriptionRef = client.createInstance(PEGASUS_NAMESPACENAME_INTEROP, g11ntestSubscriptionInstance); } catch (CIMException& ce) { if (ce.getCode() != CIM_ERR_ALREADY_EXISTS) throw; g11ntestSubscriptionRef = CIMObjectPath(g11ntestSubscriptionPath); } } // The subscription with LocalizedProvider as the destination CIMInstance providerSubscriptionInstance(PEGASUS_CLASSNAME_INDSUBSCRIPTION); providerSubscriptionInstance.addProperty(CIMProperty(CIMName ("Filter"), filterRef, 0, PEGASUS_CLASSNAME_INDFILTER)); providerSubscriptionInstance.addProperty(CIMProperty(CIMName ("Handler"), providerHandlerRef, 0, PEGASUS_CLASSNAME_INDHANDLER_CIMXML)); providerSubscriptionInstance.addProperty (CIMProperty (CIMName ("SubscriptionState"), CIMValue ((Uint16) 2))); try { providerSubscriptionRef = client.createInstance( PEGASUS_NAMESPACENAME_INTEROP, providerSubscriptionInstance); } catch (CIMException& ce) { if (ce.getCode() != CIM_ERR_ALREADY_EXISTS) throw; providerSubscriptionRef = CIMObjectPath(providerSubscriptionPath); } } catch (Exception& e) { PEGASUS_STD(cerr) << "Error in createSubscriptions " << e.getMessage() << PEGASUS_STD(endl); throw; } } /* Tests the globalization support for indications. */ static void TestLocalizedIndications( CIMClient& client, Boolean activeTest, Boolean verboseTest, Boolean skipListener, String listenerHost) { const CIMNamespaceName TEST_NAMESPACE = CIMNamespaceName ("test/TestProvider"); const CIMName GEN_METHOD = CIMName("generateIndication"); const CIMName RESULT_METHOD = CIMName("getConsumerStatus"); const CIMObjectPath REFERENCE = CIMObjectPath("Test_LocalizedProviderClass.Identifier=0"); if (!activeTest) { cout << "Active tests are disabled. Nothing to do for this test." << endl; return; } try { // // TEST 1 - Cause the LocalizedProvider to send an indication to a // CIMListener in this process. // // When the indication arrives then check that the UTF-16 chars in the // indication properties were received, and that the Content-Language header // in the Export message was received. // cout << endl << "INDICATION TEST 1: Send an indication containing UTF-16 to a" " CIMListener" << endl; // Build the destination path to this program as the CIMListener String dest("http://"); dest.append(listenerHost); dest.append("/g11ntest"); // Get the subscriptions set up to send the indications CIMObjectPath g11ntestHandlerRef; CIMObjectPath providerHandlerRef; CIMObjectPath filterRef; CIMObjectPath g11ntestSubscriptionRef; CIMObjectPath providerSubscriptionRef; createSubscriptions(client, g11ntestHandlerRef, providerHandlerRef, filterRef, g11ntestSubscriptionRef, providerSubscriptionRef, dest, skipListener, verboseTest); // Construct our CIMListener in case we use it. Boolean listenerError = false; Uint32 portNumber = 2003; HostLocator addr(listenerHost); if (addr.isPortSpecified()) { portNumber = addr.getPort(); } CIMListener listener(portNumber); // Add our comsumer MyIndicationConsumer* consumer1 = new MyIndicationConsumer("1"); listener.addConsumer(consumer1); // If we are running the listener test, then finish starting the CIMListener if (!skipListener) { try { if (verboseTest) cout << "Starting the CIMListener at destination " << dest << endl; // Start the listener listener.start(); } catch (const BindFailedException&) { // Got a bind error. The port is probably already in use. // Put out a message and keep going. // NOTE - pegasus_acceptor (part of monitor_2) does not appear // to throw this exception on bind errors. So, when monitor_2 // is used, we will get the timeout below rather than a bind error. cerr << endl << "==>WARNING: unable to bind to listener port " << portNumber << endl; cerr << "The listener port may be in use." << endl; cerr << "Skipping the CIMListener tests." << endl; listenerError = true; } } else { cout << "skiplistener option is true. Skipping the CIMListener tests." << endl; listenerError = true; // forces the validation to be skipped. } // Cause the indication. // Note: because of the subscriptions, the indication will go to the // CIMListener (if enabled) and the CIMIndicationConsumerProvider. if (verboseTest) cout << "Causing the indication" << endl; // Set the language objects to be sent to the provider // This is required by the provider AcceptLanguageList AL_DE; AL_DE.insert(LanguageTag("de"), Real32(0.8)); ContentLanguageList CL_DE; CL_DE.append(LanguageTag("de")); client.setRequestAcceptLanguages(AL_DE); client.setRequestContentLanguages(CL_DE); Array<CIMParamValue> inParams; Array<CIMParamValue> outParams; CIMValue rtnVal = client.invokeMethod( TEST_NAMESPACE, REFERENCE, GEN_METHOD, inParams, outParams); // Block until the indication comes in (let the user know we are waiting) if (!listenerError) { cout << "Waiting to receive the indication (timeout is 10sec)" << endl; if (!indicationReceived.time_wait(10 * 1000)) { throw Exception("Timed out waiting for indication."); } cout << "Received the indication" << endl; // Verify that the UTF-16 properties in the indication got to our // CIMListener if (verboseTest) cout << "Checking the indication for valid utf-16 chars" << endl; Uint32 pos = indication.findProperty("UnicodeStr"); MYASSERT(pos != (Uint32)PEG_NOT_FOUND); CIMValue val = indication.getProperty(pos).getValue(); String utf16; val.get(utf16); MYASSERT(utf16 == String(utf16Chars)); pos = indication.findProperty("UnicodeChar"); MYASSERT(pos != (Uint32)PEG_NOT_FOUND); val = indication.getProperty(pos).getValue(); Char16 char16; val.get(char16); MYASSERT(char16 == utf16Chars[0]); // Verify that the Content-Language of the indication got to us ContentLanguageList expectedCL; expectedCL.append(LanguageTag("x-world")); if (verboseTest) cout << "Checking the indication for ContentLanguageList = " << LanguageParser::buildContentLanguageHeader(expectedCL) << endl; ContentLanguageListContainer cntr = indicationContext.get(ContentLanguageListContainer::NAME); ContentLanguageList cl = cntr.getLanguages(); MYASSERT(cl == expectedCL); } // endif !skiplistener // Clean up the listener if (verboseTest && !skipListener) cout << "Stopping the listener" << endl; listener.stop(); listener.removeConsumer(consumer1); delete consumer1; // // TEST 2 - Cause the LocalizedProvider to send an indication to a // CIMIndicationConsumerProvider // // The consumer provider checks that the UTF-16 chars in the // indication properties were received, and that the Content-Language header // in the Export message was received. This program calls a method on // the provider to get the test result. // // Note: LocalizedProvider is the consumer in this test. So the provider // is sending an indication to itself. However, the destination in the // handler is // set up so that the indication still goes through the TCP/IP stack. // (this is done by setting the host:port to localhost:5988) // cout << endl << "INDICATION TEST 2: Send an indication containing UTF-16 " "to a CIMIndicationConsumerProvider" << endl; // Verify that the indication got to the CIMIndicationConsumerProvider if (verboseTest) cout << "Getting the status from the CIMIndicationConsumerProvider" << endl; Threads::sleep(3000); // give the indication 3 sec to get to the consumer rtnVal = client.invokeMethod( TEST_NAMESPACE, REFERENCE, RESULT_METHOD, inParams, outParams); if (verboseTest) cout << "Checking the status from the CIMIndicationConsumerProvider" << endl; Uint8 result; rtnVal.get(result); switch (result) { case 0: break; case 1: throw Exception("CIMIndicationConsumer did not receive the indication"); break; case 2: throw Exception( "CIMIndicationConsumer did not receive the UTF-16 string"); break; case 3: throw Exception( "CIMIndicationConsumer did not receive the correct value in" " UTF-16 string"); break; case 4: throw Exception( "CIMIndicationConsumer did not receive the UTF-16 character"); break; case 5: throw Exception("CIMIndicationConsumer did not receive the correct" " value in UTF-16 character"); break; case 6: throw Exception("CIMIndicationConsumer did not receive the correct" " content languages"); break; default: throw Exception("CIMIndicationConsumer sent an unknown status value"); break; } // Clean up the repository if (verboseTest) cout << "Removing the handlers, filters,and subscriptions" << endl; if (!skipListener) client.deleteInstance(PEGASUS_NAMESPACENAME_INTEROP, g11ntestSubscriptionRef); client.deleteInstance(PEGASUS_NAMESPACENAME_INTEROP, providerSubscriptionRef); client.deleteInstance(PEGASUS_NAMESPACENAME_INTEROP, filterRef); if (!skipListener) client.deleteInstance(PEGASUS_NAMESPACENAME_INTEROP, g11ntestHandlerRef); client.deleteInstance(PEGASUS_NAMESPACENAME_INTEROP, providerHandlerRef); if (verboseTest) cout << "Indication test completed successfully " << endl; } catch (Exception& e) { PEGASUS_STD(cerr) << "Error in TestLocalizedIndications: " << e.getMessage() << PEGASUS_STD(endl); throw; } } // This function is used to control the default message loading in the server. // When make poststarttests is run with ICU enabled, the // PEGASUS_USE_DEFAULT_MESSAGES // env var is set. This env var causes the server to return default messages // even though ICU is used. This is needed to pass the wbemexec testcases that // expect the default messages. However, when this program is run with ICU // enabled, messages from the resource bundles are expected from the server. // This function controls whether the MessageLoader in the server loads from // the resource bundles. Boolean setServerDefaultMessageLoading(CIMClient & client, Boolean newSetting) { const CIMNamespaceName TEST_NAMESPACE = CIMNamespaceName ("test/TestProvider"); const CIMName SETTER_METHOD = CIMName("setDefaultMessageLoading"); const CIMObjectPath REFERENCE = CIMObjectPath("Test_LocalizedProviderClass.Identifier=0"); // Set the language objects to be sent to the LocalizedProvider // This is required by the provider AcceptLanguageList AL_DE; AL_DE.insert(LanguageTag("de"), Real32(0.8)); ContentLanguageList CL_DE; CL_DE.append(LanguageTag("de")); client.setRequestAcceptLanguages(AL_DE); client.setRequestContentLanguages(CL_DE); // Set the new default message loading value Array<CIMParamValue> inParams; inParams.append( CIMParamValue( "newSetting", CIMValue( newSetting ) ) ); Array<CIMParamValue> outParams; CIMValue rtnVal = client.invokeMethod( TEST_NAMESPACE, REFERENCE, SETTER_METHOD, inParams, outParams); // The old value is returned by the provider Boolean oldSetting; rtnVal.get(oldSetting); return oldSetting; } // l10n end /////////////////////////////////////////////////////////////// // OPTION MANAGEMENT /////////////////////////////////////////////////////////////// /** GetOptions function - This function defines the Options Table and sets up the options from that table using the option manager. const char* optionName; const char* defaultValue; int required; Option::Type type; char** domain; Uint32 domainSize; const char* commandLineOptionName; const char* optionHelpMessage; */ void GetOptions( OptionManager& om, int& argc, char** argv, const String& pegasusHome) { static struct OptionRow optionsTable[] = // optionname defaultvalue rqd type domain domainsize clname hlpmsg { {"repeat", "1", false, Option::WHOLE_NUMBER, 0, 0, "r", "Specifies a Repeat Count Entire test repeated this" " many times" }, {"version", "false", false, Option::BOOLEAN, 0, 0, "version", "Displays TestClient Version "}, {"verbose", "false", false, Option::BOOLEAN, 0, 0, "verbose", "If set, outputs extra information "}, {"help", "false", false, Option::BOOLEAN, 0, 0, "h", "Prints help message with command line options "}, {"debug", "false", false, Option::BOOLEAN, 0, 0, "d", "Not Used "}, {"local", "false", false, Option::BOOLEAN, 0, 0, "local", "Use local connection mechanism"}, {"user", "", false, Option::STRING, 0, 0, "user", "Specifies user name" }, {"password", "", false, Option::STRING, 0, 0, "password", "Specifies password" }, {"reqlang", "", false, Option::STRING, 0, 0, "reqlang", "Specifies the language list (in RFC 2616 Accept-Language" " form) to request for messages from the server" }, {"rsplang", "", false, Option::STRING, 0, 0, "rsplang", "Specifies the language expected to be returned by" " the server"}, {"skipactive", "false", false, Option::BOOLEAN, 0, 0, "skipactive", "If set then skips tests that modify CIM Objects on" " the server" }, {"skiplistener", "false", false, Option::BOOLEAN, 0, 0, "skiplistener", "If set then skips the CIMListener tests" }, {"listenerhost", "localhost:2003", false, Option::STRING, 0, 0, "l", "Specifies the listener host:port for the" " CIMListener tests" }, {"utfrep", "false", false, Option::BOOLEAN, 0, 0, "utfrep", "If set then use class/qualifier/namepaces names with" " UTF-16 in the repository tests." } }; const Uint32 NUM_OPTIONS = sizeof(optionsTable) / sizeof(optionsTable[0]); om.registerOptions(optionsTable, NUM_OPTIONS); String configFile = pegasusHome + "/cimserver.conf"; cout << "Config file from " << configFile << endl; if (FileSystem::exists(configFile)) om.mergeFile(configFile); om.mergeCommandLine(argc, argv); om.checkRequiredOptions(); } /////////////////////////////////////////////////////////////// // MAIN /////////////////////////////////////////////////////////////// int main(int argc, char** argv) { // Get environment variables: String pegasusHome; pegasusHome = "/"; // GetEnvironmentVariables(argv[0], pegasusHome); // Get options (from command line and from configuration file); this // removes corresponding options and their arguments fromt he command // line. // Get options (from command line and from configuration file); this // removes corresponding options and their arguments fromt he command // line. OptionManager om; try { GetOptions(om, argc, argv, pegasusHome); } catch (Exception& e) { cerr << argv[0] << ": " << e.getMessage() << endl; exit(1); } // Check to see if user asked for help (-h otpion): if (om.valueEquals("help", "true")) { String header = "Usage "; header.append(argv[0]); header.append(" -parameters host [host]"); String trailer = "Assumes localhost:5988 if host not specified"; trailer.append("\nHost may be of the form name or name:port"); trailer.append("\nPort 5988 assumed if port number missing."); om.printOptionsHelpTxt(header, trailer); exit(0); } String reqLang; om.lookupValue("reqlang", reqLang); if (reqLang != String::EMPTY) { // User is requesting translated msgs from the server skipICU = false; } else { // User is not requesting translated msgs from the server. skipICU = true; } cout << "Request Language = " << reqLang << endl; String rspLang; om.lookupValue("rsplang", rspLang); cout << "Expected Response Language = " << rspLang << endl; if (om.valueEquals("version","true")) { cout << argv[0] << " version " <<programVersion << endl; //cout << argv[0] << endl; exit(0); } // Setup the active test flag. Determines if we change repository. Boolean activeTest = true; if (om.valueEquals("skipactive", "true")) activeTest = false; // Setup the flag to decide whether to use UTF-16 in the classes // and qualifiers created in the repository tests. Boolean utfRepNames = false; if (om.valueEquals("utfrep", "true")) utfRepNames = true; String userName; om.lookupValue("user", userName); if (userName != String::EMPTY) { cout << "Username = " << userName << endl; } Boolean verboseTest = om.isTrue("verbose"); String password; om.lookupValue("password", password); if (password != String::EMPTY) { cout << "password = " << password << endl; } // Set up number of test repetitions. // Will repeat entire test this number of times // Default is zero // String repeats; Uint32 repeatTestCount = 0; /* ATTN: KS P0 Test and fix function added to Option Manager */ if (!om.lookupIntegerValue("repeat", repeatTestCount)) repeatTestCount = 1; // Settings for the indication tests String listenerHost; om.lookupValue("listenerhost",listenerHost); cout << "Listener Host:Port = " << listenerHost << endl; Boolean skipListener = false; if (om.valueEquals("skiplistener", "true")) skipListener = true; if(verboseTest) cout << "Test repeat count " << repeatTestCount << endl; Boolean localConnection = (om.valueEquals("local", "true"))? true: false; cout << "localConnection " << (localConnection ? "true" : "false") << endl; Array<String> connectionList; if (argc > 1 && !localConnection) for (Sint32 i = 1; i < argc; i++) connectionList.append(argv[i]); if(argc < 2) connectionList.append("localhost:5988"); // Expand host to add port if not defined // Show the connectionlist cout << "Connection List size " << connectionList.size() << endl; for (Uint32 i = 0; i < connectionList.size(); i++) cout << "Connection " << i << " address " << connectionList[i] << endl; cout << "==========START GLOBALIZATION TEST============" << endl; for(Uint32 numTests = 1; numTests <= repeatTestCount; numTests++) { cout << "Test Repetition # " << numTests << endl; for (Uint32 i = 0; i < connectionList.size(); i++) { cout << "Start Try Block" << endl; try { cout << "Set Stopwatch" << endl; Stopwatch elapsedTime; cout << "Create client" << endl; CIMClient client; client.setTimeout(360 * 1000); cout << "Client created" << endl; // // Get host and port number from connection list entry // HostLocator addr(connectionList[i]); String host = addr.getHost(); Uint32 portNumber = 0; if (addr.isPortSpecified()) { portNumber = addr.getPort(); } if (om.isTrue("local")) { cout << "Using local connection mechanism " << endl; client.connectLocal(); } else { cout << "Connecting to " << connectionList[i] << endl; client.connect (host, portNumber, userName, password); } cout << "Client Connected" << endl; if (verboseTest) cout << "Disabling default message loading in the server" << endl; Boolean oldSetting = setServerDefaultMessageLoading(client, false); try { testStart("Test Server Error Messages"); elapsedTime.reset(); elapsedTime.start(); TestServerMessages(client, reqLang, rspLang, activeTest, verboseTest); elapsedTime.stop(); testEnd(elapsedTime.getElapsed()); testStart("Test Instance Operations"); elapsedTime.reset(); elapsedTime.start(); TestLocalizedInstances(client, activeTest, verboseTest); elapsedTime.stop(); testEnd(elapsedTime.getElapsed()); testStart("Test Method Operations"); elapsedTime.reset(); elapsedTime.start(); TestLocalizedMethods(client, activeTest, verboseTest); elapsedTime.stop(); testEnd(elapsedTime.getElapsed()); testStart("Test Class, Qualifier, and Namespace Operations"); elapsedTime.reset(); elapsedTime.start(); TestUTFRepository(client, utfRepNames, activeTest, verboseTest); elapsedTime.stop(); testEnd(elapsedTime.getElapsed()); testStart("Test Indication Operations"); elapsedTime.reset(); elapsedTime.start(); TestLocalizedIndications(client, activeTest, verboseTest, skipListener ,listenerHost); elapsedTime.stop(); testEnd(elapsedTime.getElapsed()); } catch (const Exception&) { // Restore the default message loading value before we leave setServerDefaultMessageLoading(client, oldSetting); throw; } if (verboseTest) cout << "Restoring the old default message loading value" << endl; setServerDefaultMessageLoading(client, oldSetting); client.disconnect(); } catch(Exception& e) { PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl); exit(1); } } } PEGASUS_STD(cout) << "+++++ "<< argv[0] << " Terminated Normally" << PEGASUS_STD(endl); return 0; }
No CVS admin address has been configured |
Powered by ViewCVS 0.9.2 |