TEST_F(FunctionTypeTests,
TwoFunctionTypesDifferingInNumberOfParametersAreNotEqual) {
ShPtr<FunctionType> ft1(FunctionType::create());
ShPtr<FunctionType> ft2(FunctionType::create());
ShPtr<IntType> paramType(IntType::create(32));
ft2->addParam(paramType);
EXPECT_FALSE(ft1->isEqualTo(ft2));
}
QVariant DeferredSignal::result()
{
if(!m_argv) {
return QVariant();
}
//legacy from QObjectComWrapper
const QMetaObject *mo = m_method.enclosingMetaObject();
QList<QByteArray> ptypes = m_method.parameterTypes();
int pcount = ptypes.count();
QVariantList result;
result.reserve(pcount);
//prepare arguments
for (int p = 0; p < pcount; ++p) {
bool out;
QByteArray ptype = paramType(ptypes.at(p), &out);
QVariant variant;
if (mo->indexOfEnumerator(ptype) != -1) {
// convert enum values to int
variant = QVariant(*reinterpret_cast<int *>(m_argv[p+1]));
} else {
QVariant::Type vt = QVariant::nameToType(ptype);
if (vt == QVariant::UserType) {
if (ptype.endsWith('*')) {
variant = QVariant(QMetaType::type(ptype), (void**)m_argv[p+1]);
} else {
variant = QVariant(QMetaType::type(ptype), m_argv[p+1]);
}
} else {
variant = QVariant(vt, m_argv[p + 1]);
}
}
result.push_back(variant);
}
return result;
}
void CallCandidate::format(FormatStream & out) const {
out << method_->name();
if (typeParams_ != NULL) {
out << "[";
for (TupleType::const_iterator it = typeParams_->begin(); it != typeParams_->end(); ++it) {
if (it != typeParams_->begin()) {
out << ", ";
}
out << *it;
}
out << "]";
}
out << "(";
for (size_t i = 0; i < callExpr_->argCount(); ++i) {
if (i != 0) {
out << ", ";
}
out << ":" << paramType(i);
}
out << ") -> " << resultType();
}
bool AddExtension::execute(const HttpRequestContext& requestContext,
UtlSList& params,
void* userData,
XmlRpcResponse& response,
XmlRpcMethod::ExecutionStatus& status)
{
bool result = false;
int totalParams = params.entries();
if (totalParams > 2)
{
response.setFault(TOO_MANY_PARAMS_FAULT_CODE, TOO_MANY_PARAMS_FAULT_STRING);
result = false;
}
else
{
UtlString groupName;
UtlString extension;
for (int index = 0; index < totalParams; index++)
{
UtlContainable *value = params.at(index);
if (index == 0 || index == 1)
{
UtlString paramType(value->getContainableType());
if (paramType.compareTo("UtlString") == 0)
{
if (index == 0)
{
groupName = *((UtlString *)value);
}
else
{
extension = *((UtlString *)value);
}
result = true;
}
else
{
response.setFault(ILLEGAL_PARAM_FAULT_CODE, ILLEGAL_PARAM_FAULT_STRING);
result = false;
}
}
}
if (result)
{
SipDialogMonitor* dialogMonitor = (SipDialogMonitor *) userData;
Url extensionUrl(extension);
dialogMonitor->addExtension(groupName, extensionUrl);
status = XmlRpcMethod::OK;
// Construct the response
UtlString responseText("method call \"addExtension\" successful");
response.setResponse(&responseText);
}
}
return true;
}
/*! Return a list of \l{DeviceClass}{DeviceClasses} describing all the devices supported by this plugin. */
QList<DeviceClass> DevicePlugin::supportedDevices() const
{
QList<DeviceClass> deviceClasses;
foreach (const QJsonValue &vendorJson, m_metaData.value("vendors").toArray()) {
bool broken = false;
VendorId vendorId = vendorJson.toObject().value("id").toString();
foreach (const QJsonValue &deviceClassJson, vendorJson.toObject().value("deviceClasses").toArray()) {
QJsonObject jo = deviceClassJson.toObject();
DeviceClass deviceClass(pluginId(), vendorId, jo.value("deviceClassId").toString());
deviceClass.setName(jo.value("name").toString());
DeviceClass::CreateMethods createMethods;
foreach (const QJsonValue &createMethodValue, jo.value("createMethods").toArray()) {
if (createMethodValue.toString() == "discovery") {
createMethods |= DeviceClass::CreateMethodDiscovery;
} else if (createMethodValue.toString() == "auto") {
createMethods |= DeviceClass::CreateMethodAuto;
} else {
createMethods |= DeviceClass::CreateMethodUser;
}
}
deviceClass.setCreateMethods(createMethods);
deviceClass.setDiscoveryParamTypes(parseParamTypes(jo.value("discoveryParamTypes").toArray()));
QString setupMethod = jo.value("setupMethod").toString();
if (setupMethod == "pushButton") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodPushButton);
} else if (setupMethod == "displayPin") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodDisplayPin);
} else if (setupMethod == "enterPin") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodEnterPin);
} else {
deviceClass.setSetupMethod(DeviceClass::SetupMethodJustAdd);
}
deviceClass.setPairingInfo(jo.value("pairingInfo").toString());
deviceClass.setParamTypes(parseParamTypes(jo.value("paramTypes").toArray()));
QList<ActionType> actionTypes;
QList<StateType> stateTypes;
foreach (const QJsonValue &stateTypesJson, jo.value("stateTypes").toArray()) {
QJsonObject st = stateTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "type" << "id" << "name", st);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in stateTypes";
broken = true;
break;
}
QVariant::Type t = QVariant::nameToType(st.value("type").toString().toLatin1().data());
StateType stateType(st.value("id").toString());
stateType.setName(st.value("name").toString());
stateType.setType(t);
stateType.setUnit(unitStringToUnit(st.value("unit").toString()));
stateType.setDefaultValue(st.value("defaultValue").toVariant());
stateTypes.append(stateType);
// create ActionType if this StateType is writable
if (st.contains("writable")) {
ActionType actionType(st.value("id").toString());
actionType.setName("set " + st.value("name").toString());
// Note: fields already checked in StateType
ParamType paramType(st.value("name").toString(), t, st.value("defaultValue").toVariant());
if (st.value("writable").toObject().contains("allowedValues")) {
QVariantList allowedValues;
foreach (const QJsonValue &allowedTypesJson, st.value("writable").toObject().value("allowedValues").toArray()) {
allowedValues.append(allowedTypesJson.toVariant());
}
paramType.setAllowedValues(allowedValues);
}
paramType.setInputType(inputTypeStringToInputType(st.value("writable").toObject().value("inputType").toString()));
paramType.setUnit(unitStringToUnit(st.value("unit").toString()));
paramType.setLimits(st.value("writable").toObject().value("minValue").toVariant(),
st.value("writable").toObject().value("maxValue").toVariant());
actionType.setParamTypes(QList<ParamType>() << paramType);
actionTypes.append(actionType);
}
}
deviceClass.setStateTypes(stateTypes);
foreach (const QJsonValue &actionTypesJson, jo.value("actionTypes").toArray()) {
QJsonObject at = actionTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "id" << "name", at);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in actionTypes";
broken = true;
break;
}
ActionType actionType(at.value("id").toString());
actionType.setName(at.value("name").toString());
actionType.setParamTypes(parseParamTypes(at.value("paramTypes").toArray()));
actionTypes.append(actionType);
}
deviceClass.setActionTypes(actionTypes);
QList<EventType> eventTypes;
foreach (const QJsonValue &eventTypesJson, jo.value("eventTypes").toArray()) {
QJsonObject et = eventTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "id" << "name", et);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in eventTypes";
broken = true;
break;
}
EventType eventType(et.value("id").toString());
eventType.setName(et.value("name").toString());
eventType.setParamTypes(parseParamTypes(et.value("paramTypes").toArray()));
eventTypes.append(eventType);
}
deviceClass.setEventTypes(eventTypes);
if (!broken) {
deviceClasses.append(deviceClass);
}
}
CMPIStatus TestMethodProviderInvokeMethod (
CMPIMethodMI * mi,
const CMPIContext * ctx,
const CMPIResult * rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in,
CMPIArgs * out)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIString *className;
CMPIData data;
char result[80] = "Hello,";
const char *strCat;
const char * name;
char *argName = "Message";
CMPIString * str1;
CMPIString * str2;
CMPIValue val1, val2;
/* get the class name from object-path */
className = CMGetClassName(ref, &rc);
/* get a pointer to a C char* representation of this String. */
name = CMGetCharsPtr(className, &rc);
if(!strcmp(name, _ClassName))
{
if(!strcmp ("SayHello", methodName))
{
/* gets the number of arguments contained in "in" Args. */
if(CMGetArgCount(in, &rc) > 0)
{
/* gets a Name argument value */
data = CMGetArg(in, "Name", &rc);
/*check for data type and not null value of argument value
recieved */
if(data.type == CMPI_string && !(CMIsNullValue(data)))
{
strCat = CMGetCharsPtr(data.value.string, &rc);
strcat(result, strCat);
// strcat(result, "!");
/* create the new string to return to client */
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
}
else
{
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
/* create string to add to an array */
str2 = CMNewString(_broker,"Have a good day", &rc);
val2.string = str2;
/* Adds a value of str2 string to out array argument */
rc = CMAddArg(out, argName, &val2, CMPI_string);
} else if (!strcmp("CheckArrayNoType", methodName)) {
data = CMGetArg(in, "IntArray", &rc);
CMPIType atype=data.value.array->ft->getSimpleType(data.value.array,&rc);
sprintf(result,"Datatype is %s",paramType(atype));
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
}
CMReturnData (rslt, (CMPIValue *) &val1, CMPI_string);
CMReturnDone (rslt);
return rc;
}
bool CallCandidate::isMoreSpecific(const CallCandidate * other) const {
bool same = true;
if (paramAssignments_.size() != other->paramAssignments_.size()) {
diag.info() << "different number of args.";
return false;
}
// TODO: Factor in return type.
/*if (!resultType()->isEqual(other->resultType())) {
if (!resultType()->isSubtype(other->resultType())) {
return false;
}
same = false;
}*/
// Note - I think we want to compare candidates in their *unbound* state.
// So other than type aliases, we don't want to dereference any types.
size_t argCount = paramAssignments_.size();
for (size_t i = 0; i < argCount; ++i) {
QualifiedType t0 = paramType(i);
QualifiedType t1 = other->paramType(i);
TypeRelation::RelativeSpecificity rspec = TypeRelation::isMoreSpecific(t0, t1);
if (rspec == TypeRelation::NOT_MORE_SPECIFIC) {
return false;
} else if (rspec == TypeRelation::MORE_SPECIFIC) {
same = false;
} else {
// Variadic parameters are less specific than non-variadic parameters.
const ParameterDefn * p0 = fnType_->param(parameterIndex(i));
const ParameterDefn * p1 = other->fnType_->param(other->parameterIndex(i));
if (p0->isVariadic()) {
if (!p1->isVariadic()) {
return false;
}
} else if (p1->isVariadic()) {
same = false;
}
}
}
if (same) {
// If this method has fewer default params than the other, then it is more
// specific.
if (method_->params().size() < other->method()->params().size()) {
return true;
}
// If one is a template, than it is less specific than the other.
// TODO: If they are both templates, choose the one with the smaller number
// of template parameters. Although explicitly bound parameters should not count, only
// deduced parameters.
if (!method_->isTemplate() && other->method()->isTemplate()) {
return true;
}
if (method_->isTemplate() && !other->method()->isTemplate()) {
return false;
}
if (typeParams_ == NULL && other->typeParams_ != NULL) {
return true;
}
if (typeParams_ != NULL && other->typeParams_ != NULL) {
}
// TODO: This is a temporary kludge - should really compare the two template parameter
// lists and see which one is more tightly bound.
if (!method_->hasUnboundTypeParams() && other->method()->hasUnboundTypeParams()) {
return true;
}
if (conditionCount_ > other->conditionCount_) {
return true;
}
}
// Return true if they are not the same.
return !same;
}
void PacketUtility::add(string* val, string label)
{
this->_params.push_back(paramType(AnyParameter::P_STRING, val, string("")));
}
void PacketUtility::add(float* val, string label)
{
this->_params.push_back(paramType(AnyParameter::P_FLOAT, val, label));
}
CMPIStatus
TestMethodProviderInvokeMethod(CMPIMethodMI * mi,
const CMPIContext *ctx,
const CMPIResult *rslt,
const CMPIObjectPath * ref,
const char *methodName,
const CMPIArgs * in, CMPIArgs * out)
{
CMPIStatus rc = { CMPI_RC_OK, NULL };
CMPIString *className;
CMPIData data;
char result[80] = "Hello,";
const char *strCat;
const char *name;
char *argName = "Message";
CMPIString *str1;
CMPIString *str2;
CMPIValue val1,
val2;
/*
* get the class name from object-path
*/
className = CMGetClassName(ref, &rc);
/*
* get a pointer to a C char* representation of this String.
*/
name = CMGetCharsPtr(className, &rc);
if (!strcmp(name, _ClassName)) {
if (!strcmp("SayHello", methodName)) {
/*
* gets the number of arguments contained in "in" Args.
*/
if (CMGetArgCount(in, &rc) > 0) {
/*
* gets a Name argument value
*/
data = CMGetArg(in, "Name", &rc);
/*
* check for data type and not null value of argument value
* recieved
*/
if (data.type == CMPI_string && !(CMIsNullValue(data))) {
strCat = CMGetCharsPtr(data.value.string, &rc);
strcat(result, strCat);
// strcat(result, "!");
/*
* create the new string to return to client
*/
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
} else {
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
/*
* create string to add to an array
*/
str2 = CMNewString(_broker, "Have a good day", &rc);
val2.string = str2;
/*
* Adds a value of str2 string to out array argument
*/
rc = CMAddArg(out, argName, &val2, CMPI_string);
/*
* For: 3048960 method array types not filled in Test provider.
*/
} else if (!strcmp("CheckArrayNoType", methodName)) {
data = CMGetArg(in, "IntArray", &rc);
CMPIType atype=data.value.array->ft->getSimpleType(data.value.array,&rc);
sprintf(result,"Datatype is %s",paramType(atype));
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
/*
* This method simulates various provider problems for testing.
*/
} else if (!strcmp("Misbehave", methodName)) {
data = CMGetArg(in, "Action", &rc);
const char *strval = NULL;
if (data.type == CMPI_string && !(CMIsNullValue(data))) {
strval = CMGetCharsPtr(data.value.string, &rc);
sprintf(result, "data type is %s, value = %s", paramType(data.type),
strval);
if (!strcmp(strval,"hang")) {
while(sleep(60)); /* to test req handler timeout, etc. */
}
else if (!strcmp(strval,"abort")) {
abort();
}
else if (!strcmp(strval,"fpe")) {
#pragma GCC diagnostic ignored "-Wdiv-by-zero"
fprintf(stderr,"ouch! %d\n",1/0);
#pragma GCC diagnostic warning "-Wdiv-by-zero"
}
else if (!strcmp(strval,"segfault")) {
void (*crashme)(void) = NULL;
crashme();
}
/*
* These tend to behave as if the condition were raised internally
*/
else if (!strcmp(strval,"sigabrt")) {
kill(getpid(), SIGABRT);
while(sleep(3)); /* slight pause to ensure we catch signal */
}
else if (!strcmp(strval,"sigfpe")) {
kill(getpid(), SIGFPE);
while(sleep(3));
}
else if (!strcmp(strval,"sigsegv")) {
kill(getpid(), SIGSEGV);
while(sleep(3));
}
else if (!strcmp(strval,"sigusr1")) {
kill(getpid(), SIGUSR1); /* as if we received a signal from stopBroker() */
while(sleep(3));
}
else if (!strcmp(strval,"sigkill")) {
kill(getpid(), SIGKILL); /* this is currently not handled by providerDrv*/
while(sleep(3));
} else {
sprintf(result, "Action not recognized: %s", strval);
fprintf(stderr,
"+++ cmpiTestMethodProvider: Action not recognized \"%s\"\n",
strval);
}
/*
* create the new string to return to client
*/
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
} else {
sprintf(result, "Unknown method name: %s", methodName);
fprintf(stderr,
"+++ cmpiTestMethodProvider: Unknown method name \"%s\"\n",
methodName);
str1 = CMNewString(_broker, result, &rc);
val1.string = str1;
}
}
CMReturnData(rslt, (CMPIValue *) & val1, CMPI_string);
CMReturnDone(rslt);
return rc;
}
/*! Return a list of \l{DeviceClass}{DeviceClasses} describing all the devices supported by this plugin.
If a DeviceClass has an invalid parameter it will be ignored.
*/
QList<DeviceClass> DevicePlugin::supportedDevices() const
{
QList<DeviceClass> deviceClasses;
foreach (const QJsonValue &vendorJson, m_metaData.value("vendors").toArray()) {
bool broken = false;
VendorId vendorId = vendorJson.toObject().value("id").toString();
foreach (const QJsonValue &deviceClassJson, vendorJson.toObject().value("deviceClasses").toArray()) {
QJsonObject jo = deviceClassJson.toObject();
DeviceClass deviceClass(pluginId(), vendorId, jo.value("deviceClassId").toString());
deviceClass.setName(jo.value("name").toString());
DeviceClass::CreateMethods createMethods;
foreach (const QJsonValue &createMethodValue, jo.value("createMethods").toArray()) {
if (createMethodValue.toString() == "discovery") {
createMethods |= DeviceClass::CreateMethodDiscovery;
} else if (createMethodValue.toString() == "auto") {
createMethods |= DeviceClass::CreateMethodAuto;
} else if (createMethodValue.toString() == "user") {
createMethods |= DeviceClass::CreateMethodUser;
} else {
qCWarning(dcDeviceManager) << "Unknown createMehtod" << createMethodValue.toString() <<
"in deviceClass " << deviceClass.name() << ". Falling back to CreateMethodUser.";
createMethods |= DeviceClass::CreateMethodUser;
}
}
deviceClass.setCreateMethods(createMethods);
deviceClass.setDeviceIcon(loadAndVerifyDeviceIcon(jo.value("deviceIcon").toString()));
deviceClass.setDiscoveryParamTypes(parseParamTypes(jo.value("discoveryParamTypes").toArray()));
QString setupMethod = jo.value("setupMethod").toString();
if (setupMethod == "pushButton") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodPushButton);
} else if (setupMethod == "displayPin") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodDisplayPin);
} else if (setupMethod == "enterPin") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodEnterPin);
} else if (setupMethod == "justAdd") {
qCWarning(dcDeviceManager) << "Unknown setupMehtod" << setupMethod <<
"in deviceClass " << deviceClass.name() << ". Falling back to SetupMethodJustAdd.";
deviceClass.setSetupMethod(DeviceClass::SetupMethodJustAdd);
}
deviceClass.setPairingInfo(jo.value("pairingInfo").toString());
deviceClass.setParamTypes(parseParamTypes(jo.value("paramTypes").toArray()));
QList<DeviceClass::BasicTag> basicTags;
foreach (const QJsonValue &basicTagJson, jo.value("basicTags").toArray()) {
basicTags.append(loadAndVerifyBasicTag(basicTagJson.toString()));
}
deviceClass.setBasicTags(basicTags);
QList<ActionType> actionTypes;
QList<StateType> stateTypes;
foreach (const QJsonValue &stateTypesJson, jo.value("stateTypes").toArray()) {
QJsonObject st = stateTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "type" << "id" << "name", st);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in stateTypes";
broken = true;
break;
}
QVariant::Type t = QVariant::nameToType(st.value("type").toString().toLatin1().data());
StateType stateType(st.value("id").toString());
stateType.setName(st.value("name").toString());
stateType.setType(t);
stateType.setUnit(loadAndVerifyUnit(st.value("unit").toString()));
stateType.setDefaultValue(st.value("defaultValue").toVariant());
if (st.contains("minValue"))
stateType.setMinValue(st.value("minValue").toVariant());
if (st.contains("maxValue"))
stateType.setMaxValue(st.value("maxValue").toVariant());
if (st.contains("possibleValues")) {
QVariantList possibleValues;
foreach (const QJsonValue &possibleValueJson, st.value("possibleValues").toArray()) {
possibleValues.append(possibleValueJson.toVariant());
}
stateType.setPossibleValues(possibleValues);
// inform the plugin developer about the error in the plugin json file
Q_ASSERT_X(stateType.possibleValues().contains(stateType.defaultValue()),
QString("\"%1\" plugin").arg(pluginName()).toLatin1().data(),
QString("The given default value \"%1\" is not in the possible values of the stateType \"%2\".")
.arg(stateType.defaultValue().toString()).arg(stateType.name()).toLatin1().data());
}
stateTypes.append(stateType);
// create ActionType if this StateType is writable
if (st.contains("writable") && st.value("writable").toBool()) {
// Note: fields already checked in StateType
ActionType actionType(ActionTypeId(stateType.id().toString()));
actionType.setName("set " + stateType.name());
ParamType paramType(stateType.name(), t, stateType.defaultValue());
paramType.setAllowedValues(stateType.possibleValues());
paramType.setUnit(stateType.unit());
paramType.setLimits(stateType.minValue(), stateType.maxValue());
actionType.setParamTypes(QList<ParamType>() << paramType);
actionTypes.append(actionType);
}
}
deviceClass.setStateTypes(stateTypes);
foreach (const QJsonValue &actionTypesJson, jo.value("actionTypes").toArray()) {
QJsonObject at = actionTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "id" << "name", at);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in actionTypes";
broken = true;
break;
}
ActionType actionType(at.value("id").toString());
actionType.setName(at.value("name").toString());
actionType.setParamTypes(parseParamTypes(at.value("paramTypes").toArray()));
actionTypes.append(actionType);
}
deviceClass.setActionTypes(actionTypes);
QList<EventType> eventTypes;
foreach (const QJsonValue &eventTypesJson, jo.value("eventTypes").toArray()) {
QJsonObject et = eventTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "id" << "name", et);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in eventTypes";
broken = true;
break;
}
EventType eventType(et.value("id").toString());
eventType.setName(et.value("name").toString());
eventType.setParamTypes(parseParamTypes(et.value("paramTypes").toArray()));
eventTypes.append(eventType);
}
deviceClass.setEventTypes(eventTypes);
if (!broken)
deviceClasses.append(deviceClass);
}
}