messageserializer.cpp

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

    try
    {
        const LocaleContainer inContainer =
            inOperationContext.get(LocaleContainer::NAME);
        try
        {
            const LocaleContainer outContainer =
                outOperationContext.get(LocaleContainer::NAME);
            PEGASUS_TEST_ASSERT(
                inContainer.getLanguageId() == outContainer.getLanguageId());
        }
        catch(const Exception&)
        {
            PEGASUS_TEST_ASSERT(0);
        }
    }
    catch(const Exception&)
    {
    }
}

//
// validateCIMMessageAttributes
//
void validateCIMMessageAttributes(
    const CIMMessage* inMessage,
    const CIMMessage* outMessage)
{
    // Validate Message attributes
    PEGASUS_TEST_ASSERT(inMessage->getType() == outMessage->getType());
    PEGASUS_TEST_ASSERT(inMessage->isComplete() == outMessage->isComplete());
    PEGASUS_TEST_ASSERT(inMessage->getIndex() == outMessage->getIndex());

    // Validate messageId member
    PEGASUS_TEST_ASSERT(inMessage->messageId == outMessage->messageId);

    // Validate OperationContext
    validateOperationContext(
        inMessage->operationContext, outMessage->operationContext);
}

//
// validateCIMRequestMessageAttributes
//
void validateCIMRequestMessageAttributes(
    const CIMRequestMessage* inMessage,
    const CIMRequestMessage* outMessage)
{
    validateCIMMessageAttributes(inMessage, outMessage);

    // Validate queueIds member
    PEGASUS_TEST_ASSERT(
        inMessage->queueIds.size() == outMessage->queueIds.size());
    if (!inMessage->queueIds.isEmpty())
    {
        PEGASUS_TEST_ASSERT(
            inMessage->queueIds.top() == outMessage->queueIds.top());
    }
}

//
// validateCIMOperationRequestMessageAttributes
//
void validateCIMOperationRequestMessageAttributes(
    const CIMOperationRequestMessage* inMessage,
    const CIMOperationRequestMessage* outMessage)
{
    validateCIMRequestMessageAttributes(inMessage, outMessage);
    PEGASUS_TEST_ASSERT(inMessage->nameSpace == outMessage->nameSpace);
    PEGASUS_TEST_ASSERT(inMessage->className == outMessage->className);
    PEGASUS_TEST_ASSERT(inMessage->providerType == outMessage->providerType);
}

//
// validateCIMIndicationRequestMessageAttributes
//
void validateCIMIndicationRequestMessageAttributes(
    const CIMIndicationRequestMessage* inMessage,
    const CIMIndicationRequestMessage* outMessage)
{
    // CIMIndicationRequestMessage has no additional properties
    validateCIMRequestMessageAttributes(inMessage, outMessage);
}

//
// validateCIMResponseMessageAttributes
//
void validateCIMResponseMessageAttributes(
    const CIMResponseMessage* inMessage,
    const CIMResponseMessage* outMessage)
{
    validateCIMMessageAttributes(inMessage, outMessage);

    // Validate queueIds member
    PEGASUS_TEST_ASSERT(
        inMessage->queueIds.size() == outMessage->queueIds.size());
    if (!inMessage->queueIds.isEmpty())
    {
        PEGASUS_TEST_ASSERT(
            inMessage->queueIds.top() == outMessage->queueIds.top());
    }

    // Validate cimException member
    PEGASUS_TEST_ASSERT(inMessage->cimException.getCode() ==
           outMessage->cimException.getCode());
    PEGASUS_TEST_ASSERT(inMessage->cimException.getMessage() ==
           outMessage->cimException.getMessage());
}

//
// serializeDeserializeMessage
//
/**
    Serializes the message into a Buffer, and then dseserialize it back into
    a Message object.
*/
CIMMessage* serializeDeserializeMessage(CIMMessage* inMessage)
{
    Buffer outBuffer;
    CIMMessageSerializer::serialize(outBuffer, inMessage);
    outBuffer.append(0);

    char* inBuffer = new char[outBuffer.size()];
    memcpy(inBuffer, outBuffer.getData(), outBuffer.size());

    if (verbose)
    {
        cout << inBuffer << endl;
    }

    CIMMessage* outMessage;
    outMessage = CIMMessageDeserializer::deserialize(inBuffer);

    delete [] inBuffer;

    return outMessage;
}

//
// testEmptyRequestMessage
//
void testEmptyMessage()
{
    Buffer outBuffer;
    CIMMessageSerializer::serialize(outBuffer, 0);
    PEGASUS_TEST_ASSERT(outBuffer.size() == 0);

    char inBuffer[1] = { 0 };
    CIMMessage* outMessage = CIMMessageDeserializer::deserialize(inBuffer);
    PEGASUS_TEST_ASSERT(outMessage == 0);
}

