diff --git a/.chronus/changes/http-specs-additional-special-words-2023-5-22.md b/.chronus/changes/http-specs-additional-special-words-2023-5-22.md new file mode 100644 index 00000000000..eb29ea0e54c --- /dev/null +++ b/.chronus/changes/http-specs-additional-special-words-2023-5-22.md @@ -0,0 +1,7 @@ +--- +kind: feature +packages: + - "@typespec/http-specs" +--- + +Add test cases for additional special words in http-specs \ No newline at end of file diff --git a/packages/http-specs/specs/special-words/main.tsp b/packages/http-specs/specs/special-words/main.tsp index 7517d04be5a..4dd8c12eba2 100644 --- a/packages/http-specs/specs/special-words/main.tsp +++ b/packages/http-specs/specs/special-words/main.tsp @@ -11,35 +11,85 @@ using Spector; * Current list of special words * ```txt * and + * any + * apiVersion + * arguments * as * assert * async * await + * boolean * break + * case + * catch * class + * client + * const * constructor * continue + * date + * debugger + * declare * def + * default * del + * delete + * do * elif * else + * endpoint + * enum + * error * except * exec + * export + * extends + * false * finally * for * from + * function + * get * global * if + * implements * import * in + * instanceof + * interface * is * lambda + * let + * module + * new * not + * null + * number + * of * or + * package * pass + * private + * protected + * public * raise + * requestoptions + * require * return + * set + * static + * string + * super + * switch + * symbol + * this + * throw + * true * try + * type + * typeof + * var + * void * while * with * yield @@ -77,15 +127,65 @@ interface Operations { @opNameScenario("in") in(): void; @opNameScenario("is") `is`(): void; @opNameScenario("lambda") lambda(): void; + @opNameScenario("let") `let`(): void; + @opNameScenario("module") `module`(): void; + @opNameScenario("new") `new`(): void; @opNameScenario("not") not(): void; + @opNameScenario("null") `null`(): void; + @opNameScenario("number") number(): void; + @opNameScenario("of") of(): void; @opNameScenario("or") or(): void; + @opNameScenario("package") `package`(): void; @opNameScenario("pass") pass(): void; + @opNameScenario("private") `private`(): void; + @opNameScenario("protected") `protected`(): void; + @opNameScenario("public") `public`(): void; @opNameScenario("raise") raise(): void; + @opNameScenario("requestoptions") requestoptions(): void; + @opNameScenario("require") require(): void; @opNameScenario("return") `return`(): void; + @opNameScenario("set") set(): void; + @opNameScenario("static") `static`(): void; + @opNameScenario("string") string(): void; + @opNameScenario("super") `super`(): void; + @opNameScenario("switch") `switch`(): void; + @opNameScenario("symbol") symbol(): void; + @opNameScenario("this") `this`(): void; + @opNameScenario("throw") `throw`(): void; + @opNameScenario("true") `true`(): void; @opNameScenario("try") try(): void; + @opNameScenario("type") `type`(): void; + @opNameScenario("typeof") `typeof`(): void; + @opNameScenario("var") `var`(): void; + @opNameScenario("void") `void`(): void; @opNameScenario("while") while(): void; @opNameScenario("with") `with`(): void; @opNameScenario("yield") yield(): void; + @opNameScenario("any") `any`(): void; + @opNameScenario("apiVersion") apiVersion(): void; + @opNameScenario("arguments") `arguments`(): void; + @opNameScenario("boolean") boolean(): void; + @opNameScenario("case") `case`(): void; + @opNameScenario("catch") `catch`(): void; + @opNameScenario("client") client(): void; + @opNameScenario("const") `const`(): void; + @opNameScenario("date") date(): void; + @opNameScenario("debugger") `debugger`(): void; + @opNameScenario("declare") `declare`(): void; + @opNameScenario("default") `default`(): void; + @opNameScenario("delete") `delete`(): void; + @opNameScenario("do") `do`(): void; + @opNameScenario("endpoint") endpoint(): void; + @opNameScenario("enum") `enum`(): void; + @opNameScenario("error") error(): void; + @opNameScenario("export") `export`(): void; + @opNameScenario("extends") `extends`(): void; + @opNameScenario("false") `false`(): void; + @opNameScenario("function") `function`(): void; + @opNameScenario("get") get(): void; + @opNameScenario("implements") `implements`(): void; + @opNameScenario("instanceof") `instanceof`(): void; + @opNameScenario("interface") `interface`(): void; } /** @@ -126,6 +226,56 @@ interface Parameters { @paramNameScenario("while") withWhile(@query while: string): void; @paramNameScenario("with") withWith(@query with: string): void; @paramNameScenario("yield") withYield(@query yield: string): void; + @paramNameScenario("any") withAny(@query `any`: string): void; + @paramNameScenario("apiVersion") withApiVersion(@query apiVersion: string): void; + @paramNameScenario("arguments") withArguments(@query `arguments`: string): void; + @paramNameScenario("boolean") withBoolean(@query boolean: string): void; + @paramNameScenario("case") withCase(@query `case`: string): void; + @paramNameScenario("catch") withCatch(@query `catch`: string): void; + @paramNameScenario("client") withClient(@query client: string): void; + @paramNameScenario("const") withConst(@query `const`: string): void; + @paramNameScenario("date") withDate(@query date: string): void; + @paramNameScenario("debugger") withDebugger(@query `debugger`: string): void; + @paramNameScenario("declare") withDeclare(@query `declare`: string): void; + @paramNameScenario("default") withDefault(@query `default`: string): void; + @paramNameScenario("delete") withDelete(@query `delete`: string): void; + @paramNameScenario("do") withDo(@query `do`: string): void; + @paramNameScenario("endpoint") withEndpoint(@query endpoint: string): void; + @paramNameScenario("enum") withEnum(@query `enum`: string): void; + @paramNameScenario("error") withError(@query error: string): void; + @paramNameScenario("export") withExport(@query `export`: string): void; + @paramNameScenario("extends") withExtends(@query `extends`: string): void; + @paramNameScenario("false") withFalse(@query `false`: string): void; + @paramNameScenario("function") withFunction(@query `function`: string): void; + @paramNameScenario("get") withGet(@query get: string): void; + @paramNameScenario("implements") withImplements(@query `implements`: string): void; + @paramNameScenario("instanceof") withInstanceof(@query `instanceof`: string): void; + @paramNameScenario("interface") withInterface(@query `interface`: string): void; + @paramNameScenario("let") withLet(@query `let`: string): void; + @paramNameScenario("module") withModule(@query `module`: string): void; + @paramNameScenario("new") withNew(@query `new`: string): void; + @paramNameScenario("null") withNull(@query `null`: string): void; + @paramNameScenario("number") withNumber(@query number: string): void; + @paramNameScenario("of") withOf(@query of: string): void; + @paramNameScenario("package") withPackage(@query `package`: string): void; + @paramNameScenario("private") withPrivate(@query `private`: string): void; + @paramNameScenario("protected") withProtected(@query `protected`: string): void; + @paramNameScenario("public") withPublic(@query `public`: string): void; + @paramNameScenario("requestoptions") withRequestOptions(@query requestoptions: string): void; + @paramNameScenario("require") withRequire(@query require: string): void; + @paramNameScenario("set") withSet(@query set: string): void; + @paramNameScenario("static") withStatic(@query `static`: string): void; + @paramNameScenario("string") withString(@query string: string): void; + @paramNameScenario("super") withSuper(@query `super`: string): void; + @paramNameScenario("switch") withSwitch(@query `switch`: string): void; + @paramNameScenario("symbol") withSymbol(@query symbol: string): void; + @paramNameScenario("this") withThis(@query `this`: string): void; + @paramNameScenario("throw") withThrow(@query `throw`: string): void; + @paramNameScenario("true") withTrue(@query `true`: string): void; + @paramNameScenario("type") withType(@query `type`: string): void; + @paramNameScenario("typeof") withTypeof(@query `typeof`: string): void; + @paramNameScenario("var") withVar(@query `var`: string): void; + @paramNameScenario("void") withVoid(@query `void`: string): void; // Non keywords but parameters name that could cause conflict with some language standards @paramNameScenario("cancellationToken") withCancellationToken( @@ -174,6 +324,56 @@ namespace Models { model while is Base; model `with` is Base; model yield is Base; + model `any` is Base; + model apiVersion is Base; + model `arguments` is Base; + model boolean is Base; + model `case` is Base; + model `catch` is Base; + model client is Base; + model `const` is Base; + model date is Base; + model `debugger` is Base; + model `declare` is Base; + model `default` is Base; + model `delete` is Base; + model `do` is Base; + model endpoint is Base; + model `enum` is Base; + model error is Base; + model `export` is Base; + model `extends` is Base; + model `false` is Base; + model `function` is Base; + model get is Base; + model `implements` is Base; + model `instanceof` is Base; + model `interface` is Base; + model `let` is Base; + model `module` is Base; + model `new` is Base; + model `null` is Base; + model number is Base; + model of is Base; + model `package` is Base; + model `private` is Base; + model `protected` is Base; + model `public` is Base; + model requestoptions is Base; + model require is Base; + model set is Base; + model `static` is Base; + model string is Base; + model `super` is Base; + model `switch` is Base; + model symbol is Base; + model `this` is Base; + model `throw` is Base; + model `true` is Base; + model `type` is Base; + model `typeof` is Base; + model `var` is Base; + model `void` is Base; @modelNameScenario("and") op withAnd(@body body: and): void; @modelNameScenario("as") op withAs(@body body: as): void; @@ -208,6 +408,56 @@ namespace Models { @modelNameScenario("while") op withWhile(@body body: while): void; @modelNameScenario("with") op withWith(@body body: `with`): void; @modelNameScenario("yield") op withYield(@body body: yield): void; + @modelNameScenario("any") op withAny(@body body: `any`): void; + @modelNameScenario("apiVersion") op withApiVersion(@body body: apiVersion): void; + @modelNameScenario("arguments") op withArguments(@body body: `arguments`): void; + @modelNameScenario("boolean") op withBoolean(@body body: boolean): void; + @modelNameScenario("case") op withCase(@body body: `case`): void; + @modelNameScenario("catch") op withCatch(@body body: `catch`): void; + @modelNameScenario("client") op withClient(@body body: client): void; + @modelNameScenario("const") op withConst(@body body: `const`): void; + @modelNameScenario("date") op withDate(@body body: date): void; + @modelNameScenario("debugger") op withDebugger(@body body: `debugger`): void; + @modelNameScenario("declare") op withDeclare(@body body: `declare`): void; + @modelNameScenario("default") op withDefault(@body body: `default`): void; + @modelNameScenario("delete") op withDelete(@body body: `delete`): void; + @modelNameScenario("do") op withDo(@body body: `do`): void; + @modelNameScenario("endpoint") op withEndpoint(@body body: endpoint): void; + @modelNameScenario("enum") op withEnum(@body body: `enum`): void; + @modelNameScenario("error") op withError(@body body: error): void; + @modelNameScenario("export") op withExport(@body body: `export`): void; + @modelNameScenario("extends") op withExtends(@body body: `extends`): void; + @modelNameScenario("false") op withFalse(@body body: `false`): void; + @modelNameScenario("function") op withFunction(@body body: `function`): void; + @modelNameScenario("get") op withGet(@body body: get): void; + @modelNameScenario("implements") op withImplements(@body body: `implements`): void; + @modelNameScenario("instanceof") op withInstanceof(@body body: `instanceof`): void; + @modelNameScenario("interface") op withInterface(@body body: `interface`): void; + @modelNameScenario("let") op withLet(@body body: `let`): void; + @modelNameScenario("module") op withModule(@body body: `module`): void; + @modelNameScenario("new") op withNew(@body body: `new`): void; + @modelNameScenario("null") op withNull(@body body: `null`): void; + @modelNameScenario("number") op withNumber(@body body: number): void; + @modelNameScenario("of") op withOf(@body body: of): void; + @modelNameScenario("package") op withPackage(@body body: `package`): void; + @modelNameScenario("private") op withPrivate(@body body: `private`): void; + @modelNameScenario("protected") op withProtected(@body body: `protected`): void; + @modelNameScenario("public") op withPublic(@body body: `public`): void; + @modelNameScenario("requestoptions") op withRequestOptions(@body body: requestoptions): void; + @modelNameScenario("require") op withRequire(@body body: require): void; + @modelNameScenario("set") op withSet(@body body: set): void; + @modelNameScenario("static") op withStatic(@body body: `static`): void; + @modelNameScenario("string") op withString(@body body: string): void; + @modelNameScenario("super") op withSuper(@body body: `super`): void; + @modelNameScenario("switch") op withSwitch(@body body: `switch`): void; + @modelNameScenario("symbol") op withSymbol(@body body: symbol): void; + @modelNameScenario("this") op withThis(@body body: `this`): void; + @modelNameScenario("throw") op withThrow(@body body: `throw`): void; + @modelNameScenario("true") op withTrue(@body body: `true`): void; + @modelNameScenario("type") op withType(@body body: `type`): void; + @modelNameScenario("typeof") op withTypeof(@body body: `typeof`): void; + @modelNameScenario("var") op withVar(@body body: `var`): void; + @modelNameScenario("void") op withVoid(@body body: `void`): void; } /** diff --git a/packages/http-specs/specs/special-words/mockapi.ts b/packages/http-specs/specs/special-words/mockapi.ts index 6c85d72cb9c..c7a34275b39 100644 --- a/packages/http-specs/specs/special-words/mockapi.ts +++ b/packages/http-specs/specs/special-words/mockapi.ts @@ -64,6 +64,56 @@ Scenarios.SpecialWords_Models_try = createModelsTests(`/special-words/models/try Scenarios.SpecialWords_Models_while = createModelsTests(`/special-words/models/while`); Scenarios.SpecialWords_Models_with = createModelsTests(`/special-words/models/with`); Scenarios.SpecialWords_Models_yield = createModelsTests(`/special-words/models/yield`); +Scenarios.SpecialWords_Models_any = createModelsTests(`/special-words/models/any`); +Scenarios.SpecialWords_Models_apiVersion = createModelsTests(`/special-words/models/apiVersion`); +Scenarios.SpecialWords_Models_arguments = createModelsTests(`/special-words/models/arguments`); +Scenarios.SpecialWords_Models_boolean = createModelsTests(`/special-words/models/boolean`); +Scenarios.SpecialWords_Models_case = createModelsTests(`/special-words/models/case`); +Scenarios.SpecialWords_Models_catch = createModelsTests(`/special-words/models/catch`); +Scenarios.SpecialWords_Models_client = createModelsTests(`/special-words/models/client`); +Scenarios.SpecialWords_Models_const = createModelsTests(`/special-words/models/const`); +Scenarios.SpecialWords_Models_date = createModelsTests(`/special-words/models/date`); +Scenarios.SpecialWords_Models_debugger = createModelsTests(`/special-words/models/debugger`); +Scenarios.SpecialWords_Models_declare = createModelsTests(`/special-words/models/declare`); +Scenarios.SpecialWords_Models_default = createModelsTests(`/special-words/models/default`); +Scenarios.SpecialWords_Models_delete = createModelsTests(`/special-words/models/delete`); +Scenarios.SpecialWords_Models_do = createModelsTests(`/special-words/models/do`); +Scenarios.SpecialWords_Models_endpoint = createModelsTests(`/special-words/models/endpoint`); +Scenarios.SpecialWords_Models_enum = createModelsTests(`/special-words/models/enum`); +Scenarios.SpecialWords_Models_error = createModelsTests(`/special-words/models/error`); +Scenarios.SpecialWords_Models_export = createModelsTests(`/special-words/models/export`); +Scenarios.SpecialWords_Models_extends = createModelsTests(`/special-words/models/extends`); +Scenarios.SpecialWords_Models_false = createModelsTests(`/special-words/models/false`); +Scenarios.SpecialWords_Models_function = createModelsTests(`/special-words/models/function`); +Scenarios.SpecialWords_Models_get = createModelsTests(`/special-words/models/get`); +Scenarios.SpecialWords_Models_implements = createModelsTests(`/special-words/models/implements`); +Scenarios.SpecialWords_Models_instanceof = createModelsTests(`/special-words/models/instanceof`); +Scenarios.SpecialWords_Models_interface = createModelsTests(`/special-words/models/interface`); +Scenarios.SpecialWords_Models_let = createModelsTests(`/special-words/models/let`); +Scenarios.SpecialWords_Models_module = createModelsTests(`/special-words/models/module`); +Scenarios.SpecialWords_Models_new = createModelsTests(`/special-words/models/new`); +Scenarios.SpecialWords_Models_null = createModelsTests(`/special-words/models/null`); +Scenarios.SpecialWords_Models_number = createModelsTests(`/special-words/models/number`); +Scenarios.SpecialWords_Models_of = createModelsTests(`/special-words/models/of`); +Scenarios.SpecialWords_Models_package = createModelsTests(`/special-words/models/package`); +Scenarios.SpecialWords_Models_private = createModelsTests(`/special-words/models/private`); +Scenarios.SpecialWords_Models_protected = createModelsTests(`/special-words/models/protected`); +Scenarios.SpecialWords_Models_public = createModelsTests(`/special-words/models/public`); +Scenarios.SpecialWords_Models_requestoptions = createModelsTests(`/special-words/models/requestoptions`); +Scenarios.SpecialWords_Models_require = createModelsTests(`/special-words/models/require`); +Scenarios.SpecialWords_Models_set = createModelsTests(`/special-words/models/set`); +Scenarios.SpecialWords_Models_static = createModelsTests(`/special-words/models/static`); +Scenarios.SpecialWords_Models_string = createModelsTests(`/special-words/models/string`); +Scenarios.SpecialWords_Models_super = createModelsTests(`/special-words/models/super`); +Scenarios.SpecialWords_Models_switch = createModelsTests(`/special-words/models/switch`); +Scenarios.SpecialWords_Models_symbol = createModelsTests(`/special-words/models/symbol`); +Scenarios.SpecialWords_Models_this = createModelsTests(`/special-words/models/this`); +Scenarios.SpecialWords_Models_throw = createModelsTests(`/special-words/models/throw`); +Scenarios.SpecialWords_Models_true = createModelsTests(`/special-words/models/true`); +Scenarios.SpecialWords_Models_type = createModelsTests(`/special-words/models/type`); +Scenarios.SpecialWords_Models_typeof = createModelsTests(`/special-words/models/typeof`); +Scenarios.SpecialWords_Models_var = createModelsTests(`/special-words/models/var`); +Scenarios.SpecialWords_Models_void = createModelsTests(`/special-words/models/void`); function createOperationsTests(uri: string) { return passOnSuccess({ @@ -128,6 +178,56 @@ Scenarios.SpecialWords_Operations_try = createOperationsTests(`/special-words/op Scenarios.SpecialWords_Operations_while = createOperationsTests(`/special-words/operations/while`); Scenarios.SpecialWords_Operations_with = createOperationsTests(`/special-words/operations/with`); Scenarios.SpecialWords_Operations_yield = createOperationsTests(`/special-words/operations/yield`); +Scenarios.SpecialWords_Operations_any = createOperationsTests(`/special-words/operations/any`); +Scenarios.SpecialWords_Operations_apiVersion = createOperationsTests(`/special-words/operations/apiVersion`); +Scenarios.SpecialWords_Operations_arguments = createOperationsTests(`/special-words/operations/arguments`); +Scenarios.SpecialWords_Operations_boolean = createOperationsTests(`/special-words/operations/boolean`); +Scenarios.SpecialWords_Operations_case = createOperationsTests(`/special-words/operations/case`); +Scenarios.SpecialWords_Operations_catch = createOperationsTests(`/special-words/operations/catch`); +Scenarios.SpecialWords_Operations_client = createOperationsTests(`/special-words/operations/client`); +Scenarios.SpecialWords_Operations_const = createOperationsTests(`/special-words/operations/const`); +Scenarios.SpecialWords_Operations_date = createOperationsTests(`/special-words/operations/date`); +Scenarios.SpecialWords_Operations_debugger = createOperationsTests(`/special-words/operations/debugger`); +Scenarios.SpecialWords_Operations_declare = createOperationsTests(`/special-words/operations/declare`); +Scenarios.SpecialWords_Operations_default = createOperationsTests(`/special-words/operations/default`); +Scenarios.SpecialWords_Operations_delete = createOperationsTests(`/special-words/operations/delete`); +Scenarios.SpecialWords_Operations_do = createOperationsTests(`/special-words/operations/do`); +Scenarios.SpecialWords_Operations_endpoint = createOperationsTests(`/special-words/operations/endpoint`); +Scenarios.SpecialWords_Operations_enum = createOperationsTests(`/special-words/operations/enum`); +Scenarios.SpecialWords_Operations_error = createOperationsTests(`/special-words/operations/error`); +Scenarios.SpecialWords_Operations_export = createOperationsTests(`/special-words/operations/export`); +Scenarios.SpecialWords_Operations_extends = createOperationsTests(`/special-words/operations/extends`); +Scenarios.SpecialWords_Operations_false = createOperationsTests(`/special-words/operations/false`); +Scenarios.SpecialWords_Operations_function = createOperationsTests(`/special-words/operations/function`); +Scenarios.SpecialWords_Operations_get = createOperationsTests(`/special-words/operations/get`); +Scenarios.SpecialWords_Operations_implements = createOperationsTests(`/special-words/operations/implements`); +Scenarios.SpecialWords_Operations_instanceof = createOperationsTests(`/special-words/operations/instanceof`); +Scenarios.SpecialWords_Operations_interface = createOperationsTests(`/special-words/operations/interface`); +Scenarios.SpecialWords_Operations_let = createOperationsTests(`/special-words/operations/let`); +Scenarios.SpecialWords_Operations_module = createOperationsTests(`/special-words/operations/module`); +Scenarios.SpecialWords_Operations_new = createOperationsTests(`/special-words/operations/new`); +Scenarios.SpecialWords_Operations_null = createOperationsTests(`/special-words/operations/null`); +Scenarios.SpecialWords_Operations_number = createOperationsTests(`/special-words/operations/number`); +Scenarios.SpecialWords_Operations_of = createOperationsTests(`/special-words/operations/of`); +Scenarios.SpecialWords_Operations_package = createOperationsTests(`/special-words/operations/package`); +Scenarios.SpecialWords_Operations_private = createOperationsTests(`/special-words/operations/private`); +Scenarios.SpecialWords_Operations_protected = createOperationsTests(`/special-words/operations/protected`); +Scenarios.SpecialWords_Operations_public = createOperationsTests(`/special-words/operations/public`); +Scenarios.SpecialWords_Operations_requestoptions = createOperationsTests(`/special-words/operations/requestoptions`); +Scenarios.SpecialWords_Operations_require = createOperationsTests(`/special-words/operations/require`); +Scenarios.SpecialWords_Operations_set = createOperationsTests(`/special-words/operations/set`); +Scenarios.SpecialWords_Operations_static = createOperationsTests(`/special-words/operations/static`); +Scenarios.SpecialWords_Operations_string = createOperationsTests(`/special-words/operations/string`); +Scenarios.SpecialWords_Operations_super = createOperationsTests(`/special-words/operations/super`); +Scenarios.SpecialWords_Operations_switch = createOperationsTests(`/special-words/operations/switch`); +Scenarios.SpecialWords_Operations_symbol = createOperationsTests(`/special-words/operations/symbol`); +Scenarios.SpecialWords_Operations_this = createOperationsTests(`/special-words/operations/this`); +Scenarios.SpecialWords_Operations_throw = createOperationsTests(`/special-words/operations/throw`); +Scenarios.SpecialWords_Operations_true = createOperationsTests(`/special-words/operations/true`); +Scenarios.SpecialWords_Operations_type = createOperationsTests(`/special-words/operations/type`); +Scenarios.SpecialWords_Operations_typeof = createOperationsTests(`/special-words/operations/typeof`); +Scenarios.SpecialWords_Operations_var = createOperationsTests(`/special-words/operations/var`); +Scenarios.SpecialWords_Operations_void = createOperationsTests(`/special-words/operations/void`); function createParametersTests(uri: string, data: any, paramName: string) { return passOnSuccess({ @@ -375,6 +475,356 @@ Scenarios.SpecialWords_Parameters_yield = createParametersTests( }, "yield", ); +Scenarios.SpecialWords_Parameters_any = createParametersTests( + `/special-words/parameters/any`, + { + any: "ok", + }, + "any", +); +Scenarios.SpecialWords_Parameters_apiVersion = createParametersTests( + `/special-words/parameters/apiVersion`, + { + apiVersion: "ok", + }, + "apiVersion", +); +Scenarios.SpecialWords_Parameters_arguments = createParametersTests( + `/special-words/parameters/arguments`, + { + arguments: "ok", + }, + "arguments", +); +Scenarios.SpecialWords_Parameters_boolean = createParametersTests( + `/special-words/parameters/boolean`, + { + boolean: "ok", + }, + "boolean", +); +Scenarios.SpecialWords_Parameters_case = createParametersTests( + `/special-words/parameters/case`, + { + case: "ok", + }, + "case", +); +Scenarios.SpecialWords_Parameters_catch = createParametersTests( + `/special-words/parameters/catch`, + { + catch: "ok", + }, + "catch", +); +Scenarios.SpecialWords_Parameters_client = createParametersTests( + `/special-words/parameters/client`, + { + client: "ok", + }, + "client", +); +Scenarios.SpecialWords_Parameters_const = createParametersTests( + `/special-words/parameters/const`, + { + const: "ok", + }, + "const", +); +Scenarios.SpecialWords_Parameters_date = createParametersTests( + `/special-words/parameters/date`, + { + date: "ok", + }, + "date", +); +Scenarios.SpecialWords_Parameters_debugger = createParametersTests( + `/special-words/parameters/debugger`, + { + debugger: "ok", + }, + "debugger", +); +Scenarios.SpecialWords_Parameters_declare = createParametersTests( + `/special-words/parameters/declare`, + { + declare: "ok", + }, + "declare", +); +Scenarios.SpecialWords_Parameters_default = createParametersTests( + `/special-words/parameters/default`, + { + default: "ok", + }, + "default", +); +Scenarios.SpecialWords_Parameters_delete = createParametersTests( + `/special-words/parameters/delete`, + { + delete: "ok", + }, + "delete", +); +Scenarios.SpecialWords_Parameters_do = createParametersTests( + `/special-words/parameters/do`, + { + do: "ok", + }, + "do", +); +Scenarios.SpecialWords_Parameters_endpoint = createParametersTests( + `/special-words/parameters/endpoint`, + { + endpoint: "ok", + }, + "endpoint", +); +Scenarios.SpecialWords_Parameters_enum = createParametersTests( + `/special-words/parameters/enum`, + { + enum: "ok", + }, + "enum", +); +Scenarios.SpecialWords_Parameters_error = createParametersTests( + `/special-words/parameters/error`, + { + error: "ok", + }, + "error", +); +Scenarios.SpecialWords_Parameters_export = createParametersTests( + `/special-words/parameters/export`, + { + export: "ok", + }, + "export", +); +Scenarios.SpecialWords_Parameters_extends = createParametersTests( + `/special-words/parameters/extends`, + { + extends: "ok", + }, + "extends", +); +Scenarios.SpecialWords_Parameters_false = createParametersTests( + `/special-words/parameters/false`, + { + false: "ok", + }, + "false", +); +Scenarios.SpecialWords_Parameters_function = createParametersTests( + `/special-words/parameters/function`, + { + function: "ok", + }, + "function", +); +Scenarios.SpecialWords_Parameters_get = createParametersTests( + `/special-words/parameters/get`, + { + get: "ok", + }, + "get", +); +Scenarios.SpecialWords_Parameters_implements = createParametersTests( + `/special-words/parameters/implements`, + { + implements: "ok", + }, + "implements", +); +Scenarios.SpecialWords_Parameters_instanceof = createParametersTests( + `/special-words/parameters/instanceof`, + { + instanceof: "ok", + }, + "instanceof", +); +Scenarios.SpecialWords_Parameters_interface = createParametersTests( + `/special-words/parameters/interface`, + { + interface: "ok", + }, + "interface", +); +Scenarios.SpecialWords_Parameters_let = createParametersTests( + `/special-words/parameters/let`, + { + let: "ok", + }, + "let", +); +Scenarios.SpecialWords_Parameters_module = createParametersTests( + `/special-words/parameters/module`, + { + module: "ok", + }, + "module", +); +Scenarios.SpecialWords_Parameters_new = createParametersTests( + `/special-words/parameters/new`, + { + new: "ok", + }, + "new", +); +Scenarios.SpecialWords_Parameters_null = createParametersTests( + `/special-words/parameters/null`, + { + null: "ok", + }, + "null", +); +Scenarios.SpecialWords_Parameters_number = createParametersTests( + `/special-words/parameters/number`, + { + number: "ok", + }, + "number", +); +Scenarios.SpecialWords_Parameters_of = createParametersTests( + `/special-words/parameters/of`, + { + of: "ok", + }, + "of", +); +Scenarios.SpecialWords_Parameters_package = createParametersTests( + `/special-words/parameters/package`, + { + package: "ok", + }, + "package", +); +Scenarios.SpecialWords_Parameters_private = createParametersTests( + `/special-words/parameters/private`, + { + private: "ok", + }, + "private", +); +Scenarios.SpecialWords_Parameters_protected = createParametersTests( + `/special-words/parameters/protected`, + { + protected: "ok", + }, + "protected", +); +Scenarios.SpecialWords_Parameters_public = createParametersTests( + `/special-words/parameters/public`, + { + public: "ok", + }, + "public", +); +Scenarios.SpecialWords_Parameters_requestoptions = createParametersTests( + `/special-words/parameters/requestoptions`, + { + requestoptions: "ok", + }, + "requestoptions", +); +Scenarios.SpecialWords_Parameters_require = createParametersTests( + `/special-words/parameters/require`, + { + require: "ok", + }, + "require", +); +Scenarios.SpecialWords_Parameters_set = createParametersTests( + `/special-words/parameters/set`, + { + set: "ok", + }, + "set", +); +Scenarios.SpecialWords_Parameters_static = createParametersTests( + `/special-words/parameters/static`, + { + static: "ok", + }, + "static", +); +Scenarios.SpecialWords_Parameters_string = createParametersTests( + `/special-words/parameters/string`, + { + string: "ok", + }, + "string", +); +Scenarios.SpecialWords_Parameters_super = createParametersTests( + `/special-words/parameters/super`, + { + super: "ok", + }, + "super", +); +Scenarios.SpecialWords_Parameters_switch = createParametersTests( + `/special-words/parameters/switch`, + { + switch: "ok", + }, + "switch", +); +Scenarios.SpecialWords_Parameters_symbol = createParametersTests( + `/special-words/parameters/symbol`, + { + symbol: "ok", + }, + "symbol", +); +Scenarios.SpecialWords_Parameters_this = createParametersTests( + `/special-words/parameters/this`, + { + this: "ok", + }, + "this", +); +Scenarios.SpecialWords_Parameters_throw = createParametersTests( + `/special-words/parameters/throw`, + { + throw: "ok", + }, + "throw", +); +Scenarios.SpecialWords_Parameters_true = createParametersTests( + `/special-words/parameters/true`, + { + true: "ok", + }, + "true", +); +Scenarios.SpecialWords_Parameters_type = createParametersTests( + `/special-words/parameters/type`, + { + type: "ok", + }, + "type", +); +Scenarios.SpecialWords_Parameters_typeof = createParametersTests( + `/special-words/parameters/typeof`, + { + typeof: "ok", + }, + "typeof", +); +Scenarios.SpecialWords_Parameters_var = createParametersTests( + `/special-words/parameters/var`, + { + var: "ok", + }, + "var", +); +Scenarios.SpecialWords_Parameters_void = createParametersTests( + `/special-words/parameters/void`, + { + void: "ok", + }, + "void", +); Scenarios.SpecialWords_Parameters_cancellationToken = createParametersTests( `/special-words/parameters/cancellationToken`, {