From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- .../thrift/lib/nodets/test/test_handler.ts | 300 +++++++++++++++++++++ 1 file changed, 300 insertions(+) create mode 100644 src/jaegertracing/thrift/lib/nodets/test/test_handler.ts (limited to 'src/jaegertracing/thrift/lib/nodets/test/test_handler.ts') diff --git a/src/jaegertracing/thrift/lib/nodets/test/test_handler.ts b/src/jaegertracing/thrift/lib/nodets/test/test_handler.ts new file mode 100644 index 000000000..996c32a5a --- /dev/null +++ b/src/jaegertracing/thrift/lib/nodets/test/test_handler.ts @@ -0,0 +1,300 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * 'License'); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +//This is the server side Node test handler for the standard +// Apache Thrift test service. + +import ttypes = require("./gen-nodejs/ThriftTest_types"); +import thrift = require("thrift"); +import Thrift = thrift.Thrift; +import Q = require("q"); +import Int64 = require("node-int64"); + + +export class SyncThriftTestHandler { + testVoid(): Q.IPromise { + //console.log('testVoid()'); + return Q.resolve(undefined); + } + testMapMap(hello: number) { + //console.log('testMapMap(' + hello + ')'); + + var mapmap: {[key: number]: {[key: number]: number; }} = []; + var pos: {[key: number]: number; } = []; + var neg: {[key: number]: number; } = []; + for (var i = 1; i < 5; i++) { + pos[i] = i; + neg[-i] = -i; + } + mapmap[4] = pos; + mapmap[-4] = neg; + + return Q.resolve(mapmap); + } + testInsanity(argument: ttypes.Insanity): Q.IPromise<{ [k: number]: any; }> { + const first_map: { [k: number]: any; } = []; + const second_map: { [k: number]: any; } = []; + + first_map[ttypes.Numberz.TWO] = argument; + first_map[ttypes.Numberz.THREE] = argument; + + const looney = new ttypes.Insanity(); + second_map[ttypes.Numberz.SIX] = looney; + + const insane: { [k: number]: any; } = []; + insane[1] = first_map; + insane[2] = second_map; + + return Q.resolve(insane); + } + testMulti(arg0: any, arg1: number, arg2: Int64, arg3: { [k: number]: string; }, arg4: ttypes.Numberz, arg5: number) { + var hello = new ttypes.Xtruct(); + hello.string_thing = 'Hello2'; + hello.byte_thing = arg0; + hello.i32_thing = arg1; + hello.i64_thing = arg2; + return Q.resolve(hello); + } + testException(arg: string): Q.IPromise { + if (arg === 'Xception') { + var x = new ttypes.Xception(); + x.errorCode = 1001; + x.message = arg; + throw x; + } else if (arg === 'TException') { + throw new Thrift.TException(arg); + } else { + return Q.resolve(); + } + } + testMultiException(arg0: string, arg1: string) { + if (arg0 === ('Xception')) { + var x = new ttypes.Xception(); + x.errorCode = 1001; + x.message = 'This is an Xception'; + throw x; + } else if (arg0 === ('Xception2')) { + var x2 = new ttypes.Xception2(); + x2.errorCode = 2002; + x2.struct_thing = new ttypes.Xtruct(); + x2.struct_thing.string_thing = 'This is an Xception2'; + throw x2; + } + + var res = new ttypes.Xtruct(); + res.string_thing = arg1; + return Q.resolve(res); + } + testOneway(sleepFor: number) { + } + + testString(thing: string) { + return Q.resolve(thing); + } + testBool(thing: boolean) { + return Q.resolve(thing); + } + testByte(thing: number) { + return Q.resolve(thing); + } + testI32(thing: number) { + return Q.resolve(thing); + } + testI64(thing: number) { + return Q.resolve(thing); + } + testDouble(thing: number) { + return Q.resolve(thing); + } + testBinary(thing: Buffer) { + return Q.resolve(thing); + } + testStruct(thing: ttypes.Xtruct) { + return Q.resolve(thing); + } + testNest(thing: ttypes.Xtruct2) { + return Q.resolve(thing); + } + testMap(thing: { [k: number]: number; }) { + return Q.resolve(thing); + } + testStringMap(thing: { [k: string]: string; }) { + return Q.resolve(thing); + } + testSet(thing: number[]) { + return Q.resolve(thing); + } + testList(thing: number[]) { + return Q.resolve(thing); + } + testEnum(thing: ttypes.Numberz) { + return Q.resolve(thing); + } + testTypedef(thing: number) { + return Q.resolve(thing); + } +} + +export class AsyncThriftTestHandler { + private syncHandler: SyncThriftTestHandler; + constructor() { + this.syncHandler = new SyncThriftTestHandler(); + } + + testVoid(callback: (result: void) => void): Q.IPromise { + callback(undefined); + return Q.resolve(); + } + testMapMap(hello: number, + callback: (err: any, result: { [k: number]: { [k: number]: number; }; }) => void): + Q.IPromise<{ [k: number]: { [k: number]: number; }; }> { + + var mapmap: {[key: number]: {[key: number]: number; }} = []; + var pos: {[key: number]: number; } = []; + var neg: {[key: number]: number; } = []; + for (var i = 1; i < 5; i++) { + pos[i] = i; + neg[-i] = -i; + } + mapmap[4] = pos; + mapmap[-4] = neg; + + callback(null, mapmap); + return Q.resolve(); + } + testInsanity(argument: ttypes.Insanity, callback?: (err: any, result: { [k: number]: any; }) => void): Q.IPromise<{ [k: number]: any; }> { + const first_map: { [k: number]: any; } = []; + const second_map: { [k: number]: any; } = []; + + first_map[ttypes.Numberz.TWO] = argument; + first_map[ttypes.Numberz.THREE] = argument; + + const looney = new ttypes.Insanity(); + second_map[ttypes.Numberz.SIX] = looney; + + const insane: { [k: number]: any; } = []; + insane[1] = first_map; + insane[2] = second_map; + + if (callback !== undefined){ + callback(null, insane); + } + return Q.resolve(); + } + testMulti(arg0: any, arg1: number, arg2: Int64, arg3: { [k: number]: string; }, arg4: ttypes.Numberz, arg5: number, result: Function): Q.IPromise { + var hello = this.syncHandler.testMulti(arg0, arg1, arg2, arg3, arg4, arg5); + hello.then(hello => result(null, hello)); + return Q.resolve(); + } + testException(arg: string, result: (err: any) => void): Q.IPromise { + if (arg === 'Xception') { + var x = new ttypes.Xception(); + x.errorCode = 1001; + x.message = arg; + result(x); + } else if (arg === 'TException') { + result(new Thrift.TException(arg)); + } else { + result(null); + } + return Q.resolve(); + } + testMultiException(arg0: string, arg1: string, result: (err: any, res?: ttypes.Xtruct) => void): Q.IPromise { + if (arg0 === ('Xception')) { + var x = new ttypes.Xception(); + x.errorCode = 1001; + x.message = 'This is an Xception'; + result(x); + } else if (arg0 === ('Xception2')) { + var x2 = new ttypes.Xception2(); + x2.errorCode = 2002; + x2.struct_thing = new ttypes.Xtruct(); + x2.struct_thing.string_thing = 'This is an Xception2'; + result(x2); + } else { + var res = new ttypes.Xtruct(); + res.string_thing = arg1; + result(null, res); + } + return Q.resolve(); + } + testOneway(sleepFor: number, result: Function) { + this.syncHandler.testOneway(sleepFor); + } + testString(thing: string, callback: (err: any, result: string) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testByte(thing: number, callback: (err: any, result: number) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testBool(thing: boolean, callback: (err: any, result: boolean) => void ): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testI32(thing: number, callback: (err: any, result: number) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testI64(thing: number, callback: (err: any, result: number) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testDouble(thing: number, callback: (err: any, result: number) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testBinary(thing: Buffer, callback: (err: any, result: Buffer) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testStruct(thing: ttypes.Xtruct, callback: (err: any, result: ttypes.Xtruct) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testNest(thing: ttypes.Xtruct2, callback: (err: any, result: ttypes.Xtruct2) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testMap(thing: { [k: number]: number; }, callback: (err: any, result: { [k: number]: number; }) => void): Q.IPromise<{ [k: number]: number; }> { + callback(null, thing); + return Q.resolve(); + } + testStringMap(thing: { [k: string]: string; }, callback: (err: any, result: { [k: string]: string; }) => void): Q.IPromise<{ [k: string]: string; }> { + callback(null, thing); + return Q.resolve(); + } + testSet(thing: number[], callback: (err: any, result: number[]) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testList(thing: number[], callback: (err: any, result: number[]) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testEnum(thing: ttypes.Numberz, callback: (err: any, result: ttypes.Numberz) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } + testTypedef(thing: number, callback: (err: any, result: number) => void): Q.IPromise { + callback(null, thing); + return Q.resolve(); + } +} -- cgit v1.2.3