//
// testCIMGetInstanceRequestMessage
//
void testCIMGetInstanceRequestMessage(
    const OperationContext& oc,
    const String& mid,
    const CIMNamespaceName& ns,
    const CIMObjectPath& path,
    Boolean lo,
    Boolean iq,
    Boolean ico,
    const CIMPropertyList& pl,
    const QueueIdStack& qids,
    const String& auth,
    const String& user)
{
    CIMGetInstanceRequestMessage inMessage(
        mid, ns, path, lo, iq, ico, pl, qids, auth, user);
    inMessage.operationContext = oc;
    AutoPtr<CIMGetInstanceRequestMessage> outMessage(
        dynamic_cast<CIMGetInstanceRequestMessage*>(
            serializeDeserializeMessage(&inMessage)));
    PEGASUS_TEST_ASSERT(outMessage.get() != 0);

    validateCIMOperationRequestMessageAttributes(&inMessage, outMessage.get());
    PEGASUS_TEST_ASSERT(inMessage.instanceName == outMessage->instanceName);
    PEGASUS_TEST_ASSERT(inMessage.localOnly == outMessage->localOnly);
    PEGASUS_TEST_ASSERT(
        inMessage.includeQualifiers == outMessage->includeQualifiers);
    PEGASUS_TEST_ASSERT(
        inMessage.includeClassOrigin == outMessage->includeClassOrigin);
    validateCIMPropertyList(inMessage.propertyList, outMessage->propertyList);
    PEGASUS_TEST_ASSERT(inMessage.authType == outMessage->authType);
    PEGASUS_TEST_ASSERT(inMessage.userName == outMessage->userName);
}

//
// testCIMCreateInstanceRequestMessage
//
void testCIMCreateInstanceRequestMessage(
    const OperationContext& oc,
    const String& mid,
    const CIMNamespaceName& ns,
    const CIMInstance& inst,
    const QueueIdStack& qids,
    const String& auth,
    const String& user)
{
    CIMCreateInstanceRequestMessage inMessage(mid, ns, inst, qids, auth, user);
    inMessage.operationContext = oc;
    AutoPtr<CIMCreateInstanceRequestMessage> outMessage(
        dynamic_cast<CIMCreateInstanceRequestMessage*>(
            serializeDeserializeMessage(&inMessage)));
    PEGASUS_TEST_ASSERT(outMessage.get() != 0);

    validateCIMOperationRequestMessageAttributes(&inMessage, outMessage.get());
    validateCIMInstance(inMessage.newInstance, outMessage->newInstance);
    PEGASUS_TEST_ASSERT(inMessage.authType == outMessage->authType);
    PEGASUS_TEST_ASSERT(inMessage.userName == outMessage->userName);
}

//
// testCIMModifyInstanceRequestMessage
//
void testCIMModifyInstanceRequestMessage(
    const OperationContext& oc,
    const String& mid,
    const CIMNamespaceName& ns,
    const CIMInstance& inst,
    Boolean iq,
    const CIMPropertyList& pl,
    const QueueIdStack& qids,
    const String& auth,
    const String& user)
{
    CIMModifyInstanceRequestMessage inMessage(
        mid, ns, inst, iq, pl, qids, auth, user);
    inMessage.operationContext = oc;
    AutoPtr<CIMModifyInstanceRequestMessage> outMessage(
        dynamic_cast<CIMModifyInstanceRequestMessage*>(
            serializeDeserializeMessage(&inMessage)));
    PEGASUS_TEST_ASSERT(outMessage.get() != 0);

    validateCIMOperationRequestMessageAttributes(&inMessage, outMessage.get());
    validateCIMInstance(
        inMessage.modifiedInstance, outMessage->modifiedInstance);
    PEGASUS_TEST_ASSERT(
        inMessage.includeQualifiers == outMessage->includeQualifiers);
    validateCIMPropertyList(inMessage.propertyList, outMessage->propertyList);
    PEGASUS_TEST_ASSERT(inMessage.authType == outMessage->authType);
    PEGASUS_TEST_ASSERT(inMessage.userName == outMessage->userName);
}

//
// testCIMDeleteInstanceRequestMessage
//
void testCIMDeleteInstanceRequestMessage(
    const OperationContext& oc,
    const String& mid,
    const CIMNamespaceName& ns,
    const CIMObjectPath& path,
    const QueueIdStack& qids,
    const String& auth,
    const String& user)
{
    CIMDeleteInstanceRequestMessage inMessage(mid, ns, path, qids, auth, user);
    inMessage.operationContext = oc;
    AutoPtr<CIMDeleteInstanceRequestMessage> outMessage(
        dynamic_cast<CIMDeleteInstanceRequestMessage*>(
            serializeDeserializeMessage(&inMessage)));
    PEGASUS_TEST_ASSERT(outMessage.get() != 0);

    validateCIMOperationRequestMessageAttributes(&inMessage, outMessage.get());
    PEGASUS_TEST_ASSERT(inMessage.instanceName == outMessage->instanceName);
    PEGASUS_TEST_ASSERT(inMessage.authType == outMessage->authType);
    PEGASUS_TEST_ASSERT(inMessage.userName == outMessage->userName);
}

