@zohodesk/testinglibrary 0.0.9-exp.3 → 0.0.9-n20-experimental

package/build/core/playwright/helpers/auth/accountLogin.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _getUrlOrigin = _interopRequireDefault(require("./getUrlOrigin"));
+async function accountLogin(page, useremail, password) {
+  await page.locator('#login_id').fill(useremail);
+  await page.locator('#nextbtn').click();
+  await page.locator('#password').fill(password);
+  await page.locator('#nextbtn').click();
+  const domainUrlOrigin = (0, _getUrlOrigin.default)(process.env.domain);
+  await page.waitForNavigation();
+  if (!page.url().includes(domainUrlOrigin)) {
+    await page.goto(domainUrlOrigin);
+  }
+  await page.waitForURL(`${domainUrlOrigin}/**`);
+}
+var _default = exports.default = accountLogin;

package/build/core/playwright/helpers/auth/checkAuthCookies.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAuthFileDirectory = getAuthFileDirectory;
+exports.loadCookiesIfPresent = loadCookiesIfPresent;
+exports.verifyIfCookieFileExists = verifyIfCookieFileExists;
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+var _readConfigFile = require("../../readConfigFile");
+var _logger = require("../../../../utils/logger");
+/* eslint-disable no-console */
+
+function getAuthFileDirectory() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.auth'));
+}
+function verifyIfCookieFileExists(authFile) {
+  return (0, _fs.existsSync)(authFile);
+}
+function convertCookiesToParse(cookies, authFilePath) {
+  try {
+    return JSON.parse(cookies);
+  } catch (err) {
+    _logger.Logger.error(err);
+    throw new Error(` Error while parsing cookies ${err} \n${_path.default.resolve(process.cwd(), authFilePath)} File is Empty`);
+  }
+}
+async function loadCookiesIfPresent(page, authFile) {
+  if (verifyIfCookieFileExists(authFile)) {
+    const fileContent = (0, _fs.readFileSync)(authFile);
+    const stroageState = convertCookiesToParse(fileContent, authFile);
+    if (stroageState.cookies) {
+      await page.context().addCookies(stroageState.cookies);
+    }
+  }
+}

package/build/core/playwright/helpers/auth/getUrlOrigin.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function getUrlOrigin(url) {
+  const {
+    origin
+  } = new URL(url);
+  return origin;
+}
+var _default = exports.default = getUrlOrigin;

