detox 20.0.4-breaking.new-global-lifecycle.0 → 20.0.7-prerelease.0

package/src/realms/DetoxPrimaryContext.js

@@ -1,24 +1,34 @@
 const path = require('path');
 const { URL } = require('url');
+const { promisify } = require('util');
 
 const fs = require('fs-extra');
+const glob = require('glob');
 const pipe = require('multipipe');
+const onSignalExit = require('signal-exit');
 
 const temporary = require('../artifacts/utils/temporaryPath');
 const { DetoxRuntimeError } = require('../errors');
-const { PrimarySessionState } = require('../ipc/state');
+const SessionState = require('../ipc/SessionState');
 const symbols = require('../symbols');
 
+const globAsync = promisify(glob);
+const globSync = glob.sync;
+
 const DetoxContext = require('./DetoxContext');
 
-const { $logger, $restoreSessionState, $sessionState } = DetoxContext.protected;
+const { $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
 
 const _finalizeLogs = Symbol('finalizeLogs');
+const _finalizeLogsSync = Symbol('finalizeLogsSync');
 const _globalLifecycleHandler = Symbol('globalLifecycleHandler');
 const _ipcServer = Symbol('ipcServer');
 const _resetLockFile = Symbol('resetLockFile');
 const _wss = Symbol('wss');
 const _dirty = Symbol('dirty');
+const _emergencyTeardown = Symbol('emergencyTeardown');
+const _areLogsEnabled = Symbol('areLogsEnabled');
+const _lifecycleLogger = Symbol('lifecycleLogger');
 
 class DetoxPrimaryContext extends DetoxContext {
   constructor() {
@@ -31,6 +41,8 @@ class DetoxPrimaryContext extends DetoxContext {
      * @type {import('../ipc/IPCServer') | null}
      */
     this[_ipcServer] = null;
+    /** @type {Detox.Logger} */
+    this[_lifecycleLogger] = this[symbols.logger].child({ cat: 'lifecycle' });
   }
 
   //#region Internal members
@@ -41,7 +53,7 @@ class DetoxPrimaryContext extends DetoxContext {
   }
 
   async [symbols.resolveConfig](opts = {}) {
-    const session = this[symbols.session];
+    const session = this[$sessionState];
     if (!session.detoxConfig) {
       const configuration = require('../configuration');
       session.detoxConfig = await configuration.composeDetoxConfig(opts);
@@ -52,9 +64,9 @@ class DetoxPrimaryContext extends DetoxContext {
 
   /**
    * @override
-   * @param {Partial<DetoxInternals.DetoxGlobalSetupOptions>} [opts]
+   * @param {Partial<DetoxInternals.DetoxInitOptions>} [opts]
    */
-  async [symbols.globalSetup](opts) {
+  async [symbols.init](opts = {}) {
     if (this[_dirty]) {
       throw new DetoxRuntimeError({
         message: 'Cannot initialize primary Detox context more than once.',
@@ -63,6 +75,8 @@ class DetoxPrimaryContext extends DetoxContext {
     }
 
     this[_dirty] = true;
+    onSignalExit(this[_emergencyTeardown]);
+
     const detoxConfig = await this[symbols.resolveConfig](opts);
 
     const {
@@ -71,18 +85,16 @@ class DetoxPrimaryContext extends DetoxContext {
       logger: loggerConfig,
       session: sessionConfig
     } = detoxConfig;
-    await this[$logger].setConfig(loggerConfig);
+    await this[symbols.logger].setConfig(loggerConfig);
 
-    this.trace.begin({
-      cat: 'lifecycle',
-      args: this[$sessionState],
-      name: process.argv.slice(1).join(' '),
-    });
+    this[_lifecycleLogger].trace.begin({
+      data: this[$sessionState],
+    }, process.argv.slice(1).join(' '));
 
     const IPCServer = require('../ipc/IPCServer');
     this[_ipcServer] = new IPCServer({
       sessionState: this[$sessionState],
-      logger: this[$logger],
+      logger: this[symbols.logger],
     });
 
     await this[_ipcServer].init();
@@ -111,63 +123,98 @@ class DetoxPrimaryContext extends DetoxContext {
     }
 
     if (!sessionConfig.server && this[_wss]) {
+      // @ts-ignore
       sessionConfig.server = `ws://localhost:${this[_wss].port}`;
     }
 
     await fs.writeFile(this[$sessionState].detoxConfigSnapshotPath, this[$sessionState].stringify());
     process.env.DETOX_CONFIG_SNAPSHOT_PATH = this[$sessionState].detoxConfigSnapshotPath;
 
-    // TODO: think about signal-exit and cleaning up the logs
+    if (opts.workerId !== null) {
+      await this[symbols.installWorker](opts);
+    }
   }
 
   /**
    * @override
-   * @param {Partial<DetoxInternals.DetoxConfigurationSetupOptions>} [opts]
+   * @param {Partial<DetoxInternals.DetoxInstallWorkerOptions>} [opts]
    */
-  async [symbols.setup](opts = {}) {
-    const workerId = opts.workerId || 1;
-    this[$sessionState].workerId = workerId;
+  async [symbols.installWorker](opts = {}) {
+    const workerId = this[$sessionState].workerId = opts.workerId = opts.workerId || 'worker';
     this[_ipcServer].onRegisterWorker({ workerId });
-    await super[symbols.setup](opts);
+
+    await super[symbols.installWorker](opts);
   }
 
   /** @override */
-  async [symbols.globalTeardown]() {
+  async [symbols.cleanup]() {
+    try {
+      if (this[$worker]) {
+        await this[symbols.uninstallWorker]();
+      }
+    } finally {
+      if (this[_globalLifecycleHandler]) {
+        await this[_globalLifecycleHandler].globalCleanup();
+        this[_globalLifecycleHandler] = null;
+      }
+
+      if (this[_wss]) {
+        await this[_wss].close();
+        this[_wss] = null;
+      }
+
+      if (this[_ipcServer]) {
+        await this[_ipcServer].dispose();
+        this[_ipcServer] = null;
+      }
+
+      await fs.remove(this[$sessionState].detoxConfigSnapshotPath);
+
+      try {
+        this[_lifecycleLogger].trace.end();
+        await this[_finalizeLogs]();
+      } catch (err) {
+        this[_lifecycleLogger].error({ err }, 'Encountered an error while merging the process logs:');
+      }
+    }
+  }
+
+  [_emergencyTeardown] = (_code, signal) => {
+    if (!signal) {
+      return;
+    }
+
     if (this[_globalLifecycleHandler]) {
-      await this[_globalLifecycleHandler].globalCleanup();
+      this[_globalLifecycleHandler].emergencyCleanup();
       this[_globalLifecycleHandler] = null;
     }
 
     if (this[_wss]) {
-      await this[_wss].close();
-      this[_wss] = null;
+      this[_wss].close();
     }
 
     if (this[_ipcServer]) {
-      await this[_ipcServer].dispose();
-      this[_ipcServer] = null;
+      this[_ipcServer].dispose();
     }
 
-    await fs.remove(this[$sessionState].detoxConfigSnapshotPath);
-    delete process.env.DETOX_CONFIG_SNAPSHOT_PATH;
-
     try {
-      this.trace.end({ cat: 'lifecycle' });
-      await this[_finalizeLogs]();
+      this[_lifecycleLogger].trace.end({ abortSignal: signal });
+      this[_finalizeLogsSync]();
     } catch (err) {
-      this[$logger].error({ err }, 'Encountered an error while merging the process logs:');
+      this[symbols.logger].error({ err }, 'Encountered an error while merging the process logs:');
     }
-  }
+  };
+
   //#endregion
 
   //#region Protected members
   /**
    * @protected
    * @override
-   * @return {PrimarySessionState}
+   * @return {SessionState}
    */
   [$restoreSessionState]() {
-    return new PrimarySessionState({
+    return new SessionState({
       detoxConfigSnapshotPath: temporary.for.json(),
       detoxIPCServer: `primary-${process.pid}`,
     });
@@ -176,17 +223,16 @@ class DetoxPrimaryContext extends DetoxContext {
 
   //#region Private members
   async[_finalizeLogs]() {
-    const logs = [this[$logger].file, ...this[$sessionState].logFiles].filter(f => f && fs.existsSync(f));
+    const sessionId = this[$sessionState].id;
+    const logs = await globAsync(temporary.for.jsonl(`${sessionId}.*`));
     if (logs.length === 0) {
       return;
     }
 
-    const streamUtils = require('../utils/streamUtils');
-    const { rootDir, plugins } = this[symbols.config].artifacts || {};
-    const logConfig = plugins && plugins.log || 'none';
-    const enabled = rootDir && (typeof logConfig === 'string' ? logConfig !== 'none' : logConfig.enabled);
+    if (this[_areLogsEnabled]()) {
+      const streamUtils = require('../utils/streamUtils');
+      const { rootDir } = this[symbols.config].artifacts;
 
-    if (enabled) {
       await fs.mkdirp(rootDir);
       const [out1Stream, out2Stream, out3Stream] = ['detox.log.jsonl', 'detox.log', 'detox.trace.json']
         .map((filename) => fs.createWriteStream(path.join(rootDir, filename)));
@@ -198,7 +244,7 @@ class DetoxPrimaryContext extends DetoxContext {
 
       await Promise.all([
         pipe(mergedStream, streamUtils.writeJSONL(), out1Stream),
-        pipe(mergedStream, streamUtils.debugStream(this[$logger].config.options), out2Stream),
+        pipe(mergedStream, streamUtils.debugStream(this[symbols.logger].config.options), out2Stream),
         pipe(mergedStream, streamUtils.chromeTraceStream(), streamUtils.writeJSON(), out3Stream),
       ]);
     }
@@ -206,6 +252,45 @@ class DetoxPrimaryContext extends DetoxContext {
     await Promise.all(logs.map(filepath => fs.remove(filepath)));
   }
 
+  async[_finalizeLogsSync]() {
+    const logsEnabled = this[_areLogsEnabled]();
+
+    const { rootDir } = this[symbols.config].artifacts;
+
+    if (logsEnabled) {
+      fs.mkdirpSync(rootDir);
+    }
+
+    const sessionId = this[$sessionState].id;
+    const logs = globSync(temporary.for.jsonl(`${sessionId}.*`));
+
+    for (const log of logs) {
+      if (logsEnabled) {
+        fs.moveSync(log, path.join(rootDir, path.basename(log)));
+      } else {
+        fs.removeSync(log);
+      }
+    }
+  }
+
+  [_areLogsEnabled]() {
+    const { rootDir, plugins } = this[symbols.config].artifacts || {};
+    if (!rootDir || !plugins) {
+      return false;
+    }
+
+    if (!plugins.log.enabled) {
+      return false;
+    }
+
+    if (!plugins.log.keepOnlyFailedTestsArtifacts) {
+      return true;
+    }
+
+    const { failedTestFiles, testFilesToRetry } = this[$sessionState];
+    return failedTestFiles.length + testFilesToRetry.length > 0;
+  }
+
   async[_resetLockFile]() {
     const DeviceRegistry = require('../devices/DeviceRegistry');
 

package/src/realms/DetoxSecondaryContext.js

@@ -1,12 +1,12 @@
 const fs = require('fs');
 
 const { DetoxInternalError } = require('../errors');
-const { SecondarySessionState } = require('../ipc/state');
+const SessionState = require('../ipc/SessionState');
 const symbols = require('../symbols');
 
 const DetoxContext = require('./DetoxContext');
 
-const { $logger, $restoreSessionState, $sessionState } = DetoxContext.protected;
+const { $restoreSessionState, $sessionState, $worker } = DetoxContext.protected;
 const _ipcClient = Symbol('ipcClient');
 const _shortLifecycle = Symbol('shortLifecycle');
 
@@ -22,6 +22,8 @@ class DetoxSecondaryContext extends DetoxContext {
     /**
      * @private
      * @type {undefined | boolean}
+     *
+     * TODO: explain what is short lifecycle and why we need it
      */
     this[_shortLifecycle] = false;
   }
@@ -40,59 +42,52 @@ class DetoxSecondaryContext extends DetoxContext {
   }
 
   /** @override */
-  async [symbols.globalSetup]() {
+  async [symbols.init](opts = {}) {
     const IPCClient = require('../ipc/IPCClient');
 
     this[_ipcClient] = new IPCClient({
       id: `secondary-${process.pid}`,
       state: this[$sessionState],
-      logger: this[$logger],
+      logger: this[symbols.logger],
     });
 
     await this[_ipcClient].init();
-  }
 
-  /** @override */
-  async [symbols.globalTeardown]() {
-    if (this[_ipcClient]) {
-      await this[_ipcClient].dispose();
-      this[_ipcClient] = null;
+    if (opts.workerId !== null) {
+      await this[symbols.installWorker](opts);
     }
   }
 
   /** @override */
-  async [symbols.setup](opts = {}) {
-    if (!this[_ipcClient]) {
-      this[_shortLifecycle] = true;
-      await this[symbols.globalSetup]();
-    }
-
-    const workerId = opts.workerId || 1;
-    await this[_ipcClient].registerWorker(workerId);
-    await super[symbols.setup](opts);
-  }
-
-  /** @override */
-  async [symbols.teardown]() {
+  async [symbols.cleanup]() {
     try {
-      await super[symbols.teardown]();
+      if (this[$worker]) {
+        await this[symbols.uninstallWorker]();
+      }
     } finally {
-      if (this[_shortLifecycle]) {
-        await this[symbols.globalTeardown]();
+      if (this[_ipcClient]) {
+        await this[_ipcClient].dispose();
+        this[_ipcClient] = null;
       }
     }
   }
+
+  /** @override */
+  async [symbols.installWorker](opts = {}) {
+    const workerId = opts.workerId = opts.workerId || 'worker';
+    await this[_ipcClient].registerWorker(workerId);
+    await super[symbols.installWorker](opts);
+  }
   //#endregion
 
   //#region Protected members
-
   /**
    * @protected
    * @override
-   * @return {SecondarySessionState}
+   * @return {SessionState}
    */
   [$restoreSessionState]() {
-    return SecondarySessionState.parse(fs.readFileSync(process.env.DETOX_CONFIG_SNAPSHOT_PATH));
+    return SessionState.parse(fs.readFileSync(process.env.DETOX_CONFIG_SNAPSHOT_PATH));
   }
   //#endregion
 }

package/src/server/DetoxConnection.js

@@ -1,43 +1,37 @@
-// @ts-nocheck
 const _ = require('lodash');
-const { WebSocket } = require('ws'); // eslint-disable-line @typescript-eslint/no-unused-vars, no-unused-vars
 
 const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
-const logger = require('../utils/logger').child({ __filename, cat: 'ws-server,ws' });
+const logger = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const AnonymousConnectionHandler = require('./handlers/AnonymousConnectionHandler');
 
-const EVENTS = {
-  NEW: { event: 'WSS_CONNECTION' },
-  GET: { event: 'WSS_GET_FROM' },
-  SEND: { event: 'WSS_SEND_TO' },
-  ERROR: { event: 'ERROR' },
-  SOCKET_ERROR: { event: 'WSS_SOCKET_ERROR' },
-};
-
 class DetoxConnection {
   /**
-   * @param {DetoxSessionManager} sessionManager
-   * @param {WebSocket} webSocket
-   * @param {Socket} socket
+   * @param {{
+   *   sessionManager: import('./DetoxSessionManager');
+   *   webSocket: import('ws');
+   *   socket: import('net').Socket;
+   * }} config
    */
   constructor({ sessionManager, webSocket, socket }) {
     this._onMessage = this._onMessage.bind(this);
     this._onError = this._onError.bind(this);
     this._onClose = this._onClose.bind(this);
 
-    this._log = logger.child({ trackingId: socket.remotePort });
+    this._log = logger.child({ id: socket.remotePort });
+    this._log.debug.begin(`connection :${socket.localPort}<->:${socket.remotePort}`);
+
     this._sessionManager = sessionManager;
     this._webSocket = webSocket;
     this._webSocket.on('message', this._onMessage);
     this._webSocket.on('error', this._onError);
     this._webSocket.on('close', this._onClose);
-    this._log.debug(EVENTS.NEW, 'registered a new connection.');
 
-    const log = this._log;
+    // eslint-disable-next-line unicorn/no-this-assignment
+    const self = this;
     this._handler = new AnonymousConnectionHandler({
       api: {
-        get log() { return log; },
+        get log() { return self._log; },
         appendLogDetails: (details) => { this._log = this._log.child(details); },
 
         registerSession: (params) => this._sessionManager.registerSession(this, params),
@@ -49,13 +43,13 @@ class DetoxConnection {
 
   sendAction(action) {
     const messageAsString = JSON.stringify(action);
-    this._log.trace(EVENTS.SEND, messageAsString);
+    this._log.trace({ data: action }, 'send');
     this._webSocket.send(messageAsString + '\n ');
   }
 
   _onMessage(rawData) {
     const data = _.isString(rawData) ? rawData : rawData.toString('utf8');
-    this._log.trace(EVENTS.GET, data);
+    this._log.trace({ data }, 'get');
 
     try {
       let action;
@@ -84,16 +78,17 @@ class DetoxConnection {
         this._handler.onError(handlerError, action);
       }
     } catch (error) {
-      this._log.warn({ ...EVENTS.ERROR }, error instanceof DetoxRuntimeError ? error.message : `${error}`);
+      this._log.warn({ error }, 'Caught unhandled error:');
     }
   }
 
-  _onError(e) {
-    this._log.warn(EVENTS.SOCKET_ERROR, DetoxRuntimeError.format(e));
+  _onError(error) {
+    this._log.warn({ error }, 'Caught socket error:');
   }
 
   _onClose() {
     this._sessionManager.unregisterConnection(this._webSocket);
+    this._log.debug.end();
   }
 }
 

package/src/server/DetoxServer.js

@@ -4,7 +4,7 @@ const WebSocket = require('ws');
 
 const { DetoxInternalError, DetoxRuntimeError } = require('../errors');
 const Deferred = require('../utils/Deferred');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const DetoxSessionManager = require('./DetoxSessionManager');
 
@@ -40,18 +40,16 @@ class DetoxServer {
     await this._startListening();
 
     const level = this._options.standalone ? 'info' : 'debug';
-    log[level]({ event: 'WSS_CREATE' }, `Detox server listening on localhost:${this.port}...`);
+    log[level](`Detox server listening on localhost:${this.port}...`);
   }
 
   async close() {
     try {
       await this._closeWithTimeout(10000);
-      log.debug({ event: 'WSS_CLOSE' }, 'Detox server has been closed gracefully');
-    } catch (e) {
-      log.warn({ event: 'ERROR' },
-        `Detox server has been closed abruptly! See the error details below:\n`
-        + DetoxRuntimeError.format(e) + '\n'
-        + DetoxRuntimeError.reportIssue
+      log.debug('Detox server has been closed gracefully');
+    } catch (err) {
+      log.warn({ err },
+        `Detox server has been closed abruptly! See the error details below:`
       );
     }
   }
@@ -90,8 +88,7 @@ class DetoxServer {
     } else if (this._closing) {
       this._closing.reject(err);
     } else {
-      const formattedError = DetoxRuntimeError.format(err);
-      log.error('Detox server has got an unhandled error:\n' + formattedError);
+      log.error({ err }, 'Detox server has got an unhandled error:');
     }
   }
 

package/src/server/DetoxSession.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const DetoxInternalError = require('../errors/DetoxInternalError');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws-session' });
 
 class DetoxSession {
   /**
@@ -17,7 +17,7 @@ class DetoxSession {
     /** @type {boolean | null} */
     this._pendingTesterStatus = null;
 
-    log.trace({ event: 'SESSION_CREATED' }, `created session ${id}`);
+    log.trace(`created session ${id}`);
   }
 
   get id() {
@@ -120,7 +120,7 @@ class DetoxSession {
   }
 
   _notifyAboutAppConnect() {
-    log.trace({ event: 'SESSION_JOINED' }, `app joined session ${this.id}`);
+    log.trace(`app joined session ${this.id}`);
 
     if (!this._tester) {
       return;
@@ -132,7 +132,7 @@ class DetoxSession {
   }
 
   _notifyAboutAppDisconnect() {
-    log.trace({ event: 'SESSION_TORN' }, `app exited session ${this.id}`);
+    log.trace(`app exited session ${this.id}`);
 
     if (!this._tester) {
       return;
@@ -144,11 +144,11 @@ class DetoxSession {
   }
 
   _notifyAboutTesterConnect() {
-    log.trace({ event: 'SESSION_JOINED' }, `tester joined session ${this.id}`);
+    log.trace(`tester joined session ${this.id}`);
   }
 
   _notifyAboutTesterDisconnect() {
-    log.trace({ event: 'SESSION_TORN' }, `tester exited session ${this.id}`);
+    log.trace(`tester exited session ${this.id}`);
 
     if (!this._app) {
       return;

package/src/server/DetoxSessionManager.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 const DetoxInternalError = require('../errors/DetoxInternalError');
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'ws-server,ws' });
 
 const DetoxConnection = require('./DetoxConnection');
 const DetoxSession = require('./DetoxSession');

package/src/server/handlers/RegisteredConnectionHandler.js

@@ -1,7 +1,6 @@
 // @ts-nocheck
 const { serializeError } = require('serialize-error');
 
-const DetoxError = require('../../errors/DetoxError');
 const DetoxInternalError = require('../../errors/DetoxInternalError');
 
 class RegisteredConnectionHandler {
@@ -41,7 +40,7 @@ class RegisteredConnectionHandler {
         messageId: action && action.messageId,
       });
     } catch (err) {
-      this._api.log.error('Cannot forward the error details to the tester due to the error:\n' + DetoxError.format(err));
+      this._api.log.error({ err }, 'Cannot forward the error details to the tester due to the error:');
       throw error;
     }
   }

package/src/symbols.js

@@ -1,8 +1,11 @@
 /**
  * @type {{
+ *   readonly cleanup: unique symbol;
  *   readonly config: unique symbol;
- *   readonly globalSetup: unique symbol;
- *   readonly globalTeardown: unique symbol;
+ *   readonly getStatus: unique symbol;
+ *   readonly init: unique symbol;
+ *   readonly installWorker: unique symbol;
+ *   readonly logger: unique symbol;
  *   readonly onHookFailure: unique symbol;
  *   readonly onHookStart: unique symbol;
  *   readonly onHookSuccess: unique symbol;
@@ -18,8 +21,7 @@
  *   readonly reportFailedTests: unique symbol;
  *   readonly resolveConfig: unique symbol;
  *   readonly session: unique symbol;
- *   readonly setup: unique symbol;
- *   readonly teardown: unique symbol;
+ *   readonly uninstallWorker: unique symbol;
  *   readonly worker: unique symbol;
  * }}
  */
@@ -44,13 +46,15 @@ module.exports = {
   //#endregion
 
   //#region Main
+  cleanup: Symbol('cleanup'),
   config: Symbol('config'),
-  globalSetup: Symbol('globalSetup'),
-  globalTeardown: Symbol('globalTeardown'),
+  getStatus: Symbol('getStatus'),
+  init: Symbol('init'),
+  installWorker: Symbol('installWorker'),
+  logger: Symbol('logger'),
   resolveConfig: Symbol('resolveConfig'),
   session: Symbol('session'),
-  setup: Symbol('setup'),
-  teardown: Symbol('teardown'),
+  uninstallWorker: Symbol('uninstallWorker'),
   worker: Symbol('worker'),
   //#endregion
 };

package/src/utils/childProcess/exec.js

@@ -3,7 +3,7 @@ const { exec } = require('child-process-promise');
 const _ = require('lodash');
 
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
-const rootLogger = require('../logger').child({ __filename });
+const rootLogger = require('../logger').child({ cat: ['child-process', 'child-process-exec'] });
 const retry = require('../retry');
 
 const execsCounter = require('./opsCounter');

package/src/utils/childProcess/spawn.js

@@ -2,7 +2,7 @@
 const { spawn } = require('child-process-promise');
 const _ = require('lodash');
 
-const rootLogger = require('../logger').child({ __filename });
+const rootLogger = require('../logger').child({ cat: ['child-process', 'child-process-spawn'] });
 const { escape } = require('../pipeCommands');
 const retry = require('../retry');