//
// testCIMEnumerateInstancesRequestMessage
//
void testCIMEnumerateInstancesRequestMessage(
    const OperationContext& oc,
    const String& mid,
    const CIMNamespaceName& ns,
    const CIMName& className,
    Boolean di,
    Boolean lo,
    Boolean iq,
    Boolean ico,
    const CIMPropertyList& pl,
    const QueueIdStack& qids,
    const String& auth,
    const String& user)
{
    CIMEnumerateInstancesRequestMessage inMessage(
        mid, ns, className, di, lo, iq, ico, pl, qids, auth, user);
    inMessage.operationContext = oc;
    AutoPtr<CIMEnumerateInstancesRequestMessage> outMessage(
        dynamic_cast<CIMEnumerateInstancesRequestMessage*>(
            serializeDeserializeMessage(&inMessage)));
    PEGASUS_TEST_ASSERT(outMessage.get() != 0);

    validateCIMOperationRequestMessageAttributes(&inMessage, outMessage.get());
    PEGASUS_TEST_ASSERT(
        inMessage.deepInheritance == outMessage->deepInheritance);
    PEGASUS_TEST_ASSERT(inMessage.localOnly == outMessage->localOnly);
    PEGASUS_TEST_ASSERT(
        inMessage.includeQualifiers == outMessage->includeQualifiers);
    PEGASUS_TEST_ASSERT(
        inMessage.includeClassOrigin == outMessage->includeClassOrigin);
    validateCIMPropertyList(inMessage.propertyList, outMessage->propertyList);
    PEGASUS_TEST_ASSERT(inMessage.authType == outMessage->authType);
    PEGASUS_TEST_ASSERT(inMessage.userName == outMessage->userName);
}

//
// testCIMEnumerateInstanceNamesRequestMessage
//
void testCIMEnumerateInstanceNamesRequestMessage(
    const OperationContext& oc,
    const String& mid,
    const CIMNamespaceName& ns,
    const CIMName& className,
    const QueueIdStack& qids,
    const String& auth,
    const String& user)
{
    CIMEnumerateInstanceNamesRequestMessage inMessage(
        mid, ns, className, qids, auth, user);
    inMessage.operationContext = oc;
    AutoPtr<CIMEnumerateInstanceNamesRequestMessage> outMessage(
        dynamic_cast<CIMEnumerateInstanceNamesRequestMessage*>(
            serializeDeserializeMessage(&inMessage)));
    PEGASUS_TEST_ASSERT(outMessage.get() != 0);

    validateCIMOperationRequestMessageAttributes(&inMessage, outMessage.get());
    PEGASUS_TEST_ASSERT(inMessage.authType == outMessage->authType);
    PEGASUS_TEST_ASSERT(inMessage.userName == outMessage->userName);
}

//
// testCIMExecQueryRequestMessage
//
void testCIMExecQueryRequestMessage(
    const OperationContext& oc,
    const String& mid,
    const CIMNamespaceName& ns,
    const String& ql,
    const String& qs,
    const QueueIdStack& qids,
    const String& auth,
    const String& user)
{
    CIMExecQueryRequestMessage inMessage(mid, ns, ql, qs, qids, auth, user);
    inMessage.operationContext = oc;
    AutoPtr<CIMExecQueryRequestMessage> outMessage(
        dynamic_cast<CIMExecQueryRequestMessage*>(
            serializeDeserializeMessage(&inMessage)));
    PEGASUS_TEST_ASSERT(outMessage.get() != 0);

    validateCIMOperationRequestMessageAttributes(&inMessage, outMessage.get());
    PEGASUS_TEST_ASSERT(inMessage.queryLanguage == outMessage->queryLanguage);
    PEGASUS_TEST_ASSERT(inMessage.query == outMessage->query);
    PEGASUS_TEST_ASSERT(inMessage.authType == outMessage->authType);
    PEGASUS_TEST_ASSERT(inMessage.userName == outMessage->userName);
}

//
// testCIMAssociatorsRequestMessage
//
void testCIMAssociatorsRequestMessage(
    const OperationContext& oc,
    const String& mid,
    const CIMNamespaceName& ns,
    const CIMObjectPath& path,
    const CIMName& assocClass,
    const CIMName& resultClass,
    const String& role,
    const String& resultRole,
    Boolean iq,
    Boolean ico,
    const CIMPropertyList& pl,
    const QueueIdStack& qids,
    const String& auth,
    const String& user)
{
    CIMAssociatorsRequestMessage inMessage(
        mid, ns, path, assocClass, resultClass, role, resultRole,
        iq, ico, pl, qids, auth, user);
    inMessage.operationContext = oc;
    AutoPtr<CIMAssociatorsRequestMessage> outMessage(
        dynamic_cast<CIMAssociatorsRequestMessage*>(
            serializeDeserializeMessage(&inMessage)));
    PEGASUS_TEST_ASSERT(outMessage.get() != 0);

    validateCIMOperationRequestMessageAttributes(&inMessage, outMessage.get());