package/build/core/playwright/helpers/auth/getUsers.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDefaultActor = getDefaultActor;
+exports.getDefaultActorConf = getDefaultActorConf;
+exports.getListOfActors = getListOfActors;
+exports.getRunMode = getRunMode;
+exports.getUserForSelectedEditionAndProfile = getUserForSelectedEditionAndProfile;
+exports.isCI = isCI;
+exports.isDevelopmentSetup = isDevelopmentSetup;
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+var _readConfigFile = require("../../readConfigFile");
+/* eslint-disable global-require */
+function getRunMode() {
+  let {
+    mode
+  } = process.env;
+  return mode || 'dev';
+}
+function isCI() {
+  const mode = getRunMode();
+  return mode === 'CI' || mode === 'ci';
+}
+function isDevelopmentSetup() {
+  const mode = getRunMode();
+  return mode === 'DEV' || mode === 'dev';
+}
+function getDefaultActorConf() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  const modeSettingsFile = `conf/${getRunMode()}/settings.json`;
+  const filePath = _path.default.join(uatDirectory, modeSettingsFile);
+  try {
+    if (!(0, _fs.existsSync)(filePath)) {
+      const defaultSettingsFile = _path.default.join(uatDirectory, `conf/default/settings.json`);
+      return require(defaultSettingsFile);
+    }
+    return require(filePath);
+  } catch (error) {
+    throw new Error(`${defaultSettingFile} ${filePath} both files are missing.`);
+  }
+}
+function getDefaultActor() {
+  const {
+    edition,
+    profile
+  } = getDefaultActorConf();
+  return getUserForSelectedEditionAndProfile(edition, profile);
+}
+function getListOfActors(betaFeature) {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  const mode = getRunMode();
+  let configFile = _path.default.join(uatDirectory, `conf/${mode}/actors/index.js`);
+  let betaReference = mode;
+  if (!(0, _fs.existsSync)(configFile)) {
+    configFile = _path.default.join(uatDirectory, `conf/default/actors/index.js`);
+    betaReference = "default";
+  }
+  if (betaFeature) {
+    configFile = _path.default.join(uatDirectory, `conf/${betaReference}/actors/beta/${betaFeature}/index.js`);
+    if (!(0, _fs.existsSync)(configFile)) {
+      throw new Error(`There is no beta feature configured with the name "${betaFeature}"`);
+    }
+  }
+  try {
+    return require(configFile);
+  } catch (error) {
+    throw new Error(`Error loading actor configuration from ${configFile}`);
+  }
+}
+function getUserForSelectedEditionAndProfile(preferedEdition, preferredProfile, betaFeature, testDataPortal = null) {
+  const actorsData = getListOfActors(betaFeature);
+  if (!actorsData || !actorsData.editions) {
+    throw new Error("The actors data is missing.");
+  }
+  const {
+    editions: userdata
+  } = actorsData;
+  const defaultConf = getDefaultActorConf();
+  const edition = preferedEdition || defaultConf.edition;
+  const profile = preferredProfile || defaultConf.profile;
+  let selectedProfile = {};
+
+  // TODO: We are returning the first data from array. We need to check the possiblity of having multiple users for same profile and possibly round robin
+  // For this we need to get the data from ci environment.
+
+  let testingPortal = null;
+  if (!userdata.hasOwnProperty(edition)) {
+    throw new Error(`There is no "${edition}" edition configured.`);
+  }
+  if (testDataPortal !== null) {
+    testingPortal = userdata[edition].find(editionData => editionData.orgName === testDataPortal);
+    if (!testingPortal) {
+      throw new Error(`There is no "${testDataPortal}" portal configured in "${edition}" edition.`);
+    }
+  } else {
+    testingPortal = userdata[edition] ? userdata[edition][0] : {};
+  }
+  const {
+    profiles,
+    ...editionData
+  } = testingPortal;
+  selectedProfile = profiles.find(user => user.profile === profile);
+  if (!selectedProfile) {
+    throw new Error(`There is no "${profile}" profile configured in "${edition}" edition.`);
+  }
+  return {
+    ...editionData,
+    ...selectedProfile
+  };
+}

package/build/core/playwright/helpers/auth/index.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "accountLogin", {
+  enumerable: true,
+  get: function () {
+    return _accountLogin.default;
+  }
+});
+Object.defineProperty(exports, "getDefaultActor", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getDefaultActor;
+  }
+});
+Object.defineProperty(exports, "getDefaultActorConf", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getDefaultActorConf;
+  }
+});
+Object.defineProperty(exports, "getListOfActors", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getListOfActors;
+  }
+});
+Object.defineProperty(exports, "getRunMode", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getRunMode;
+  }
+});
+Object.defineProperty(exports, "getUserForSelectedEditionAndProfile", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.getUserForSelectedEditionAndProfile;
+  }
+});
+Object.defineProperty(exports, "isCI", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.isCI;
+  }
+});
+Object.defineProperty(exports, "isDevelopmentSetup", {
+  enumerable: true,
+  get: function () {
+    return _getUsers.isDevelopmentSetup;
+  }
+});
+Object.defineProperty(exports, "loadCookiesIfPresent", {
+  enumerable: true,
+  get: function () {
+    return _checkAuthCookies.loadCookiesIfPresent;
+  }
+});
+Object.defineProperty(exports, "performLoginSteps", {
+  enumerable: true,
+  get: function () {
+    return _loginSteps.default;
+  }
+});
+Object.defineProperty(exports, "verifyIfCookieFileExists", {
+  enumerable: true,
+  get: function () {
+    return _checkAuthCookies.verifyIfCookieFileExists;
+  }
+});
+var _accountLogin = _interopRequireDefault(require("./accountLogin"));
+var _checkAuthCookies = require("./checkAuthCookies");
+var _getUsers = require("./getUsers");
+var _loginSteps = _interopRequireDefault(require("./loginSteps"));

