const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const callback = deepFreeze({
  'http://example.com': {},
  '$request.body#/url': {},
});
assert.deepStrictEqual(t.transformCallback(callback), callback);
const values = Object.values(callback);
sinon.assert.calledWith(t.transformPathItem, values[0]);
sinon.assert.calledWith(t.transformPathItem, values[1]);
sinon.assert.calledTwice(t.transformPathItem);
sinon.assert.alwaysCalledOn(t.transformPathItem, t);
sinon.assert.calledOnce(t.transformCallback);
assertOnlyCalledMethods(t, [t.transformCallback, t.transformPathItem]);

const t = sinon.spy(new OpenApiTransformerBase());
const callback = deepFreeze({ 'x-test': {} });
assert.deepStrictEqual(t.transformCallback(callback), callback);
sinon.assert.calledOnce(t.transformCallback);
assertOnlyCalledMethods(t, [t.transformCallback]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ schemas: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.schemas,
  t.transformSchema,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ responses: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.responses,
  t.transformResponse,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ parameters: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.parameters,
  t.transformParameter,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ examples: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.examples,
  t.transformExample3,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ requestBodies: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.requestBodies,
  t.transformRequestBody,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ headers: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.headers,
  t.transformHeader,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ securitySchemes: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.securitySchemes,
  t.transformSecurityScheme,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ links: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.links,
  t.transformLink,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ callbacks: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.callbacks,
  t.transformCallback,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const components = deepFreeze({ pathItems: {} });
assert.deepStrictEqual(t.transformComponents(components), components);
sinon.assert.calledWith(
  t.transformMap,
  components.pathItems,
  t.transformPathItem,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformComponents);
assertOnlyCalledMethods(t, [t.transformComponents, t.transformMap]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const encoding = deepFreeze({ headers: {} });
assert.deepStrictEqual(t.transformEncoding(encoding), encoding);
sinon.assert.calledWith(
  t.transformMap,
  encoding.headers,
  t.transformHeader,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformEncoding);
assertOnlyCalledMethods(t, [t.transformEncoding, t.transformMap]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const header = deepFreeze({ items: {} });
assert.deepStrictEqual(t.transformHeader(header), header);
sinon.assert.calledWith(t.transformItems, header.items);
sinon.assert.calledOnce(t.transformItems);
sinon.assert.alwaysCalledOn(t.transformItems, t);
sinon.assert.calledOnce(t.transformHeader);
assertOnlyCalledMethods(t, [t.transformHeader, t.transformItems]);

const t = sinon.spy(new OpenApiTransformerBase());
const header = deepFreeze({ schema: {} });
assert.deepStrictEqual(t.transformHeader(header), header);
sinon.assert.calledWith(t.transformSchema, header.schema);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformHeader);
assertOnlyCalledMethods(t, [t.transformHeader, t.transformSchema]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const info = deepFreeze({ contact: {} });
assert.deepStrictEqual(t.transformInfo(info), info);
sinon.assert.calledWith(t.transformContact, info.contact);
sinon.assert.calledOnce(t.transformContact);
sinon.assert.alwaysCalledOn(t.transformContact, t);
sinon.assert.calledOnce(t.transformInfo);
assertOnlyCalledMethods(t, [t.transformInfo, t.transformContact]);

const t = sinon.spy(new OpenApiTransformerBase());
const info = deepFreeze({ license: {} });
assert.deepStrictEqual(t.transformInfo(info), info);
sinon.assert.calledWith(t.transformLicense, info.license);
sinon.assert.calledOnce(t.transformLicense);
sinon.assert.alwaysCalledOn(t.transformLicense, t);
sinon.assert.calledOnce(t.transformInfo);
assertOnlyCalledMethods(t, [t.transformInfo, t.transformLicense]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const items = deepFreeze({ items: {} });
assert.deepStrictEqual(t.transformItems(items), items);
sinon.assert.calledWith(t.transformItems, items.items);
sinon.assert.calledTwice(t.transformItems);
sinon.assert.alwaysCalledOn(t.transformItems, t);
assertOnlyCalledMethods(t, [t.transformItems]);

const t = sinon.spy(new OpenApiTransformerBase());
const items = deepFreeze({ items: undefined });
assert.deepStrictEqual(t.transformItems(items), items);
sinon.assert.calledOnce(t.transformItems);
assertOnlyCalledMethods(t, [t.transformItems]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const link = deepFreeze({ server: {} });
assert.deepStrictEqual(t.transformLink(link), link);
sinon.assert.calledWith(t.transformServer, link.server);
sinon.assert.calledOnce(t.transformServer);
sinon.assert.alwaysCalledOn(t.transformServer, t);
sinon.assert.calledOnce(t.transformLink);
assertOnlyCalledMethods(t, [t.transformLink, t.transformServer]);

const t = sinon.spy(new OpenApiTransformerBase());
const link = deepFreeze({ server: undefined });
assert.deepStrictEqual(t.transformLink(link), link);
sinon.assert.calledOnce(t.transformLink);
assertOnlyCalledMethods(t, [t.transformLink]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const mapper = sinon.stub().returns(true);
const obj = deepFreeze({
  a: 1,
  b: 2,
});
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), {
  a: true,
  b: true,
});
sinon.assert.calledWith(mapper, 1);
sinon.assert.calledWith(mapper, 2);
sinon.assert.calledTwice(mapper);
sinon.assert.alwaysCalledOn(mapper, t);
sinon.assert.calledOnce(t.transformMap);
assertOnlyCalledMethods(t, [t.transformMap]);

const mapper = sinon.stub().returns(true);
const obj = deepFreeze({ 'x-test': 1 });
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), { 'x-test': true });
sinon.assert.calledWith(mapper, 1);
sinon.assert.calledOnce(mapper);
sinon.assert.alwaysCalledOn(mapper, t);
sinon.assert.calledOnce(t.transformMap);
assertOnlyCalledMethods(t, [t.transformMap]);

const mapper = sinon.stub().returns(true);
const obj = deepFreeze({
  a: 1,
  b: undefined,
});
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), {
  a: true,
  b: undefined,
});
sinon.assert.calledWith(mapper, 1);
sinon.assert.calledOnce(mapper);
sinon.assert.alwaysCalledOn(mapper, t);
sinon.assert.calledOnce(t.transformMap);
assertOnlyCalledMethods(t, [t.transformMap]);

