export function validateMimeValue(
    type: string,
    value: MultilineString | JSONObject
  ): boolean {
    // Check if "application/json" or "application/foo+json"
    const jsonTest = /^application\/(.*?)+\+json$/;
    const isJSONType = type === 'application/json' || jsonTest.test(type);

    let isString = (x: any) => {
      return Object.prototype.toString.call(x) === '[object String]';
    };

    // If it is an array, make sure if is not a JSON type and it is an
    // array of strings.
    if (Array.isArray(value)) {
      if (isJSONType) {
        return false;
      }
      let valid = true;
      (value as string[]).forEach(v => {
        if (!isString(v)) {
          valid = false;
        }
      });
      return valid;
    }

    // If it is a string, make sure we are not a JSON type.
    if (isString(value)) {
      return !isJSONType;
    }

    // It is not a string, make sure it is a JSON type.
    if (!isJSONType) {
      return false;
    }

    // It is a JSON type, make sure it is a valid JSON object.
    return JSONExt.isObject(value);
  }

  function getOption(name: string): string {
    if (configData) {
      return configData[name] || '';
    }
    configData = Object.create(null);
    let found = false;

    // Use script tag if available.
    if (typeof document !== 'undefined') {
      let el = document.getElementById('jupyter-config-data');
      if (el) {
        configData = JSON.parse(el.textContent || '') as { [key: string]: string };
        found = true;
      }
    }
    // Otherwise use CLI if given.
    if (!found && typeof process !== 'undefined') {
      try {
        let cli = minimist(process.argv.slice(2));
        if ('jupyter-config-data' in cli) {
          let path: any = require('path');
          let fullPath = path.resolve(cli['jupyter-config-data']);
          // Force Webpack to ignore this require.
          configData = eval('require')(fullPath) as { [key: string]: string };
        }
      } catch (e) {
        console.error(e);
      }
    }

    if (!JSONExt.isObject(configData)) {
      configData = Object.create(null);
    } else {
      for (let key in configData) {
        // Quote characters are escaped, unescape them.
        configData[key] = String(configData[key]).split(''').join('"');
      }
    }
    return configData[name] || '';
  }

      compose: plugin => {
        // Only override the canonical schema the first time.
        if (!canonical) {
          canonical = JSONExt.deepCopy(plugin.schema);
          populate(canonical);
        }

        const defaults = canonical.properties.shortcuts.default;
        const user = {
          shortcuts: ((plugin.data && plugin.data.user) || {}).shortcuts || []
        };
        const composite = {
          shortcuts: SettingRegistry.reconcileShortcuts(
            defaults,
            user.shortcuts as ISettingRegistry.IShortcut[]
          )
        };

        plugin.data = { composite, user };

        return plugin;
      },

 manager.runningChanged.connect((sender, args) => {
   expect(sender).to.be(manager);
   expect(JSONExt.deepEqual(toArray(args), data)).to.be(true);
   done();
 });

 it('should get the running sessions', () => {
   let test = JSONExt.deepEqual(toArray(data), toArray(manager.running()));
   expect(test).to.be(true);
 });

 it('should get the value of the object', () => {
   let value = new ObservableValue('value');
   expect(value.get()).to.be('value');
   let value2 = new ObservableValue({ one: 'one', two: 2 });
   expect(JSONExt.deepEqual(value2.get(), { one: 'one', two: 2 })).to.be(true);
 });

 it('should compare two JSON values for deep equality', () => {
   expect(JSONExt.deepEqual([], [])).to.equal(true);
   expect(JSONExt.deepEqual([1], [1])).to.equal(true);
   expect(JSONExt.deepEqual({}, {})).to.equal(true);
   expect(JSONExt.deepEqual({a: []}, {a: []})).to.equal(true);
   expect(JSONExt.deepEqual({a: { b: null }}, {a: { b: null }})).to.equal(true);
   expect(JSONExt.deepEqual({a: '1'}, {a: '1'})).to.equal(true);
   expect(JSONExt.deepEqual({a: { b: null }}, {a: { b: '1' }})).to.equal(false);
   expect(JSONExt.deepEqual({a: []}, {a: [1]})).to.equal(false);
   expect(JSONExt.deepEqual([1], [1, 2])).to.equal(false);
   expect(JSONExt.deepEqual(null, [1, 2])).to.equal(false);
   expect(JSONExt.deepEqual([1], {})).to.equal(false);
   expect(JSONExt.deepEqual([1], [2])).to.equal(false);
   expect(JSONExt.deepEqual({}, { a: 1 })).to.equal(false);
   expect(JSONExt.deepEqual({ b: 1 }, { a: 1 })).to.equal(false);
 });

 }).then((info) => {
   content = info.content;
   expect(JSONExt.deepEqual(content, kernel.info)).to.be(true);
   return kernel.shutdown();
 });