package/build/core/playwright/helpers/auth/loginDefaultStepsHelper.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.executeDefaultLoginSteps = executeDefaultLoginSteps;
+exports.loginSteps = loginSteps;
+exports.performDefaultPageSteps = performDefaultPageSteps;
+exports.verifyPageIsLoaded = verifyPageIsLoaded;
+var _auth = require("../auth");
+var _readConfigFile = require("../../readConfigFile");
+var _logger = require("../../../../utils/logger");
+let {
+  testSetup,
+  isAuthMode
+} = (0, _readConfigFile.generateConfigFromFile)();
+async function loginSteps(pageDetail) {
+  const {
+    page
+  } = pageDetail;
+  if (testSetup.loginSteps && typeof testSetup.loginSteps === 'function') {
+    return await testSetup.loginSteps(pageDetail);
+  } else {
+    await page.goto(process.env.domain);
+  }
+}
+async function performDefaultPageSteps(testInfo) {
+  if (testSetup.page && typeof testSetup.page === 'function') {
+    await testSetup.page(testInfo);
+  }
+}
+async function verifyPageIsLoaded(testInfo) {
+  if (testSetup.validateLogin && typeof testSetup.validateLogin === 'function') {
+    return await testSetup.validateLogin(testInfo);
+  }
+  return true;
+}
+async function executeDefaultLoginSteps(context, testInfo, testDetails, testPortalDetails) {
+  if (!isAuthMode) {
+    return;
+  }
+  try {
+    const projectName = testInfo.project.name;
+    if (testPortalDetails && projectName !== 'setup' && projectName !== 'cleanup') {
+      await context.clearCookies();
+      await (0, _auth.performLoginSteps)(testDetails, async testInfo => {
+        return await verifyPageIsLoaded(testInfo);
+      }, loginSteps);
+      process.env.actorInfo = JSON.stringify(testPortalDetails);
+    }
+  } catch (error) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error while executing the default login steps:', error);
+  }
+}

package/build/core/playwright/helpers/auth/loginSteps.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fileMutex = _interopRequireDefault(require("../fileMutex"));
+var _fileMutexConfig = require("../../constants/fileMutexConfig");
+var _checkAuthCookies = require("./checkAuthCookies");
+var _checkAuthDirectory = require("../checkAuthDirectory");
+var _logger = require("../../../../utils/logger");
+/* eslint-disable no-console */
+
+async function performLoginSteps(testInfo, isLoggedIn, loginSteps) {
+  let {
+    page,
+    authFilePrefix,
+    email
+  } = testInfo;
+  authFilePrefix = authFilePrefix || email;
+  const authFile = _path.default.resolve(_path.default.join((0, _checkAuthCookies.getAuthFileDirectory)(), `${authFilePrefix}-cookies.json`));
+  const lockFileName = email.replace(/[@.]/g, '_');
+  const fileMutex = new _fileMutex.default((0, _checkAuthDirectory.getLockDirectoryPath)(), lockFileName, _fileMutexConfig.fileDeletionTimeoutConfig);
+  let loginUsingCookie = false;
+  try {
+    if ((0, _checkAuthCookies.verifyIfCookieFileExists)(authFile)) {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `${email} Cookie file exists. Loading cookies, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      loginUsingCookie = true;
+    } else {
+      await fileMutex.acquire();
+    }
+    await (0, _checkAuthCookies.loadCookiesIfPresent)(page, authFile);
+    const isAlreadyLoggedIn = await isLoggedIn(testInfo);
+    if (!isAlreadyLoggedIn) {
+      await loginSteps(testInfo);
+      await isLoggedIn(testInfo);
+      await page.context().storageState({
+        path: authFile
+      });
+    }
+  } catch (error) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error during login for ${email}:`, error);
+  } finally {
+    if (!loginUsingCookie) {
+      await fileMutex.release();
+    }
+  }
+}
+var _default = exports.default = performLoginSteps;