const mapper = sinon.stub().returns(true);
const obj = Object.create({ a: 1 });
obj.b = 2;
deepFreeze(obj);
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), { b: true });
sinon.assert.calledWith(mapper, 2);
sinon.assert.calledOnce(mapper);
sinon.assert.alwaysCalledOn(mapper, t);
sinon.assert.calledOnce(t.transformMap);
assertOnlyCalledMethods(t, [t.transformMap]);

const mapper = sinon.stub().returns(true);
const obj = deepFreeze([1, 2]);
const t = sinon.spy(new OpenApiTransformerBase());
assert.deepStrictEqual(t.transformMap(obj, mapper), obj);
sinon.assert.notCalled(mapper);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.calledOnce(t.warn);
assertOnlyCalledMethods(t, [t.transformMap, t.warn]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const mediatype = deepFreeze({ schema: {} });
assert.deepStrictEqual(t.transformMediaType(mediatype), mediatype);
sinon.assert.calledWith(t.transformSchema, mediatype.schema);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformMediaType);
assertOnlyCalledMethods(t, [t.transformMediaType, t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const mediatype = deepFreeze({ examples: {} });
assert.deepStrictEqual(t.transformMediaType(mediatype), mediatype);
sinon.assert.calledWith(
  t.transformMap,
  mediatype.examples,
  t.transformExample3,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformMediaType);
assertOnlyCalledMethods(t, [t.transformMediaType, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const mediatype = deepFreeze({ encoding: {} });
assert.deepStrictEqual(t.transformMediaType(mediatype), mediatype);
sinon.assert.calledWith(
  t.transformMap,
  mediatype.encoding,
  t.transformEncoding,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformMediaType);
assertOnlyCalledMethods(t, [t.transformMediaType, t.transformMap]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const oAuthFlows = deepFreeze({ implicit: {} });
assert.deepStrictEqual(t.transformOAuthFlows(oAuthFlows), oAuthFlows);
sinon.assert.calledWith(t.transformOAuthFlow, oAuthFlows.implicit);
sinon.assert.calledOnce(t.transformOAuthFlow);
sinon.assert.alwaysCalledOn(t.transformOAuthFlow, t);
sinon.assert.calledOnce(t.transformOAuthFlows);
assertOnlyCalledMethods(t, [t.transformOAuthFlows, t.transformOAuthFlow]);

const t = sinon.spy(new OpenApiTransformerBase());
const oAuthFlows = deepFreeze({ password: {} });
assert.deepStrictEqual(t.transformOAuthFlows(oAuthFlows), oAuthFlows);
sinon.assert.calledWith(t.transformOAuthFlow, oAuthFlows.password);
sinon.assert.calledOnce(t.transformOAuthFlow);
sinon.assert.alwaysCalledOn(t.transformOAuthFlow, t);
sinon.assert.calledOnce(t.transformOAuthFlows);
assertOnlyCalledMethods(t, [t.transformOAuthFlows, t.transformOAuthFlow]);

const t = sinon.spy(new OpenApiTransformerBase());
const oAuthFlows = deepFreeze({ clientCredentials: {} });
assert.deepStrictEqual(t.transformOAuthFlows(oAuthFlows), oAuthFlows);
sinon.assert.calledWith(
  t.transformOAuthFlow,
  oAuthFlows.clientCredentials,
);
sinon.assert.calledOnce(t.transformOAuthFlow);
sinon.assert.alwaysCalledOn(t.transformOAuthFlow, t);
sinon.assert.calledOnce(t.transformOAuthFlows);
assertOnlyCalledMethods(t, [t.transformOAuthFlows, t.transformOAuthFlow]);

const t = sinon.spy(new OpenApiTransformerBase());
const oAuthFlows = deepFreeze({ authorizationCode: {} });
assert.deepStrictEqual(t.transformOAuthFlows(oAuthFlows), oAuthFlows);
sinon.assert.calledWith(
  t.transformOAuthFlow,
  oAuthFlows.authorizationCode,
);
sinon.assert.calledOnce(t.transformOAuthFlow);
sinon.assert.alwaysCalledOn(t.transformOAuthFlow, t);
sinon.assert.calledOnce(t.transformOAuthFlows);
assertOnlyCalledMethods(t, [t.transformOAuthFlows, t.transformOAuthFlow]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ info: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformInfo, openApi.info);
sinon.assert.calledOnce(t.transformInfo);
sinon.assert.alwaysCalledOn(t.transformInfo, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformInfo]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ externalDocs: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformExternalDocs, openApi.externalDocs);
sinon.assert.calledOnce(t.transformExternalDocs);
sinon.assert.alwaysCalledOn(t.transformExternalDocs, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformExternalDocs]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ servers: [] });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
  t.transformArray,
  openApi.servers,
  t.transformServer,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ components: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformComponents, openApi.components);
sinon.assert.calledOnce(t.transformComponents);
sinon.assert.alwaysCalledOn(t.transformComponents, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformComponents]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ definitions: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
  t.transformMap,
  openApi.definitions,
  t.transformSchema,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ parameters: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
  t.transformMap,
  openApi.parameters,
  t.transformParameter,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const parameters = [];
const openApi = deepFreeze({
  'x-ms-parameterized-host': {
    hostTemplate: 'example.{tld}',
    parameters,
  },
});
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
  t.transformArray,
  parameters,
  t.transformParameter,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ responses: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
  t.transformMap,
  openApi.responses,
  t.transformResponse,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ paths: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformPaths, openApi.paths);
