node-alljoyn
Version:
Access Alljoyn service functions
470 lines (467 loc) • 184 kB
JavaScript
/*
* Copyright (c) 2011, 2013, AllSeen Alliance. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
AsyncTestCase("MarshalTest", {
_setUp: ondeviceready(function(callback) {
otherBus = undefined;
bus = new org.alljoyn.bus.BusAttachment();
bus.create(false, callback);
}),
tearDown: function() {
otherBus && otherBus.destroy();
bus.destroy();
},
testBasic: function(queue) {
queue.call(function(callbacks) {
var connect = function(err) {
assertFalsy(err);
bus.connect(callbacks.add(createInterface));
};
var createInterface = function(err) {
bus.createInterface({ name: 'interface.b', method: [ { name: 'Methodb', signature: 'b', returnSignature: 'b' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.d', method: [ { name: 'Methodd', signature: 'd', returnSignature: 'd' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.g', method: [ { name: 'Methodg', signature: 'g', returnSignature: 'g' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.i', method: [ { name: 'Methodi', signature: 'i', returnSignature: 'i' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.n', method: [ { name: 'Methodn', signature: 'n', returnSignature: 'n' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.o', method: [ { name: 'Methodo', signature: 'o', returnSignature: 'o' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.q', method: [ { name: 'Methodq', signature: 'q', returnSignature: 'q' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.s', method: [ { name: 'Methods', signature: 's', returnSignature: 's' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.t', method: [ { name: 'Methodt', signature: 't', returnSignature: 't' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.u', method: [ { name: 'Methodu', signature: 'u', returnSignature: 'u' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.x', method: [ { name: 'Methodx', signature: 'x', returnSignature: 'x' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.y', method: [ { name: 'Methody', signature: 'y', returnSignature: 'y' } ] }, callbacks.add(registerBusObject))
}))}))}))}))}))}))}))}))}))}))}))};
var registerBusObject = function(err) {
bus.registerBusObject('/testObject',
{
'interface.b': { Methodb: function(context, arg) { context.reply(arg); } },
'interface.d': { Methodd: function(context, arg) { context.reply(arg); } },
'interface.g': { Methodg: function(context, arg) { context.reply(arg); } },
'interface.i': { Methodi: function(context, arg) { context.reply(arg); } },
'interface.n': { Methodn: function(context, arg) { context.reply(arg); } },
'interface.o': { Methodo: function(context, arg) { context.reply(arg); } },
'interface.q': { Methodq: function(context, arg) { context.reply(arg); } },
'interface.s': { Methods: function(context, arg) { context.reply(arg); } },
'interface.t': { Methodt: function(context, arg) { context.reply(arg); } },
'interface.u': { Methodu: function(context, arg) { context.reply(arg); } },
'interface.x': { Methodx: function(context, arg) { context.reply(arg); } },
'interface.y': { Methody: function(context, arg) { context.reply(arg); } }
},
false,
callbacks.add(getProxyObj));
};
var getProxyObj = function(err) {
assertFalsy(err);
bus.getProxyBusObject(bus.uniqueName + '/testObject', callbacks.add(methodb));
};
var proxy;
var methodb = function(err, proxyObj) {
assertFalsy(err);
proxy = proxyObj;
proxy.methodCall('interface.b', 'Methodb', true, callbacks.add(onReplyb));
};
var onReplyb = function(err, context, argb) {
assertFalsy(err);
assertEquals(true, argb);
proxy.methodCall('interface.d', 'Methodd', 1.234, callbacks.add(onReplyd));
};
var onReplyd = function(err, context, argd) {
assertFalsy(err);
assertEquals(1.234, argd);
proxy.methodCall('interface.g', 'Methodg', "sig", callbacks.add(onReplyg));
};
var onReplyg = function(err, context, argg) {
assertFalsy(err);
assertEquals("sig", argg);
proxy.methodCall('interface.i', 'Methodi', -1, callbacks.add(onReplyi));
};
var onReplyi = function(err, context, argi) {
assertFalsy(err);
assertEquals(-1, argi);
proxy.methodCall('interface.n', 'Methodn', -2, callbacks.add(onReplyn));
};
var onReplyn = function(err, context, argn) {
assertFalsy(err);
assertEquals(-2, argn);
proxy.methodCall('interface.o', 'Methodo', "/path", callbacks.add(onReplyo));
};
var onReplyo = function(err, context, argo) {
assertFalsy(err);
assertEquals("/path", argo);
proxy.methodCall('interface.q', 'Methodq', 3, callbacks.add(onReplyq));
};
var onReplyq = function(err, context, argq) {
assertFalsy(err);
assertEquals(3, argq);
proxy.methodCall('interface.s', 'Methods', "string", callbacks.add(onReplys));
};
var onReplys = function(err, context, args) {
assertFalsy(err);
assertEquals("string", args);
proxy.methodCall('interface.t', 'Methodt', 4, callbacks.add(onReplyt));
};
var onReplyt = function(err, context, argt) {
assertFalsy(err);
assertEquals(4, argt);
proxy.methodCall('interface.u', 'Methodu', 5, callbacks.add(onReplyu));
};
var onReplyu = function(err, context, argu) {
assertFalsy(err);
assertEquals(5, argu);
proxy.methodCall('interface.x', 'Methodx', -6, callbacks.add(onReplyx));
};
var onReplyx = function(err, context, argx) {
assertFalsy(err);
assertEquals(-6, argx);
proxy.methodCall('interface.y', 'Methody', 7, callbacks.add(onReplyy));
};
var onReplyy = function(err, context, argy) {
assertFalsy(err);
assertEquals(7, argy);
};
this._setUp(callbacks.add(connect));
});
},
testArray: function(queue) {
queue.call(function(callbacks) {
var connect = function(err) {
assertFalsy(err);
bus.connect(callbacks.add(createInterface));
};
var createInterface = function(err) {
bus.createInterface({ name: 'interface.ab', method: [ { name: 'Methodab', signature: 'ab', returnSignature: 'ab' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ad', method: [ { name: 'Methodad', signature: 'ad', returnSignature: 'ad' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ag', method: [ { name: 'Methodag', signature: 'ag', returnSignature: 'ag' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ai', method: [ { name: 'Methodai', signature: 'ai', returnSignature: 'ai' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.an', method: [ { name: 'Methodan', signature: 'an', returnSignature: 'an' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ao', method: [ { name: 'Methodao', signature: 'ao', returnSignature: 'ao' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.aq', method: [ { name: 'Methodaq', signature: 'aq', returnSignature: 'aq' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.as', method: [ { name: 'Methodas', signature: 'as', returnSignature: 'as' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.at', method: [ { name: 'Methodat', signature: 'at', returnSignature: 'at' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.au', method: [ { name: 'Methodau', signature: 'au', returnSignature: 'au' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ax', method: [ { name: 'Methodax', signature: 'ax', returnSignature: 'ax' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ay', method: [ { name: 'Methoday', signature: 'ay', returnSignature: 'ay' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.aas', method: [ { name: 'Methodaas', signature: 'aas', returnSignature: 'aas' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ae', method: [ { name: 'Methodae', signature: 'aa{ss}', returnSignature: 'aa{ss}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ar', method: [ { name: 'Methodar', signature: 'a(s)', returnSignature: 'a(s)' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.av', method: [ { name: 'Methodav', signature: 'av', returnSignature: 'av' } ] }, callbacks.add(registerBusObject))
}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))};
var registerBusObject = function(err) {
bus.registerBusObject('/testObject',
{
'interface.ab': { Methodab: function(context, arg) { context.reply(arg); } },
'interface.ad': { Methodad: function(context, arg) { context.reply(arg); } },
'interface.ag': { Methodag: function(context, arg) { context.reply(arg); } },
'interface.ai': { Methodai: function(context, arg) { context.reply(arg); } },
'interface.an': { Methodan: function(context, arg) { context.reply(arg); } },
'interface.ao': { Methodao: function(context, arg) { context.reply(arg); } },
'interface.aq': { Methodaq: function(context, arg) { context.reply(arg); } },
'interface.as': { Methodas: function(context, arg) { context.reply(arg); } },
'interface.at': { Methodat: function(context, arg) { context.reply(arg); } },
'interface.au': { Methodau: function(context, arg) { context.reply(arg); } },
'interface.ax': { Methodax: function(context, arg) { context.reply(arg); } },
'interface.ay': { Methoday: function(context, arg) { context.reply(arg); } },
'interface.aas': { Methodaas: function(context, arg) { context.reply(arg); } },
'interface.ae': { Methodae: function(context, arg) { context.reply(arg); } },
'interface.ar': { Methodar: function(context, arg) { context.reply(arg); } },
'interface.av': {
Methodav: function(context, arg) {
var args = [];
for (var i = 0; i < arg.length; ++i) {
args[i] = { 's': arg[i] };
}
context.reply(args);
}
}
},
false,
callbacks.add(getProxyObj));
};
var getProxyObj = function(err) {
assertFalsy(err);
bus.getProxyBusObject(bus.uniqueName + '/testObject', callbacks.add(methodab));
};
var proxy;
var methodab = function(err, proxyObj) {
assertFalsy(err);
proxy = proxyObj;
proxy.methodCall('interface.ab', 'Methodab', [ true, true ], callbacks.add(onReplyab));
};
var onReplyab = function(err, context, argab) {
err && console.log('err.name = ' + err.name + ' err.code = ' + err.code);
assertFalsy(err);
assertEquals([ true, true ], argab);
proxy.methodCall('interface.ad', 'Methodad', [ 1.234, 1.234 ], callbacks.add(onReplyad));
};
var onReplyad = function(err, context, argad) {
assertFalsy(err);
assertEquals([ 1.234, 1.234 ], argad);
proxy.methodCall('interface.ag', 'Methodag', [ "sig", "sig" ], callbacks.add(onReplyag));
};
var onReplyag = function(err, context, argag) {
assertFalsy(err);
assertEquals([ "sig", "sig" ], argag);
proxy.methodCall('interface.ai', 'Methodai', [ -1, -1 ], callbacks.add(onReplyai));
};
var onReplyai = function(err, context, argai) {
assertFalsy(err);
assertEquals([ -1, -1 ], argai);
proxy.methodCall('interface.an', 'Methodan', [ -2, -2 ], callbacks.add(onReplyan));
};
var onReplyan = function(err, context, argan) {
assertFalsy(err);
assertEquals([ -2, -2 ], argan);
proxy.methodCall('interface.ao', 'Methodao', [ "/path", "/path" ], callbacks.add(onReplyao));
};
var onReplyao = function(err, context, argao) {
assertFalsy(err);
assertEquals([ "/path", "/path" ], argao);
proxy.methodCall('interface.aq', 'Methodaq', [ 3, 3 ], callbacks.add(onReplyaq));
};
var onReplyaq = function(err, context, argaq) {
assertFalsy(err);
assertEquals([ 3, 3 ], argaq);
proxy.methodCall('interface.as', 'Methodas', [ "string", "string" ], callbacks.add(onReplyas));
};
var onReplyas = function(err, context, argas) {
assertFalsy(err);
assertEquals([ "string", "string" ], argas);
proxy.methodCall('interface.at', 'Methodat', [ 4, 4 ], callbacks.add(onReplyat));
};
var onReplyat = function(err, context, argat) {
assertFalsy(err);
argat[0] = parseInt(argat[0]);
argat[1] = parseInt(argat[1]);
assertEquals([ 4, 4 ], argat);
proxy.methodCall('interface.au', 'Methodau', [ 5, 5 ], callbacks.add(onReplyau));
};
var onReplyau = function(err, context, argau) {
assertFalsy(err);
assertEquals([ 5, 5 ], argau);
proxy.methodCall('interface.ax', 'Methodax', [ -6, -6 ], callbacks.add(onReplyax));
};
var onReplyax = function(err, context, argax) {
assertFalsy(err);
argax[0] = parseInt(argax[0]);
argax[1] = parseInt(argax[1]);
assertEquals([ -6, -6 ], argax);
proxy.methodCall('interface.ay', 'Methoday', [ 7, 7 ], callbacks.add(onReplyay));
};
var onReplyay = function(err, context, argay) {
assertFalsy(err);
assertEquals([ 7, 7 ], argay);
proxy.methodCall('interface.aas', 'Methodaas', [ ["s0", "s1"], ["s0", "s1"] ], callbacks.add(onReplyaas));
};
var onReplyaas = function(err, context, argaas) {
assertFalsy(err);
assertEquals([ ["s0", "s1"], ["s0", "s1"] ], argaas);
proxy.methodCall('interface.ae', 'Methodae', [ { key0: "value0", key1: "value1" }, { key0: "value0", key1: "value1" } ], callbacks.add(onReplyae));
};
var onReplyae = function(err, context, argae) {
assertFalsy(err);
assertEquals([ { key0: "value0", key1: "value1" }, { key0: "value0", key1: "value1" } ], argae);
proxy.methodCall('interface.ar', 'Methodar', [ ["string"], ["string"] ], callbacks.add(onReplyar));
};
var onReplyar = function(err, context, argar) {
assertFalsy(err);
assertEquals([ ["string"], ["string"] ], argar);
proxy.methodCall('interface.av', 'Methodav', [ { s: "string" }, { s: "string" } ], callbacks.add(onReplyav));
};
var onReplyav = function(err, context, argav) {
err && console.log('err.name = ' + err.name + ' err.code = ' + err.code);
assertFalsy(err);
assertEquals([ "string", "string" ], argav);
};
this._setUp(callbacks.add(connect));
});
},
testDictionary: function(queue) {
queue.call(function(callbacks) {
var connect = function(err) {
assertFalsy(err);
bus.connect(callbacks.add(createInterface));
};
var createInterface = function(err) {
bus.createInterface({ name: 'interface.ebb', method: [ { name: 'Methodebb', signature: 'a{bb}', returnSignature: 'a{bb}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebd', method: [ { name: 'Methodebd', signature: 'a{bd}', returnSignature: 'a{bd}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebg', method: [ { name: 'Methodebg', signature: 'a{bg}', returnSignature: 'a{bg}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebi', method: [ { name: 'Methodebi', signature: 'a{bi}', returnSignature: 'a{bi}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebn', method: [ { name: 'Methodebn', signature: 'a{bn}', returnSignature: 'a{bn}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebo', method: [ { name: 'Methodebo', signature: 'a{bo}', returnSignature: 'a{bo}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebq', method: [ { name: 'Methodebq', signature: 'a{bq}', returnSignature: 'a{bq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebs', method: [ { name: 'Methodebs', signature: 'a{bs}', returnSignature: 'a{bs}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebt', method: [ { name: 'Methodebt', signature: 'a{bt}', returnSignature: 'a{bt}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebu', method: [ { name: 'Methodebu', signature: 'a{bu}', returnSignature: 'a{bu}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebx', method: [ { name: 'Methodebx', signature: 'a{bx}', returnSignature: 'a{bx}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eby', method: [ { name: 'Methodeby', signature: 'a{by}', returnSignature: 'a{by}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebas', method: [ { name: 'Methodebas', signature: 'a{bas}', returnSignature: 'a{bas}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebe', method: [ { name: 'Methodebe', signature: 'a{ba{ss}}', returnSignature: 'a{ba{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebr', method: [ { name: 'Methodebr', signature: 'a{b(s)}', returnSignature: 'a{b(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ebv', method: [ { name: 'Methodebv', signature: 'a{bv}', returnSignature: 'a{bv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edb', method: [ { name: 'Methodedb', signature: 'a{db}', returnSignature: 'a{db}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edd', method: [ { name: 'Methodedd', signature: 'a{dd}', returnSignature: 'a{dd}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edg', method: [ { name: 'Methodedg', signature: 'a{dg}', returnSignature: 'a{dg}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edi', method: [ { name: 'Methodedi', signature: 'a{di}', returnSignature: 'a{di}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edn', method: [ { name: 'Methodedn', signature: 'a{dn}', returnSignature: 'a{dn}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edo', method: [ { name: 'Methodedo', signature: 'a{do}', returnSignature: 'a{do}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edq', method: [ { name: 'Methodedq', signature: 'a{dq}', returnSignature: 'a{dq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eds', method: [ { name: 'Methodeds', signature: 'a{ds}', returnSignature: 'a{ds}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edt', method: [ { name: 'Methodedt', signature: 'a{dt}', returnSignature: 'a{dt}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edu', method: [ { name: 'Methodedu', signature: 'a{du}', returnSignature: 'a{du}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edx', method: [ { name: 'Methodedx', signature: 'a{dx}', returnSignature: 'a{dx}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edy', method: [ { name: 'Methodedy', signature: 'a{dy}', returnSignature: 'a{dy}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edas', method: [ { name: 'Methodedas', signature: 'a{das}', returnSignature: 'a{das}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ede', method: [ { name: 'Methodede', signature: 'a{da{ss}}', returnSignature: 'a{da{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edr', method: [ { name: 'Methodedr', signature: 'a{d(s)}', returnSignature: 'a{d(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.edv', method: [ { name: 'Methodedv', signature: 'a{dv}', returnSignature: 'a{dv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egb', method: [ { name: 'Methodegb', signature: 'a{gb}', returnSignature: 'a{gb}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egd', method: [ { name: 'Methodegd', signature: 'a{gd}', returnSignature: 'a{gd}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egg', method: [ { name: 'Methodegg', signature: 'a{gg}', returnSignature: 'a{gg}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egi', method: [ { name: 'Methodegi', signature: 'a{gi}', returnSignature: 'a{gi}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egn', method: [ { name: 'Methodegn', signature: 'a{gn}', returnSignature: 'a{gn}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ego', method: [ { name: 'Methodego', signature: 'a{go}', returnSignature: 'a{go}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egq', method: [ { name: 'Methodegq', signature: 'a{gq}', returnSignature: 'a{gq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egs', method: [ { name: 'Methodegs', signature: 'a{gs}', returnSignature: 'a{gs}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egt', method: [ { name: 'Methodegt', signature: 'a{gt}', returnSignature: 'a{gt}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egu', method: [ { name: 'Methodegu', signature: 'a{gu}', returnSignature: 'a{gu}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egx', method: [ { name: 'Methodegx', signature: 'a{gx}', returnSignature: 'a{gx}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egy', method: [ { name: 'Methodegy', signature: 'a{gy}', returnSignature: 'a{gy}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egas', method: [ { name: 'Methodegas', signature: 'a{gas}', returnSignature: 'a{gas}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ege', method: [ { name: 'Methodege', signature: 'a{ga{ss}}', returnSignature: 'a{ga{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egr', method: [ { name: 'Methodegr', signature: 'a{g(s)}', returnSignature: 'a{g(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.egv', method: [ { name: 'Methodegv', signature: 'a{gv}', returnSignature: 'a{gv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eib', method: [ { name: 'Methodeib', signature: 'a{ib}', returnSignature: 'a{ib}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eid', method: [ { name: 'Methodeid', signature: 'a{id}', returnSignature: 'a{id}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eig', method: [ { name: 'Methodeig', signature: 'a{ig}', returnSignature: 'a{ig}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eii', method: [ { name: 'Methodeii', signature: 'a{ii}', returnSignature: 'a{ii}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ein', method: [ { name: 'Methodein', signature: 'a{in}', returnSignature: 'a{in}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eio', method: [ { name: 'Methodeio', signature: 'a{io}', returnSignature: 'a{io}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eiq', method: [ { name: 'Methodeiq', signature: 'a{iq}', returnSignature: 'a{iq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eis', method: [ { name: 'Methodeis', signature: 'a{is}', returnSignature: 'a{is}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eit', method: [ { name: 'Methodeit', signature: 'a{it}', returnSignature: 'a{it}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eiu', method: [ { name: 'Methodeiu', signature: 'a{iu}', returnSignature: 'a{iu}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eix', method: [ { name: 'Methodeix', signature: 'a{ix}', returnSignature: 'a{ix}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eiy', method: [ { name: 'Methodeiy', signature: 'a{iy}', returnSignature: 'a{iy}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eias', method: [ { name: 'Methodeias', signature: 'a{ias}', returnSignature: 'a{ias}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eie', method: [ { name: 'Methodeie', signature: 'a{ia{ss}}', returnSignature: 'a{ia{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eir', method: [ { name: 'Methodeir', signature: 'a{i(s)}', returnSignature: 'a{i(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eiv', method: [ { name: 'Methodeiv', signature: 'a{iv}', returnSignature: 'a{iv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.enb', method: [ { name: 'Methodenb', signature: 'a{nb}', returnSignature: 'a{nb}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.end', method: [ { name: 'Methodend', signature: 'a{nd}', returnSignature: 'a{nd}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eng', method: [ { name: 'Methodeng', signature: 'a{ng}', returnSignature: 'a{ng}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eni', method: [ { name: 'Methodeni', signature: 'a{ni}', returnSignature: 'a{ni}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.enn', method: [ { name: 'Methodenn', signature: 'a{nn}', returnSignature: 'a{nn}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eno', method: [ { name: 'Methodeno', signature: 'a{no}', returnSignature: 'a{no}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.enq', method: [ { name: 'Methodenq', signature: 'a{nq}', returnSignature: 'a{nq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ens', method: [ { name: 'Methodens', signature: 'a{ns}', returnSignature: 'a{ns}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ent', method: [ { name: 'Methodent', signature: 'a{nt}', returnSignature: 'a{nt}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.enu', method: [ { name: 'Methodenu', signature: 'a{nu}', returnSignature: 'a{nu}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.enx', method: [ { name: 'Methodenx', signature: 'a{nx}', returnSignature: 'a{nx}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eny', method: [ { name: 'Methodeny', signature: 'a{ny}', returnSignature: 'a{ny}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.enas', method: [ { name: 'Methodenas', signature: 'a{nas}', returnSignature: 'a{nas}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ene', method: [ { name: 'Methodene', signature: 'a{na{ss}}', returnSignature: 'a{na{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.enr', method: [ { name: 'Methodenr', signature: 'a{n(s)}', returnSignature: 'a{n(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.env', method: [ { name: 'Methodenv', signature: 'a{nv}', returnSignature: 'a{nv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eob', method: [ { name: 'Methodeob', signature: 'a{ob}', returnSignature: 'a{ob}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eod', method: [ { name: 'Methodeod', signature: 'a{od}', returnSignature: 'a{od}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eog', method: [ { name: 'Methodeog', signature: 'a{og}', returnSignature: 'a{og}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eoi', method: [ { name: 'Methodeoi', signature: 'a{oi}', returnSignature: 'a{oi}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eon', method: [ { name: 'Methodeon', signature: 'a{on}', returnSignature: 'a{on}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eoo', method: [ { name: 'Methodeoo', signature: 'a{oo}', returnSignature: 'a{oo}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eoq', method: [ { name: 'Methodeoq', signature: 'a{oq}', returnSignature: 'a{oq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eos', method: [ { name: 'Methodeos', signature: 'a{os}', returnSignature: 'a{os}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eot', method: [ { name: 'Methodeot', signature: 'a{ot}', returnSignature: 'a{ot}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eou', method: [ { name: 'Methodeou', signature: 'a{ou}', returnSignature: 'a{ou}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eox', method: [ { name: 'Methodeox', signature: 'a{ox}', returnSignature: 'a{ox}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eoy', method: [ { name: 'Methodeoy', signature: 'a{oy}', returnSignature: 'a{oy}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eoas', method: [ { name: 'Methodeoas', signature: 'a{oas}', returnSignature: 'a{oas}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eoe', method: [ { name: 'Methodeoe', signature: 'a{oa{ss}}', returnSignature: 'a{oa{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eor', method: [ { name: 'Methodeor', signature: 'a{o(s)}', returnSignature: 'a{o(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eov', method: [ { name: 'Methodeov', signature: 'a{ov}', returnSignature: 'a{ov}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqb', method: [ { name: 'Methodeqb', signature: 'a{qb}', returnSignature: 'a{qb}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqd', method: [ { name: 'Methodeqd', signature: 'a{qd}', returnSignature: 'a{qd}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqg', method: [ { name: 'Methodeqg', signature: 'a{qg}', returnSignature: 'a{qg}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqi', method: [ { name: 'Methodeqi', signature: 'a{qi}', returnSignature: 'a{qi}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqn', method: [ { name: 'Methodeqn', signature: 'a{qn}', returnSignature: 'a{qn}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqo', method: [ { name: 'Methodeqo', signature: 'a{qo}', returnSignature: 'a{qo}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqq', method: [ { name: 'Methodeqq', signature: 'a{qq}', returnSignature: 'a{qq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqs', method: [ { name: 'Methodeqs', signature: 'a{qs}', returnSignature: 'a{qs}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqt', method: [ { name: 'Methodeqt', signature: 'a{qt}', returnSignature: 'a{qt}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.equ', method: [ { name: 'Methodequ', signature: 'a{qu}', returnSignature: 'a{qu}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqx', method: [ { name: 'Methodeqx', signature: 'a{qx}', returnSignature: 'a{qx}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqy', method: [ { name: 'Methodeqy', signature: 'a{qy}', returnSignature: 'a{qy}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqas', method: [ { name: 'Methodeqas', signature: 'a{qas}', returnSignature: 'a{qas}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqe', method: [ { name: 'Methodeqe', signature: 'a{qa{ss}}', returnSignature: 'a{qa{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqr', method: [ { name: 'Methodeqr', signature: 'a{q(s)}', returnSignature: 'a{q(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eqv', method: [ { name: 'Methodeqv', signature: 'a{qv}', returnSignature: 'a{qv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esb', method: [ { name: 'Methodesb', signature: 'a{sb}', returnSignature: 'a{sb}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esd', method: [ { name: 'Methodesd', signature: 'a{sd}', returnSignature: 'a{sd}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esg', method: [ { name: 'Methodesg', signature: 'a{sg}', returnSignature: 'a{sg}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esi', method: [ { name: 'Methodesi', signature: 'a{si}', returnSignature: 'a{si}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esn', method: [ { name: 'Methodesn', signature: 'a{sn}', returnSignature: 'a{sn}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eso', method: [ { name: 'Methodeso', signature: 'a{so}', returnSignature: 'a{so}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esq', method: [ { name: 'Methodesq', signature: 'a{sq}', returnSignature: 'a{sq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ess', method: [ { name: 'Methodess', signature: 'a{ss}', returnSignature: 'a{ss}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.est', method: [ { name: 'Methodest', signature: 'a{st}', returnSignature: 'a{st}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esu', method: [ { name: 'Methodesu', signature: 'a{su}', returnSignature: 'a{su}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esx', method: [ { name: 'Methodesx', signature: 'a{sx}', returnSignature: 'a{sx}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esy', method: [ { name: 'Methodesy', signature: 'a{sy}', returnSignature: 'a{sy}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esas', method: [ { name: 'Methodesas', signature: 'a{sas}', returnSignature: 'a{sas}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ese', method: [ { name: 'Methodese', signature: 'a{sa{ss}}', returnSignature: 'a{sa{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esr', method: [ { name: 'Methodesr', signature: 'a{s(s)}', returnSignature: 'a{s(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.esv', method: [ { name: 'Methodesv', signature: 'a{sv}', returnSignature: 'a{sv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etb', method: [ { name: 'Methodetb', signature: 'a{tb}', returnSignature: 'a{tb}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etd', method: [ { name: 'Methodetd', signature: 'a{td}', returnSignature: 'a{td}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etg', method: [ { name: 'Methodetg', signature: 'a{tg}', returnSignature: 'a{tg}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eti', method: [ { name: 'Methodeti', signature: 'a{ti}', returnSignature: 'a{ti}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etn', method: [ { name: 'Methodetn', signature: 'a{tn}', returnSignature: 'a{tn}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eto', method: [ { name: 'Methodeto', signature: 'a{to}', returnSignature: 'a{to}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etq', method: [ { name: 'Methodetq', signature: 'a{tq}', returnSignature: 'a{tq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ets', method: [ { name: 'Methodets', signature: 'a{ts}', returnSignature: 'a{ts}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ett', method: [ { name: 'Methodett', signature: 'a{tt}', returnSignature: 'a{tt}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etu', method: [ { name: 'Methodetu', signature: 'a{tu}', returnSignature: 'a{tu}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etx', method: [ { name: 'Methodetx', signature: 'a{tx}', returnSignature: 'a{tx}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ety', method: [ { name: 'Methodety', signature: 'a{ty}', returnSignature: 'a{ty}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etas', method: [ { name: 'Methodetas', signature: 'a{tas}', returnSignature: 'a{tas}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ete', method: [ { name: 'Methodete', signature: 'a{ta{ss}}', returnSignature: 'a{ta{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etr', method: [ { name: 'Methodetr', signature: 'a{t(s)}', returnSignature: 'a{t(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.etv', method: [ { name: 'Methodetv', signature: 'a{tv}', returnSignature: 'a{tv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eub', method: [ { name: 'Methodeub', signature: 'a{ub}', returnSignature: 'a{ub}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eud', method: [ { name: 'Methodeud', signature: 'a{ud}', returnSignature: 'a{ud}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eug', method: [ { name: 'Methodeug', signature: 'a{ug}', returnSignature: 'a{ug}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eui', method: [ { name: 'Methodeui', signature: 'a{ui}', returnSignature: 'a{ui}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eun', method: [ { name: 'Methodeun', signature: 'a{un}', returnSignature: 'a{un}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.euo', method: [ { name: 'Methodeuo', signature: 'a{uo}', returnSignature: 'a{uo}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.euq', method: [ { name: 'Methodeuq', signature: 'a{uq}', returnSignature: 'a{uq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eus', method: [ { name: 'Methodeus', signature: 'a{us}', returnSignature: 'a{us}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eut', method: [ { name: 'Methodeut', signature: 'a{ut}', returnSignature: 'a{ut}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.euu', method: [ { name: 'Methodeuu', signature: 'a{uu}', returnSignature: 'a{uu}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eux', method: [ { name: 'Methodeux', signature: 'a{ux}', returnSignature: 'a{ux}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.euy', method: [ { name: 'Methodeuy', signature: 'a{uy}', returnSignature: 'a{uy}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.euas', method: [ { name: 'Methodeuas', signature: 'a{uas}', returnSignature: 'a{uas}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eue', method: [ { name: 'Methodeue', signature: 'a{ua{ss}}', returnSignature: 'a{ua{ss}}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.eur', method: [ { name: 'Methodeur', signature: 'a{u(s)}', returnSignature: 'a{u(s)}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.euv', method: [ { name: 'Methodeuv', signature: 'a{uv}', returnSignature: 'a{uv}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exb', method: [ { name: 'Methodexb', signature: 'a{xb}', returnSignature: 'a{xb}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exd', method: [ { name: 'Methodexd', signature: 'a{xd}', returnSignature: 'a{xd}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exg', method: [ { name: 'Methodexg', signature: 'a{xg}', returnSignature: 'a{xg}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exi', method: [ { name: 'Methodexi', signature: 'a{xi}', returnSignature: 'a{xi}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exn', method: [ { name: 'Methodexn', signature: 'a{xn}', returnSignature: 'a{xn}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exo', method: [ { name: 'Methodexo', signature: 'a{xo}', returnSignature: 'a{xo}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exq', method: [ { name: 'Methodexq', signature: 'a{xq}', returnSignature: 'a{xq}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exs', method: [ { name: 'Methodexs', signature: 'a{xs}', returnSignature: 'a{xs}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.ext', method: [ { name: 'Methodext', signature: 'a{xt}', returnSignature: 'a{xt}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exu', method: [ { name: 'Methodexu', signature: 'a{xu}', returnSignature: 'a{xu}' } ] }, callbacks.add(function(err) {
bus.createInterface({ name: 'interface.exx', method: [ { name: 'Methodexx', signature: 'a{xx}', returnSignature: 'a{xx}' } ] },