package/build/core/playwright/helpers/checkAuthDirectory.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAuthDirectoryIfNotExist = createAuthDirectoryIfNotExist;
+exports.getLockDirectoryPath = getLockDirectoryPath;
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _checkAuthCookies = require("./auth/checkAuthCookies");
+var _readConfigFile = require("../readConfigFile");
+function createAuthDirectoryIfNotExist() {
+  const authDirectory = (0, _checkAuthCookies.getAuthFileDirectory)();
+  if (!(0, _fs.existsSync)(authDirectory)) {
+    console.log('Creating auth directory for the first time setup...');
+    (0, _fs.mkdirSync)(authDirectory, {
+      recursive: true
+    });
+  }
+}
+function getLockDirectoryPath() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.lock'));
+}

package/build/core/playwright/helpers/configFileNameProvider.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnvConfigFilePath = getEnvConfigFilePath;
+exports.getReportFileName = getReportFileName;
+exports.getUATFileName = getUATFileName;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _auth = require("./auth");
+function getUATFileName(mode) {
+  mode = mode || (0, _auth.getRunMode)();
+  const uatConfFilePath = _path.default.resolve(process.cwd(), `uat/conf/${mode}/uat.config.js`);
+  if (_fs.default.existsSync(uatConfFilePath)) {
+    return uatConfFilePath;
+  }
+  return _path.default.resolve(process.cwd(), `uat/conf/default/uat.config.js`);
+}
+function getEnvConfigFilePath(mode) {
+  const confFilePath = _path.default.resolve(process.cwd(), `uat/conf/${mode}/settings.json`);
+  // TODO: Actors Mode as config
+  if (_fs.default.existsSync(confFilePath)) {
+    return `uat/conf/${mode}/settings.json`;
+  }
+  return `uat/conf/default/settings.json`;
+}
+function getReportFileName() {
+  return `test-summary.json`;
+}

package/build/core/playwright/helpers/customFixturesHelper.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractTagInfo = extractTagInfo;
+exports.getCustomAccountDetails = getCustomAccountDetails;
+var _auth = require("../helpers/auth");
+var _logger = require("../../../utils/logger");
+/* eslint-disable global-require */
+
+function getTagInputFromSelectedTags(tags, inputString) {
+  const selectedTag = [...tags].reverse().find(tag => tag.startsWith(inputString));
+  let tagInput = null;
+  if (selectedTag) {
+    tagInput = selectedTag.split(`${inputString}_`).pop().toLowerCase();
+  }
+  return tagInput;
+}
+function extractTagInfo(tags) {
+  const tagsTobeFiltered = ['@profile', '@edition', '@beta', '@portal'];
+  const filteredTags = tags.filter(tag => tagsTobeFiltered.some(prefix => tag.startsWith(prefix)));
+  if (!filteredTags.length) {
+    return {
+      portalInfo: null,
+      betaFeature: null,
+      profileInfo: null,
+      editionInfo: null
+    };
+  }
+  const portalInfo = getTagInputFromSelectedTags(filteredTags, '@portal');
+  const betaFeature = getTagInputFromSelectedTags(filteredTags, '@beta');
+  const profileInfo = getTagInputFromSelectedTags(filteredTags, '@profile');
+  const editionInfo = getTagInputFromSelectedTags(filteredTags, '@edition');
+  return {
+    portalInfo,
+    betaFeature,
+    profileInfo,
+    editionInfo
+  };
+}
+function getCustomAccountDetails(tags) {
+  try {
+    const {
+      portalInfo,
+      betaFeature,
+      profileInfo,
+      editionInfo
+    } = extractTagInfo(tags);
+    if (portalInfo || betaFeature || profileInfo || editionInfo) {
+      const user = (0, _auth.getUserForSelectedEditionAndProfile)(editionInfo, profileInfo, betaFeature, portalInfo);
+      return user;
+    }
+    return (0, _auth.getDefaultActor)();
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error while getting accounts details:', err);
+  }
+}