sinon.assert.calledOnce(t.transformPaths);
sinon.assert.alwaysCalledOn(t.transformPaths, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformPaths]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ 'x-ms-paths': {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(t.transformPaths, openApi['x-ms-paths']);
sinon.assert.calledOnce(t.transformPaths);
sinon.assert.alwaysCalledOn(t.transformPaths, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformPaths]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ webhooks: {} });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
  t.transformMap,
  openApi.webhooks,
  t.transformPathItem,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ security: [] });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
  t.transformArray,
  openApi.security,
  t.transformSecurityRequirement,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const openApi = deepFreeze({ tags: [] });
assert.deepStrictEqual(t.transformOpenApi(openApi), openApi);
sinon.assert.calledWith(
  t.transformArray,
  openApi.tags,
  t.transformTag,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOpenApi);
assertOnlyCalledMethods(t, [t.transformOpenApi, t.transformArray]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = deepFreeze({ externalDocs: {} });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(t.transformExternalDocs, operation.externalDocs);
sinon.assert.calledOnce(t.transformExternalDocs);
sinon.assert.alwaysCalledOn(t.transformExternalDocs, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [
  t.transformOperation,
  t.transformExternalDocs,
]);

const t = sinon.spy(new OpenApiTransformerBase());
const parameters = [];
const operation = deepFreeze({ parameters });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(
  t.transformArray,
  parameters,
  t.transformParameter,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = deepFreeze({ requestBody: {} });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(t.transformRequestBody, operation.requestBody);
sinon.assert.calledOnce(t.transformRequestBody);
sinon.assert.alwaysCalledOn(t.transformRequestBody, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [
  t.transformOperation,
  t.transformRequestBody,
]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = deepFreeze({ responses: {} });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(t.transformResponses, operation.responses);
sinon.assert.calledOnce(t.transformResponses);
sinon.assert.alwaysCalledOn(t.transformResponses, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformResponses]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = deepFreeze({ callbacks: {} });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(
  t.transformMap,
  operation.callbacks,
  t.transformCallback,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const security = [];
const operation = deepFreeze({ security });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(
  t.transformArray,
  security,
  t.transformSecurityRequirement,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const servers = [];
const operation = deepFreeze({ servers });
assert.deepStrictEqual(t.transformOperation(operation), operation);
sinon.assert.calledWith(t.transformArray, servers, t.transformServer);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformOperation);
assertOnlyCalledMethods(t, [t.transformOperation, t.transformArray]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const parameter = deepFreeze({ content: {} });
assert.deepStrictEqual(t.transformParameter(parameter), parameter);
sinon.assert.calledWith(
  t.transformMap,
  parameter.content,
  t.transformMediaType,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformParameter);
assertOnlyCalledMethods(t, [t.transformParameter, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const parameter = deepFreeze({ schema: {} });
assert.deepStrictEqual(t.transformParameter(parameter), parameter);
sinon.assert.calledWith(t.transformSchema, parameter.schema);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformParameter);
assertOnlyCalledMethods(t, [t.transformParameter, t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const parameter = deepFreeze({ items: {} });
assert.deepStrictEqual(t.transformParameter(parameter), parameter);
sinon.assert.calledWith(t.transformItems, parameter.items);
sinon.assert.calledOnce(t.transformItems);
sinon.assert.alwaysCalledOn(t.transformItems, t);
sinon.assert.calledOnce(t.transformParameter);
assertOnlyCalledMethods(t, [t.transformParameter, t.transformItems]);

const t = sinon.spy(new OpenApiTransformerBase());
const parameter = deepFreeze({ examples: {} });
assert.deepStrictEqual(t.transformParameter(parameter), parameter);
sinon.assert.calledWith(
  t.transformMap,
  parameter.examples,
  t.transformExample3,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformParameter);
assertOnlyCalledMethods(t, [t.transformParameter, t.transformMap]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const parameters = [];
const pathItem = deepFreeze({ parameters });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(
  t.transformArray,
  parameters,
  t.transformParameter,
);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const servers = [];
const pathItem = deepFreeze({ servers });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformArray, servers, t.transformServer);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [method]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const operation = {};
const pathItem = deepFreeze({ [methodUpper]: operation });
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledWith(t.transformOperation, operation);
sinon.assert.calledOnce(t.transformOperation);
sinon.assert.alwaysCalledOn(t.transformOperation, t);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem, t.transformOperation]);

const t = sinon.spy(new OpenApiTransformerBase());
const pathItem = deepFreeze({
  summary: {},
  description: {},
  'x-get': {},
});
assert.deepStrictEqual(t.transformPathItem(pathItem), pathItem);
sinon.assert.calledOnce(t.transformPathItem);
assertOnlyCalledMethods(t, [t.transformPathItem]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const paths = deepFreeze({
  '/path1': {},
  '/path2': {},
});
assert.deepStrictEqual(t.transformPaths(paths), paths);
const values = Object.values(paths);
sinon.assert.calledWith(t.transformPathItem, values[0]);
sinon.assert.calledWith(t.transformPathItem, values[1]);
sinon.assert.calledTwice(t.transformPathItem);
sinon.assert.alwaysCalledOn(t.transformPathItem, t);
sinon.assert.calledOnce(t.transformPaths);
assertOnlyCalledMethods(t, [t.transformPaths, t.transformPathItem]);

const t = sinon.spy(new OpenApiTransformerBase());
const paths = deepFreeze({
  path1: {},
  path2: {},
});
assert.deepStrictEqual(t.transformPaths(paths), paths);
const values = Object.values(paths);
sinon.assert.calledWith(t.transformPathItem, values[0]);
sinon.assert.calledWith(t.transformPathItem, values[1]);
sinon.assert.calledTwice(t.transformPathItem);
sinon.assert.alwaysCalledOn(t.transformPathItem, t);
sinon.assert.calledOnce(t.transformPaths);
assertOnlyCalledMethods(t, [t.transformPaths, t.transformPathItem]);

const t = sinon.spy(new OpenApiTransformerBase());
const paths = deepFreeze({ 'x-test': {} });
assert.deepStrictEqual(t.transformPaths(paths), paths);
sinon.assert.calledOnce(t.transformPaths);
assertOnlyCalledMethods(t, [t.transformPaths]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const requestBody = deepFreeze({ content: {} });
assert.deepStrictEqual(t.transformRequestBody(requestBody), requestBody);
sinon.assert.calledWith(
  t.transformMap,
  requestBody.content,
  t.transformMediaType,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformRequestBody);
assertOnlyCalledMethods(t, [t.transformRequestBody, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const requestBody = deepFreeze({ content: undefined });
assert.deepStrictEqual(t.transformRequestBody(requestBody), requestBody);
sinon.assert.calledOnce(t.transformRequestBody);
assertOnlyCalledMethods(t, [t.transformRequestBody]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ headers: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(
  t.transformMap,
  response.headers,
  t.transformHeader,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ content: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(
  t.transformMap,
  response.content,
  t.transformMediaType,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ links: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(
  t.transformMap,
  response.links,
  t.transformLink,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ schema: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(t.transformSchema, response.schema);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const response = deepFreeze({ examples: {} });
assert.deepStrictEqual(t.transformResponse(response), response);
sinon.assert.calledWith(t.transformExample, response.examples);
sinon.assert.calledOnce(t.transformExample);
sinon.assert.alwaysCalledOn(t.transformExample, t);
sinon.assert.calledOnce(t.transformResponse);
assertOnlyCalledMethods(t, [t.transformResponse, t.transformExample]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const responses = deepFreeze({ default: {} });
assert.deepStrictEqual(t.transformResponses(responses), responses);
sinon.assert.calledWith(t.transformResponse, responses.default);
sinon.assert.calledOnce(t.transformResponse);
sinon.assert.alwaysCalledOn(t.transformResponse, t);
sinon.assert.calledOnce(t.transformResponses);
assertOnlyCalledMethods(t, [t.transformResponses, t.transformResponse]);

const t = sinon.spy(new OpenApiTransformerBase());
const responses = deepFreeze({ 200: {} });
assert.deepStrictEqual(t.transformResponses(responses), responses);
sinon.assert.calledWith(t.transformResponse, responses[200]);
sinon.assert.calledOnce(t.transformResponse);
sinon.assert.alwaysCalledOn(t.transformResponse, t);
sinon.assert.calledOnce(t.transformResponses);
assertOnlyCalledMethods(t, [t.transformResponses, t.transformResponse]);

const t = sinon.spy(new OpenApiTransformerBase());
const responses = deepFreeze({ '2XX': {} });
assert.deepStrictEqual(t.transformResponses(responses), responses);
sinon.assert.calledWith(t.transformResponse, responses['2XX']);
sinon.assert.calledOnce(t.transformResponse);
sinon.assert.alwaysCalledOn(t.transformResponse, t);
sinon.assert.calledOnce(t.transformResponses);
assertOnlyCalledMethods(t, [t.transformResponses, t.transformResponse]);

const t = sinon.spy(new OpenApiTransformerBase());
const responses = deepFreeze({ 'x-other': {} });
assert.deepStrictEqual(t.transformResponses(responses), responses);
sinon.assert.notCalled(t.transformResponse);
sinon.assert.calledOnce(t.transformResponses);
assertOnlyCalledMethods(t, [t.transformResponses]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ discriminator: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformDiscriminator, schema.discriminator);
sinon.assert.calledOnce(t.transformDiscriminator);
sinon.assert.alwaysCalledOn(t.transformDiscriminator, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformDiscriminator]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ externalDocs: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformExternalDocs, schema.externalDocs);
sinon.assert.calledOnce(t.transformExternalDocs);
sinon.assert.alwaysCalledOn(t.transformExternalDocs, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformExternalDocs]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ xml: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformXml, schema.xml);
sinon.assert.calledOnce(t.transformXml);
sinon.assert.alwaysCalledOn(t.transformXml, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformXml]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ properties: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchemaProperties, schema.properties);
sinon.assert.calledOnce(t.transformSchemaProperties);
sinon.assert.alwaysCalledOn(t.transformSchemaProperties, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [
  t.transformSchema,
  t.transformSchemaProperties,
]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ items: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema.items);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const items = [];
const schema = deepFreeze({ items });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, items, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaProp]: {} });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformSchema, schema[schemaProp]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({
  [schemaMapProp]: {
    a: {},
    b: {},
  },
});
assert.deepStrictEqual(t.transformSchema(schema), schema);
const values = Object.values(schema[schemaMapProp]);
sinon.assert.calledWith(t.transformSchema, values[0]);
sinon.assert.calledWith(t.transformSchema, values[1]);
sinon.assert.callCount(t.transformSchema, 3);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaMapProp]: { 'x-test': {} } });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(
  t.transformSchema,
  schema[schemaMapProp]['x-test'],
);
sinon.assert.calledTwice(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({
  [schemaMapProp]: {
    a: {},
    b: {},
  },
});
assert.deepStrictEqual(t.transformSchema(schema), schema);
const values = Object.values(schema[schemaMapProp]);
sinon.assert.calledWith(t.transformSchema, values[0]);
sinon.assert.calledWith(t.transformSchema, values[1]);
sinon.assert.callCount(t.transformSchema, 3);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaMapProp]: { 'x-test': {} } });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(
  t.transformSchema,
  schema[schemaMapProp]['x-test'],
);
sinon.assert.calledTwice(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schemas = [];
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const schemas = {};
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.calledOnce(t.warn);
assertOnlyCalledMethods(t, [
  t.transformSchema,
  t.transformArray,
  t.warn,
]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaArrayProp]: undefined });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schemas = [];
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const schemas = {};
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.calledOnce(t.warn);
assertOnlyCalledMethods(t, [
  t.transformSchema,
  t.transformArray,
  t.warn,
]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaArrayProp]: undefined });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schemas = [];
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema, t.transformArray]);

