it('should add a wallet with pre generated keys', function() {

      let userKeychain;

      // Add the user keychain
      const userKeychainPromise = Q.fcall(function() {
        userKeychain = keychains.create();
        return keychains.add(userKeychain);
      }).then(function(keychain) {
        userKeychainId = keychain.id;
      });

      const backupKeychainPromise = Q.fcall(function() {
        return keychains.createBackup();
      })
      .then(function(newBackupKeychain) {
        backupKeychainId = newBackupKeychain.id;
      });

      const bitgoKeychainPromise = keychains.createBitGo()
      .then(function(keychain) {
        bitgoKeychainId = keychain.id;
      });

      // Add the user keychain
      return Q.all([userKeychainPromise, backupKeychainPromise, bitgoKeychainPromise])
      .then(function() {
        const params = {
          label: 'sample wallet',
          m: 2,
          n: 3,
          keys: [userKeychainId, backupKeychainId, bitgoKeychainId],
          isCold: true
        };
        return wallets.add(params);
      }).then(function(res) {
        res.should.have.property('wallet');
        res.wallet.should.have.property('_wallet');
        res.wallet._wallet.should.have.property('keys');
        res.wallet._wallet.keys[0].should.equal(userKeychainId);
        res.wallet._wallet.keys[1].should.equal(backupKeychainId);
        res.wallet._wallet.keys[2].should.equal(bitgoKeychainId);
        return res.wallet.remove();
      })
      .then(function(removal) {
        removal.deleted.should.equal(true);
      });
    });

 it('Q indirect resolve', (done) => {
   Q.fcall(() => {
     return 1;
   }).then((x) => {
     assert.equal(x, 1, 'one');
   }).then(done, done).done();
 }),

 /**
  * Configure and launch (if applicable) the object's environment.
  * @public
  * @return {q.promise} A promise which will resolve when the environment is
  *     ready to test.
  */
 setupEnv(): q.Promise<any> {
   switch (this.config_.capabilities.browserName) {
     case 'chrome':
       logger.info('Using ChromeDriver directly...');
       break;
     case 'firefox':
       logger.info('Using FirefoxDriver directly...');
       break;
     default:
       throw new BrowserError(
           logger, 'browserName ' + this.config_.capabilities.browserName +
               ' is not supported with directConnect.');
   }
   return q.fcall(function() {});
 }

  constructor(settingsLocation: SettingsLocation, options: SettingsManagerOptions) {
    var logger = options.logger;
    this.logger = logger;
    this.verbose = Boolean(options.verbose);
    this.anchorPath = options.anchorPath;

    this.settingsLocation = settingsLocation;
    this.fileManagers = [];
    this.clusterManagers = [];

    this.initialLoadTimeout = options.initialLoadTimeout || 30000;
    this.appSettings = AppSettings.BLANK;

    switch (settingsLocation.location) {
      case 'transient':
        this.currentWork = Q(null)
          .then(() => {
            return settingsLocation.initAppSettings ? this.reviseSettings(settingsLocation.initAppSettings) : null;
          })
          .catch(e => {
            logger.error(`Fatal settings initialization error: ${e.message}`);
            throw e;
          });
        break;

      case 'local':
        this.currentWork = Q.fcall(() => {
          var appSettingsJS = loadFileSync(settingsLocation.uri, 'yaml');
          appSettingsJS = inlineVars(appSettingsJS, process.env);
          return AppSettings.fromJS(appSettingsJS, { visualizations: MANIFESTS });
        })
          .then((appSettings) => {
            return this.reviseSettings(appSettings);
          })
          .catch(e => {
            logger.error(`Fatal settings load error: ${e.message}`);
            throw e;
          });

        break;

      default:
        throw new Error(`unknown location ${settingsLocation.location}`);
    }

    this.makeMaxTimeCheckTimer();
  }

      function requester({query}) {
        return Q.fcall(() => {
          if (query.queryType === 'status') return { version: '0.8.3' };
          if (query.queryType !== 'segmentMetadata') throw new Error(`what is ${query.queryType}`);
          run++;

          if (run > 1) {
            columns.channel = {
              "type": "STRING",
              "hasMultipleValues": false,
              "size": 0,
              "cardinality": 0,
              "errorMessage": null
            };
          }

          return [{ columns }];
        });
      }

 /**
  * Default update job method.
  * @return a promise
  */
 updateJob(update: any): q.Promise<any> {
   return q.fcall(function() {});
 };

 /**
  * Default setup environment method.
  * @return a promise
  */
 setupEnv(): q.Promise<any> {
   return q.fcall(function() {});
 };

 /**
  * Configure and launch (if applicable) the object's environment.
  * @public
  * @return {q.promise} A promise which will resolve when the environment is
  *     ready to test.
  */
 setupEnv(): q.Promise<any> {
   logger.info('Using the selenium server at ' + this.config_.seleniumAddress);
   return q.fcall(function() {});
 }

  createMySQLGateway(port, (parameters: MySQLParameters, conn: any): void => {
    var { sql, connectionId } = parameters;
    Q.fcall(() => {
      var myContext = context;
      var match: string[];

      // Deal with "SELECT @@blah LIMIT 1" by de-sugaring
      if ((/SELECT\s+@@/i).test(sql)) {
        sql = sql.replace(/@@(?:global\.|session\.)?/g, '');
        myContext = {
          data: getVariablesFlatDataset()
        }
      }

      // Hack, treat USE `blah` as SET ... (ignores it)
      if (match = sql.match(/USE\s+`/i)) {
        sql = "SET NAMES 'utf8'";
      }

      // Handle connection id query
      if (match = sql.match(/SELECT\s+(CONNECTION_ID\(\s*\))/i)) {
        return {
          type: 'connectionId',
          name: match[1]
        }
      }

      try {
        var sqlParse = Expression.parseSQL(sql);
      } catch (e) {
        printError(sql, e);
        return {
          type: 'error',
          code: 1064, // You have an error in your SQL syntax
          message: e.message
        };
      }

      if (!sqlParse.verb) {
        return {
          type: 'error',
          code: 1064,
          message: `Must have a verb`
        };
      }

      switch (sqlParse.verb) {
        case 'SET':
          return {
            type: 'ok'
          };

        case 'SELECT':
          return executeSQLParse(sqlParse, myContext, timezone)
            .then((dataset: PlywoodValue): MySQLResult => {
              if (Dataset.isDataset(dataset)) {
                return {
                  type: 'dataset',
                  dataset,
                  table: sqlParse.table
                };
              } else {
                throw new Error('unexpected result from expression');
              }
            });

        default:
          return {
            type: 'error',
            code: 1337,
            message: `Permission to ${sqlParse.verb} denied`
          };
      }
    })
    .then((result: MySQLResult): any => {
      switch (result.type) {
        case 'ok':
          conn.writeOk();
          break;

        case 'error':
          conn.writeError({ code: result.code, message: result.message });
          break;

        case 'dataset':
          var dataset = result.dataset;
          var plyColumns = dataset.getColumns().map(c => columnToMySQL(c, result.table));
          var plyRows = dataset.flatten().map(row => {
            var newRow: any = {};
            for (var k in row) {
              var v = row[k];

              // Kill ranges
              if (v && v.start) v = v.start;

              if (v && v.toISOString) {
                v = dateToSQL(v);
              } else if (Set.isSet(v)) {
                v = v.toString();
              } else if (typeof v === 'boolean') {
//.........这里部分代码省略.........

 /**
  * Configure and launch (if applicable) the object's environment.
  * @public
  * @return {q.promise} A promise which will resolve immediately.
  */
 protected setupDriverEnv(): q.Promise<any> {
   return q.fcall(function() {});
 }