package/build/core/playwright/helpers/fileMutex.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+var _logger = require("../../../utils/logger");
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _FileMutex_brand = /*#__PURE__*/new WeakSet();
+class FileMutex {
+  constructor(directory, lockFileName, fileDeletionTimeoutConfig) {
+    _classPrivateMethodInitSpec(this, _FileMutex_brand);
+    this.directory = directory;
+    this.lockFileName = lockFileName + ".lock";
+    this.fileDeletionTimeout = fileDeletionTimeoutConfig.timeout;
+    this.lockFilePath = _assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this);
+    _assertClassBrand(_FileMutex_brand, this, _createDirectoryIfNotExist).call(this);
+  }
+  async acquire() {
+    return new Promise((resolve, reject) => {
+      if (!(0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.writeFileSync)(this.lockFilePath, 'locked');
+        _logger.Logger.log(_logger.Logger.INFO_TYPE, `Lock file created: ${this.lockFilePath}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+        return resolve();
+      }
+      const timeout = setTimeout(() => {
+        watcher.close();
+        reject(new Error('Watch timeout exceeded'));
+      }, this.fileDeletionTimeout);
+      const watcher = (0, _fs.watch)(this.directory, (eventType, filename) => {
+        try {
+          if (eventType === 'rename' && filename === this.lockFileName) {
+            clearTimeout(timeout);
+            _logger.Logger.log(_logger.Logger.INFO_TYPE, `Lock file deleted! Proceeding, worker index - ${process.env.TEST_WORKER_INDEX}`);
+            watcher.close();
+            resolve();
+          }
+        } catch (err) {
+          _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error watching for lock file deletion: ${err.message}`);
+          watcher.close();
+        }
+      });
+    });
+  }
+  async release() {
+    try {
+      if ((0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.unlinkSync)(this.lockFilePath);
+        _logger.Logger.log(_logger.Logger.INFO_TYPE, `Lock file deleted: ${this.lockFilePath}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      }
+    } catch (err) {
+      _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Error deleting lock file: ${err.message}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      throw err;
+    }
+  }
+}
+function _getLockFilePath() {
+  return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
+}
+async function _createDirectoryIfNotExist() {
+  if (!(0, _fs.existsSync)(this.directory)) {
+    (0, _fs.mkdirSync)(this.directory, {
+      recursive: true
+    });
+  }
+}
+var _default = exports.default = FileMutex;

package/build/core/playwright/helpers/getUserFixtures.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _logger = require("../../../utils/logger");
+var _readConfigFile = require("../readConfigFile");
+function getUserFixtures() {
+  const {
+    additionalPages
+  } = (0, _readConfigFile.generateConfigFromFile)();
+
+  // if (additionalPages.page || additionalPages.context) {
+  //   // Logger.log(
+  //   //   Logger.INFO_TYPE,
+  //   //   'Not allowed to override the page and context fixture. Use Test Setup in uat configuration'
+  //   // );
+  // }
+
+  return additionalPages;
+}
+var _default = exports.default = getUserFixtures;

package/build/core/playwright/helpers/mergeObjects.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeObjects = mergeObjects;
+// Utility function to merge objects using spread operator
+function mergeObjects(obj1, obj2) {
+  return {
+    ...obj1,
+    ...obj2
+  };
+}

package/build/core/playwright/helpers/parseUserArgs.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseUserArgs = parseUserArgs;
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+function parseUserArgs() {
+  return (0, _cliArgsToObject.cliArgsToObject)(process.argv.slice(2));
+}