(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@iotize/tap/protocol/core'), require('rxjs'), require('rxjs/operators'), require('@iotize/common/debug'), require('@iotize/common/byte-converter'), require('@iotize/tap/client/api'), require('@iotize/tap/client/impl'), require('@iotize/tap'), require('@iotize/tap/service/core')) :
    typeof define === 'function' && define.amd ? define('@iotize/tap/testing', ['exports', '@iotize/tap/protocol/core', 'rxjs', 'rxjs/operators', '@iotize/common/debug', '@iotize/common/byte-converter', '@iotize/tap/client/api', '@iotize/tap/client/impl', '@iotize/tap', '@iotize/tap/service/core'], factory) :
    (global = global || self, factory((global.iotize = global.iotize || {}, global.iotize.tap = global.iotize.tap || {}, global.iotize.tap.testing = {}), global.iotize.tap.protocol.core, global.rxjs, global.rxjs.operators, global.debug$1, global.byteConverter, global.iotize.tap.client.api, global.iotize.tap.client.impl, global.iotize.tap));
}(this, (function (exports, core, rxjs, operators, debug$1, byteConverter, api, impl, tap) { 'use strict';

    var prefix = '@iotize/tap/testing';
    var debug = debug$1.createDebugger(prefix);

    var MockRouter = /** @class */ (function () {
        function MockRouter() {
            this._routes = [];
        }
        Object.defineProperty(MockRouter.prototype, "routes", {
            //     constructor() {
            //         this._routes = [];
            //     }
            get: function () {
                return this._routes;
            },
            enumerable: true,
            configurable: true
        });
        MockRouter.prototype.findRoute = function (request) {
            var candidates = this._routes.filter(function (r) { return r.predicate(request); });
            if (candidates.length === 0) {
                return undefined;
            }
            else {
                return candidates[0].adapter(request);
            }
        };
        // addRoutes(map: RouteMapping) {
        //     // throw new Error('Method not implemented.');
        //     // TODO 
        // }
        MockRouter.prototype.addRoute = function (predicate, adapter) {
            // var filter: Predicate<Command>;
            // if (typeof left === 'string') {
            //     left = Util.parseApiRequestString(left);
            // }
            // if (left instanceof ApiRequest) {
            //     filter = new EqualRequestFilter(left);
            // } else if (left instanceof RegExp) {
            //     filter = new RegExpFilter(left);
            // } else if (typeof left === 'function') {
            //     filter = {
            //         test: left
            //     };
            // } else {
            //     filter = left as Predicate<Command>;
            // }
            // var adapter: ResponseAdapter<T>;
            // if (right instanceof ResponseImpl) {
            //     adapter = new (class Tmp implements ResponseAdapter<T> {
            //         public adapt(command: Command) {
            //             return right;
            //         }
            //     })();
            // } else if (right instanceof Uint8Array) {
            //     adapter = new (class Tmp implements ResponseAdapter<T> {
            //         public adapt(command: Command) {
            //             return new ResponseImpl<T>(right);
            //         }
            //     })();
            // } else if (typeof right === 'function') {
            //     adapter = {
            //         adapt: right
            //     };
            // } else {
            //     adapter = right as ResponseAdapter<T>;
            // }
            this._routes.push({
                predicate: predicate,
                adapter: adapter
            });
            return this;
        };
        //     /**
        //      * Mapping a command (represented as a string with format "<request-type> <path> [data]"
        //      * ie: GET /3//3 0xABCD or POST /1024//0 0xtest
        //      *
        //      * TapResponse must either be:
        //      *  - an hexadecimal data represented as a string (0xABCD)
        //      *  - An object with a coreRet and a body
        //      *  - A Uint8Array
        //      */
        // addRoutes(map: { [key: string]: RouteType }): this {
        //     for (const pathString in map) {
        //         const info = map[pathString];
        //         const command: Command = Util.parseApiRequestString(pathString);
        //         let response;
        //         if (info instanceof Uint8Array) {
        //             response = new ResponseImpl(info);
        //         } else if (info instanceof ResponseImpl) {
        //             response = info;
        //         } else if (typeof info === 'number') {
        //             response = ResponseImpl.create(info);
        //         } else if (typeof info === 'string') {
        //             response = new ResponseImpl(
        //                 hexStringToBuffer(info)
        //             );
        //         } else if (typeof info === 'object') {
        //             const codeRet: number = (info as RouteTypeObject).codeRet;
        //             response = new ResponseImpl(
        //                 KaitaiStreamWriter.mergeArrays(
        //                     Uint8Array.from([codeRet]),
        //                     (info as RouteTypeObject).body || new Uint8Array(0)
        //                 )
        //             );
        //         } else {
        //             throw new Error(
        //                 `Invalid response type ${typeof info} with value: ${JSON.stringify(
        //                     info
        //                 )}`
        //             );
        //         }
        //         debug(TAG, `\t- Add map ${command} -> ${response}`);
        //         this.addRoute(command, response);
        //     }
        //     return this;
        // }
        MockRouter.prototype.clearRoutes = function () {
            this._routes = [];
            return this;
        };
        return MockRouter;
    }());
    // /**
    //  * @deprecated in favor of {@link #addRoute}
    //  */
    // public mapResponse<T>(
    //     left:
    //         | FilterFunction<TapRequestFrame>
    //         | Predicate<TapRequestFrame>
    //         | TapRequestFrame,
    //     right:
    //         | ResponseAdapterFunction<T>
    //         | ResponseAdapter<T>
    //         | TapResponse<T>
    //         | Uint8Array
    // ): this {
    //     return this.addRoute(left, right);
    // }
    // public addRoute<T>(
    //     left:
    //         | FilterFunction<TapRequestFrame>
    //         | Predicate<TapRequestFrame>
    //         | TapRequestFrame,
    //     right:
    //         | ResponseAdapterFunction<T>
    //         | ResponseAdapter<T>
    //         | TapResponse<T>
    //         | Uint8Array
    // ): this {
    //     this.router.addRoute(left, right);
    //     return this;
    // }
    // //     public Configuration getConfiguration() {
    // //     return configuration;
    // // }

    var __extends = (this && this.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
        return new (P || (P = Promise))(function (resolve, reject) {
            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
            step((generator = generator.apply(thisArg, _arguments || [])).next());
        });
    };
    var __generator = (this && this.__generator) || function (thisArg, body) {
        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
        function verb(n) { return function (v) { return step([n, v]); }; }
        function step(op) {
            if (f) throw new TypeError("Generator is already executing.");
            while (_) try {
                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
                if (y = 0, t) op = [op[0] & 2, t.value];
                switch (op[0]) {
                    case 0: case 1: t = op; break;
                    case 4: _.label++; return { value: op[1], done: false };
                    case 5: _.label++; y = op[1]; op = [0]; continue;
                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
                    default:
                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                        if (t[2]) _.ops.pop();
                        _.trys.pop(); continue;
                }
                op = body.call(thisArg, _);
            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
        }
    };
    var TAG = 'MockProtocol';
    function createMockProtocol() {
        return new MockProtocol();
    }
    /**
     *
     * <p>
     * This is a mock com protocol for testing only
     * <p>
     * We can simulate iotize response according to the request message
     */
    var MockProtocol = /** @class */ (function (_super) {
        __extends(MockProtocol, _super);
        function MockProtocol() {
            var _this = _super.call(this) || this;
            _this.mockOptions = {
                connect: {
                    delay: 100
                },
                disconnect: {
                    delay: 100
                },
                write: {
                    delay: 1
                }
            };
            _this.input = new rxjs.Subject();
            _this.output = new rxjs.Subject();
            _this._router = new MockRouter();
            return _this;
            // this.connectDelay = 2000;
            // this.disconnectDelay = 2000;
            // this.callback = callback;
            // this.lastReceivedData = new Uint8Array(0);
            // this.configuration = new Configuration();
            // this.configuration.connectionTimeoutMillis = 3000;
            // this.configuration.sendTimeoutMillis = 3000;
        }
        MockProtocol.MIRROR = function () {
            var mockProtocol = new MockProtocol();
            mockProtocol.input
                .subscribe(function (input) {
                mockProtocol.setOutputData(input);
            });
            // mockProtocol.router.addRoute(
            //     (command: Uint8Array) => {
            //         return true;
            //     },
            //     (request: Uint8Array) => {
            //         return request;
            //     }
            // );
            return mockProtocol;
        };
        // /**
        //  * Create a new instance from roote mapping
        //  */
        // public static createFromRoutes(map: RouteMapping): MockProtocol {
        //     const mockProtocol = new MockProtocol();
        //     mockProtocol.router.addRoutes(map);
        //     return mockProtocol;
        // }
        // public get router(): MockRouter {
        //     return this._router;
        // }
        MockProtocol.prototype.setConnectionState = function (connectionState) {
            debug(TAG, "setConnectionState: " + connectionState);
            this.connectionState = connectionState;
            return this;
        };
        MockProtocol.prototype.setConnectDelay = function (connectDelay) {
            this.mockOptions.connect.delay = connectDelay;
            return this;
        };
        MockProtocol.prototype.getDisconnectDelay = function () {
            return this.mockOptions.disconnect.delay;
        };
        MockProtocol.prototype.setDisconnectDelay = function (disconnectDelay) {
            this.mockOptions.disconnect.delay = disconnectDelay;
            return this;
        };
        MockProtocol.prototype.setOutputData = function (inputData) {
            this.lastTranseiveData = inputData;
            this.output.next(inputData);
        };
        MockProtocol.prototype.setInputData = function (outputData) {
            this.lastReceivedData = outputData;
            this.input.next(outputData);
        };
        MockProtocol.prototype.setCallback = function (callback) {
            this.callback = callback;
        };
        MockProtocol.prototype._connect = function (options) {
            return rxjs.of(undefined).pipe(operators.delay(this.mockOptions.connect.delay));
        };
        MockProtocol.prototype._disconnect = function (options) {
            return rxjs.of(undefined).pipe(operators.delay(this.mockOptions.disconnect.delay));
        };
        MockProtocol.prototype.write = function (request) {
            return __awaiter(this, void 0, void 0, function () {
                var err_1;
                var _this = this;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            _a.trys.push([0, 5, , 6]);
                            if (!this.callback) return [3 /*break*/, 2];
                            return [4 /*yield*/, this.callback.beforeWrite(request)];
                        case 1:
                            _a.sent();
                            _a.label = 2;
                        case 2:
                            // this.lastReceivedData = request;
                            // const response = this.router.findRoute(request);
                            // if (!response) {
                            //     throw new Error(`Not route for request ${bufferToHexString(request)}`)
                            // }
                            // debug(
                            //     TAG,
                            //     'MockProtocol',
                            //     'Mocking response for ' + request + ' => ' + response
                            // );
                            // var result = this.responseEncoder.encode(response);
                            this.setInputData(request);
                            if (!this.callback) return [3 /*break*/, 4];
                            return [4 /*yield*/, this.callback.afterWrite(request)];
                        case 3:
                            _a.sent();
                            _a.label = 4;
                        case 4: return [2 /*return*/, new Promise(function (resolve) {
                                return setTimeout(resolve, _this.mockOptions.write.delay);
                            })];
                        case 5:
                            err_1 = _a.sent();
                            return [2 /*return*/, new Promise(function (resolve, reject) {
                                    return setTimeout(function () { return reject(err_1); }, _this.mockOptions.write.delay);
                                })];
                        case 6: return [2 /*return*/];
                    }
                });
            });
        };
        MockProtocol.prototype.read = function () {
            try {
                if (this.callback) {
                    this.callback.beforeRead();
                }
                return this.output.pipe(operators.first()).toPromise();
                // while (!this.hasNewData()) {
                //     // TODO wait ??
                // }
                // if (this.lastTranseiveData) {
                //     const result = of(this.lastTranseiveData);
                //     if (this.callback) {
                //         this.callback.afterRead(result);
                //     }
                //     return result.toPromise();
                // } else {
                //     return Promise.reject(new Error('Read timeout'));
                // }
            }
            catch (err) {
                return Promise.reject(err);
            }
        };
        return MockProtocol;
    }(core.QueueComProtocol));
    //    public addOnRequestListener() {
    //        this.mOnRequestListener =
    //    }
    //    public interface onRequestListener{
    //        onRequest(RequestMessage request);
    //    }

    var TAP_REQUEST_STRING_REGEX = /^(GET|PUT|POST)\s+(\/[0-9]+\/[0-9]*\/[0-9]+)\s?(\s+(0x[a-zA-Z0-9]+))?$/i;
    function createTapRequestFromString(request) {
        var match = TAP_REQUEST_STRING_REGEX.exec(request);
        if (match) {
            var methodType = match[1];
            var path = match[2];
            var body = match[4] ? byteConverter.hexStringToBuffer(match[4]) : undefined;
            return impl.TapRequestFrameBuilder.create(api.TapRequestFrame.MethodType[methodType], path, body);
        }
        else {
            throw new Error("Invalid tap request string format: \"" + request + "\".");
        }
    }
    var tapRequestEqualFilter = function (expectedRequest) {
        return function (request) {
            return impl.TapRequestHelper.toString(expectedRequest) === impl.TapRequestHelper.toString(request);
        };
    };
    var ɵ0 = tapRequestEqualFilter;

    var __extends$1 = (this && this.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __assign = (this && this.__assign) || function () {
        __assign = Object.assign || function(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                    t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };
    var TAG$1 = 'MockClient';
    function createMockClient(options) {
        return new MockClient({
            isConnected: !!(options === null || options === void 0 ? void 0 : options.connected)
        });
    }
    var MockClient = /** @class */ (function (_super) {
        __extends$1(MockClient, _super);
        function MockClient(options, router) {
            if (options === void 0) { options = {}; }
            if (router === void 0) { router = new MockRouter(); }
            var _this = _super.call(this, new impl.TapApduRequestConverter(), new impl.TapApduResponseConverter()) || this;
            _this.router = router;
            _this.input = new rxjs.Subject();
            _this.output = new rxjs.Subject();
            _this.options = __assign(__assign({}, MockClient.DEFAULT_OPTIONS), options);
            return _this;
        }
        MockClient.prototype.isConnected = function () {
            return this.options.isConnected;
        };
        // /**
        //  *
        //  * TOPO add support for parameters ?
        //  * TODO use Shell Grammar instead ?
        //  *
        //  * @param map
        //  */
        // public static createFromMap(map: MappingType): MockClient {
        //     const client = new MockClient();
        //     client.addRoutes(map);
        //     return client;
        // }
        MockClient.createWithMockProtocol = function () {
            var client = new MockClient({
                isConnected: false
            });
            client.addComProtocol(createMockProtocol());
            return client;
        };
        MockClient.prototype.connect = function () {
            var _this = this;
            var observable = rxjs.of(undefined).pipe(operators.delay(this.options.connect.delay));
            observable.subscribe(function () {
                _this.options.isConnected = true;
            });
            return observable;
        };
        MockClient.prototype.disconnect = function () {
            var _this = this;
            var observable = rxjs.of(undefined).pipe(operators.delay(this.options.disconnect.delay));
            observable.subscribe(function () {
                _this.options.isConnected = false;
            });
            return observable;
        };
        MockClient.prototype.mockResponse = function (tapResponse) {
            this.output.next(tapResponse);
        };
        MockClient.prototype.request = function (request) {
            if (!this.isConnected()) {
                return rxjs.throwError(impl.TapClientError.notConnectedError());
            }
            var responseP = this.output
                .pipe(
            // tap(event => console.log('EVENT', event)),
            operators.first(), operators.delay(this.options.command.delay), operators.timeout(this.options.command.timeout))
                .toPromise();
            this.input.next(request);
            return rxjs.from(responseP);
        };
        // /**
        //  * @deprecated in favor of addRoute
        //  * @param cmd
        //  * @param response
        //  */
        // public mapCommandToResponse(cmd: Command, response: TapResponse<any>) {
        //     return this.addRoute(cmd, response);
        // }
        // public addRoute<T>(
        //     command: Command | string | RegExp | TapRequestFilter,
        //     response: ResponseMapType
        // ): this {
        //     debug(
        //         TAG,
        //         `\t- Mapping command ${command.toString()} to response ${response.toString()}`
        //     );
        //     if (command instanceof RegExp) {
        //         throw new Error(
        //             `Route with regular expressions are not implemented yet`
        //         );
        //     } else if (typeof command === 'string') {
        //         command = Util.parseApiRequestString(command);
        //     }
        //     this.router.addRoute(
        //         command,
        //         this.createResponse(command, response)
        //     );
        //     return this;
        // }
        // public addRoutes(map: MappingType): this {
        //     for (const pathString in map) {
        //         const info = map[pathString];
        //         const command: Command = Util.parseApiRequestString(pathString);
        //         const response = this.createResponse(command, info);
        //         this.addRoute(command, response);
        //     }
        //     return this;
        // }
        // public hasRoute(command: Command | string): boolean {
        //     if (typeof command === 'string') {
        //         command = Util.parseApiRequestString(command);
        //     }
        //     return this.router.findRoute(command) != undefined;
        // }
        // createResponse<T>(
        //     command: Command | TapRequestFilter,
        //     info: ResponseMapType
        // ): TapResponse<T> | ResponseAdapterFunction<any> {
        //     let response: TapResponse<T>;
        //     if (typeof info === 'number') {
        //         response = TapResponse.create(info);
        //     } else if (typeof info === 'string') {
        //         response = new TapResponse(hexStringToBuffer(info));
        //     } else if (typeof info === 'object') {
        //         if (info instanceof TapResponse) {
        //             response = info;
        //         } else {
        //             response = TapResponse.create(typeof info.codeRet === 'number' ? info.codeRet : info.status);
        //             (response as TapResponse<T>).setBody(info.body);
        //         }
        //     } else if (typeof info === 'function') {
        //         if (command instanceof ApiRequest) {
        //             response = info(command);
        //         } else {
        //             return (command: TapRequestFrame) => {
        //                 const response = info(command);
        //                 if (response instanceof ResponseImpl) {
        //                     response.setRequest(command);
        //                 }
        //                 return response;
        //             };
        //         }
        //     } else {
        //         throw new Error(
        //             `Invalid payload type from key ${command.toString()}`
        //         );
        //     }
        //     if (command instanceof ApiRequest && response instanceof ResponseImpl) {
        //         response.setRequest(command);
        //     }
        //     return response;
        // }
        MockClient.prototype.computeResponse = function (cmd) {
            var response = this.router.findRoute(cmd);
            if (response) {
                return response;
            }
            else {
                debug(TAG$1, "MockClient", "command " + cmd + " has not been mapped. Returning 404 not found");
                return impl.TapResponseFrameBuilder.ERROR(api.ResultCode.NOT_FOUND);
            }
        };
        MockClient.DEFAULT_OPTIONS = {
            isConnected: false,
            connect: {
                delay: 100
            },
            disconnect: {
                delay: 100
            },
            command: {
                delay: 100,
                timeout: 500
            },
            encryption: true
        };
        return MockClient;
    }(impl.TapClient));

    var __extends$2 = (this && this.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var __read = (this && this.__read) || function (o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m) return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
        }
        catch (error) { e = { error: error }; }
        finally {
            try {
                if (r && !r.done && (m = i["return"])) m.call(i);
            }
            finally { if (e) throw e.error; }
        }
        return ar;
    };
    var __spread = (this && this.__spread) || function () {
        for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
        return ar;
    };
    function createMockServiceFunctionCustom(responseBuilder, options) {
        if (options === void 0) { options = {
            responseDelay: 10
        }; }
        return function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            return rxjs.of(responseBuilder.apply(void 0, __spread(args)))
                .pipe(operators.delay(options.responseDelay))
                .toPromise();
        };
    }
    function createMockServiceFunction(responseStatus, options) {
        if (responseStatus === void 0) { responseStatus = api.ResultCode.OK; }
        if (options === void 0) { options = {
            responseDelay: 10
        }; }
        return function () {
            var response = createMockServiceResponse(responseStatus);
            return rxjs.of(response)
                .pipe(operators.delay(options.responseDelay))
                .toPromise();
        };
    }
    function createMockServiceFunctionWithBody(responseStatus, body, options) {
        if (responseStatus === void 0) { responseStatus = api.ResultCode.OK; }
        if (options === void 0) { options = {
            responseDelay: 10
        }; }
        return function () {
            var response = createMockServiceResponseWithBody(responseStatus, body);
            return rxjs.of(response)
                .pipe(operators.delay(options.responseDelay))
                .toPromise();
        };
    }
    function createMockServiceResponse(responseStatus) {
        if (responseStatus === void 0) { responseStatus = api.ResultCode.OK; }
        var response = new tap.TapResponse(impl.TapResponseFrameBuilder.create(responseStatus));
        return response;
    }
    function createMockServiceResponseWithBody(responseStatus, body) {
        if (responseStatus === void 0) { responseStatus = api.ResultCode.OK; }
        var response = new tap.TapResponse(impl.TapResponseFrameBuilder.create(responseStatus));
        if (body instanceof Uint8Array) {
            response['_tapResponse'].data = body;
        }
        if (body) {
            response.setBody(body);
        }
        return response;
    }
    function createMockServiceResponseError(code) {
        var response = new tap.TapResponse(impl.TapResponseFrameBuilder.ERROR(code));
        return response;
    }
    function createMockService(constructorFct) {
        var serviceCallRunnner = new MockServiceCallRunner();
        return new constructorFct(serviceCallRunnner);
    }
    var MockServiceCallRunner = /** @class */ (function (_super) {
        __extends$2(MockServiceCallRunner, _super);
        // TODO
        function MockServiceCallRunner() {
            return _super.call(this, new MockClient()) || this;
        }
        return MockServiceCallRunner;
    }(tap.ServiceCallRunner));

    var __extends$3 = (this && this.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    function createMockTap(options) {
        return new MockTap(options);
    }
    /**
     * @experimental
     */
    var MockTap = /** @class */ (function (_super) {
        __extends$3(MockTap, _super);
        function MockTap(options) {
            return _super.call(this, createMockClient(options)) || this;
        }
        Object.defineProperty(MockTap.prototype, "client", {
            get: function () {
                return this._client;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(MockTap.prototype, "lwm2m", {
            get: function () {
                return this._lwm2m;
            },
            enumerable: true,
            configurable: true
        });
        return MockTap;
    }(tap.Tap));

    "use strict";
    Array.prototype.findSafe = function (predicate) {
        var val = this.find(predicate);
        if (val === undefined) {
            throw new Error("Cannot find element with predicate: " + predicate);
        }
        return val;
    };

    exports.MockClient = MockClient;
    exports.MockProtocol = MockProtocol;
    exports.MockServiceCallRunner = MockServiceCallRunner;
    exports.MockTap = MockTap;
    exports.createMockClient = createMockClient;
    exports.createMockProtocol = createMockProtocol;
    exports.createMockService = createMockService;
    exports.createMockServiceFunction = createMockServiceFunction;
    exports.createMockServiceFunctionCustom = createMockServiceFunctionCustom;
    exports.createMockServiceFunctionWithBody = createMockServiceFunctionWithBody;
    exports.createMockServiceResponse = createMockServiceResponse;
    exports.createMockServiceResponseError = createMockServiceResponseError;
    exports.createMockServiceResponseWithBody = createMockServiceResponseWithBody;
    exports.createMockTap = createMockTap;
    exports.createTapRequestFromString = createTapRequestFromString;
    exports.ɵ0 = ɵ0;
    exports.ɵa = MockRouter;

    Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=iotize-tap-testing.umd.js.map