const t = sinon.spy(new OpenApiTransformerBase());
const schemas = {};
const schema = deepFreeze({ [schemaArrayProp]: schemas });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledWith(t.transformArray, schemas, t.transformSchema);
sinon.assert.calledOnce(t.transformArray);
sinon.assert.alwaysCalledOn(t.transformArray, t);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.calledOnce(t.warn);
assertOnlyCalledMethods(t, [
  t.transformSchema,
  t.transformArray,
  t.warn,
]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ [schemaArrayProp]: undefined });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);

const t = sinon.spy(new OpenApiTransformerBase());
const schema = deepFreeze({ examples: [{}] });
assert.deepStrictEqual(t.transformSchema(schema), schema);
sinon.assert.calledOnce(t.transformSchema);
assertOnlyCalledMethods(t, [t.transformSchema]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const properties = deepFreeze({
  a: {},
  b: {},
});
assert.deepStrictEqual(
  t.transformSchemaProperties(properties),
  properties,
);
const values = Object.values(properties);
sinon.assert.calledWith(t.transformSchema, values[0]);
sinon.assert.calledWith(t.transformSchema, values[1]);
sinon.assert.calledTwice(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformSchemaProperties);
assertOnlyCalledMethods(t, [
  t.transformSchemaProperties,
  t.transformSchema,
]);

const t = sinon.spy(new OpenApiTransformerBase());
const properties = deepFreeze({ 'x-test': {} });
assert.deepStrictEqual(
  t.transformSchemaProperties(properties),
  properties,
);
sinon.assert.calledWith(t.transformSchema, properties['x-test']);
sinon.assert.calledOnce(t.transformSchema);
sinon.assert.alwaysCalledOn(t.transformSchema, t);
sinon.assert.calledOnce(t.transformSchemaProperties);
assertOnlyCalledMethods(t, [
  t.transformSchemaProperties,
  t.transformSchema,
]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const securityScheme = deepFreeze({ flows: {} });
assert.deepStrictEqual(
  t.transformSecurityScheme(securityScheme),
  securityScheme,
);
sinon.assert.calledWith(t.transformOAuthFlows, securityScheme.flows);
sinon.assert.calledOnce(t.transformOAuthFlows);
sinon.assert.alwaysCalledOn(t.transformOAuthFlows, t);
sinon.assert.calledOnce(t.transformSecurityScheme);
assertOnlyCalledMethods(t, [
  t.transformSecurityScheme,
  t.transformOAuthFlows,
]);

const t = sinon.spy(new OpenApiTransformerBase());
const securityScheme = deepFreeze({ flows: undefined });
assert.deepStrictEqual(
  t.transformSecurityScheme(securityScheme),
  securityScheme,
);
sinon.assert.calledOnce(t.transformSecurityScheme);
assertOnlyCalledMethods(t, [t.transformSecurityScheme]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const server = deepFreeze({ variables: {} });
assert.deepStrictEqual(t.transformServer(server), server);
sinon.assert.calledWith(
  t.transformMap,
  server.variables,
  t.transformServerVariable,
);
sinon.assert.calledOnce(t.transformMap);
sinon.assert.alwaysCalledOn(t.transformMap, t);
sinon.assert.calledOnce(t.transformServer);
assertOnlyCalledMethods(t, [t.transformServer, t.transformMap]);

const t = sinon.spy(new OpenApiTransformerBase());
const server = deepFreeze({ variables: undefined });
assert.deepStrictEqual(t.transformServer(server), server);
sinon.assert.calledOnce(t.transformServer);
assertOnlyCalledMethods(t, [t.transformServer]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);

const t = sinon.spy(new OpenApiTransformerBase());
const tag = deepFreeze({ externalDocs: {} });
assert.deepStrictEqual(t.transformTag(tag), tag);
sinon.assert.calledWith(t.transformExternalDocs, tag.externalDocs);
sinon.assert.calledOnce(t.transformExternalDocs);
sinon.assert.alwaysCalledOn(t.transformExternalDocs, t);
sinon.assert.calledOnce(t.transformTag);
assertOnlyCalledMethods(t, [t.transformTag, t.transformExternalDocs]);

const t = sinon.spy(new OpenApiTransformerBase());
const tag = deepFreeze({ externalDocs: undefined });
assert.deepStrictEqual(t.transformTag(tag), tag);
sinon.assert.calledOnce(t.transformTag);
assertOnlyCalledMethods(t, [t.transformTag]);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName](arg);
assert.strictEqual(result, arg);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]([]);
assert(Array.isArray(result), 'result isArray');
assert.strictEqual(result.length, 0);

const transformer = new OpenApiTransformerBase();
const result = transformer[methodName]({});
assert.strictEqual(typeof result, 'object');
assert.notStrictEqual(result, null);