describe('datapoint processing', () => {
    let waterrower;

    beforeEach(done => {
      waterrower = new WaterRower();
      waterrower.setupStreams();
      done();
    })

    it('treats distance as a hexadecimal integer', done => {
      waterrower.once('data', point => {
        assert.equal(point.name, 'distance');
        assert.equal(point.value, 7350);
        done();
      });
      waterrower.reads$.next({ time: 1468559128188, type: 'datapoint', data: 'IDD0571CB6\r'});
    });

    it('treats display minutes as a decimal integer', done => {
      waterrower.once('data', point => {
        assert.equal(point.name, 'display_min');
        assert.equal(point.value, 28);
        done();
      });
      waterrower.reads$.next({ time: 1468559128188, type: 'datapoint', data: 'IDS1E228\r'});
    });
  });

describeModule('name', function() {
    beforeEach(function() {
    });

    it('test', function() {
    });
});

describe(relative(__filename), () =>
{
	let currentTest: ITest;

	beforeEach(function ()
	{
		currentTest = this.currentTest as ITest;

		//console.log('it:before', currentTest.title);
		//console.log('it:before', currentTest.fullTitle());
	});

	// @ts-ignore
	describe(`custom merge`, () =>
	{
		it('custom merge array', function(done) {
			var mergeFunctionCalled = false
			function overwriteMerge(target, source, options) {
				mergeFunctionCalled = true
				assert.equal(options.arrayMerge, overwriteMerge)

				return source
			}
			const destination = {
				someArray: [ 1, 2 ],
				someObject: { what: 'yes' },
			}
			const source = {
				someArray: [ 1, 2, 3 ],
			}

			const actual = merge(destination, source, { arrayMerge: overwriteMerge })
			const expected = {
				someArray: [ 1, 2, 3 ],
				someObject: { what: 'yes' },
			}

			assert.ok(mergeFunctionCalled)
			assert.deepEqual(actual, expected)
			done()
		})

		it('merge top-level arrays', function(done) {
			function overwriteMerge(a, b) {
				return b
			}
			var actual = merge([ 1, 2 ], [ 1, 2 ], { arrayMerge: overwriteMerge })
			var expected = [ 1, 2 ]

			assert.deepEqual(actual, expected)
			done()
		})

	});
});

    describe('request', function() {
      beforeEach(function() {
        this.server.get('/users/1', () => jsonResponse(200, { name: 'Alex' }));
      });

      it('works without the generic defined', async function() {
        const ajax = new AjaxRequest();
        const response = await ajax.request('/users/1');

        expect(response).to.deep.equal({ name: 'Alex' });
      });

      it('can provide a generic type to resolve to', async function() {
        const ajax = new AjaxRequest();
        const response = await ajax.request<User>('/users/1');

        expect(response).to.deep.equal({ name: 'Alex' });
      });
    });

describe("Environment operations", () => {
  let context: Context;
  let context2: Context;

  beforeEach(() => {
    context = consoleLoggingMetaesContext();
    context2 = consoleLoggingMetaesContext();
  });

  it("should properly serialize/deserialize primitive values in enviromnent", () => {
    const primitiveValues = { foo: "bar", a: 1, b: false };
    assert.deepEqual(environmentToMessage(context, { values: primitiveValues }), { values: primitiveValues });
  });

  it("should properly serialize/deserialize object values in enviromnent", () => {
    function fn() {}
    const obj = { fn };
    const env: Environment = { values: { fn, obj } };
    const json = environmentToMessage(context, env);
    const envBack = environmentFromMessage(context, json);
    assert.deepEqual(env, envBack);
  });

  it("should properly serialize/deserialize object values in enviromnent with multiple contexts", () => {
    [context, context2].forEach(context => {
      function fn() {}
      const obj = { fn };
      const env: Environment = { values: { fn, obj } };
      const json = environmentToMessage(context, env);
      assert.equal(getReferencesMap(context).size, 2);
      const envBack = environmentFromMessage(context, json);
      assert.deepEqual(env, envBack);
      assert.equal(getReferencesMap(context).size, 2);
    });
  });

  it("should properly add values to existing environment", () => {
    const env = { values: { a: 1 } };
    const env2 = mergeValues({ b: 2 }, env);

    assert.equal(env2.values["a"], 1);
  });
});

describe("Evaluation", () => {
  let context: Context;
  beforeEach(() => {
    context = new MetaesContext();
  });
  it("success continuation should be called", () => new Promise(resolve => context.evaluate("2", resolve)));

  it("error continuation should be called", () => new Promise(resolve => context.evaluate("throw 1;", null, resolve)));

  it("should not throw in current callstack", () => {
    expect(() => context.evaluate("throw 1;")).to.not.throw();
  });

  it("should correctly execute scripting context", async () => {
    assert.equal(await evalFunctionBodyAsPromise({ context, source: a => a * 2 }, { values: { a: 1 } }), 2);
  });

  it("should correctly execute cooperatively", async () => {
    [1, 2, 3, 4, 5, 6].forEach(async i =>
      assert.equal(await evalFunctionBodyAsPromise({ context, source: a => a * 2 }, { values: { a: i } }), i * 2)
    );
  });
});

describe("Example Proxy implementation", async () => {
  type Handler = {
    get?(target, name): any;
    set?(obj, prop, value): Boolean;
  };
  class Proxy {
    constructor(public target: any, public handler: Handler) {}
  }

  let interpreters = {
    values: {
      GetProperty({ object, property }, c) {
        if (object instanceof Proxy && object.handler.get) {
          c(object.handler.get(object.target, property));
        } else {
          GetProperty.apply(null, arguments);
        }
      },
      SetProperty({ object, property, value }, c, cerr) {
        if (object instanceof Proxy && object.handler.set) {
          try {
            c(object.handler.set(object.target, property, value));
          } catch (e) {
            cerr(e);
          }
        } else {
          SetProperty.apply(null, arguments);
        }
      }
    },
    prev: ECMAScriptInterpreters
  };

  const ERROR_MESSAGE = "Can't write to proxied object";
  let context: MetaesContext;

  beforeEach(() => {
    let value = { a: 1, b: 2 };
    let proxied = new Proxy(value, {
      get(object, property) {
        return object[property] + "mln";
      },
      set() {
        throw new Error(ERROR_MESSAGE);
      }
    });
    let self = { value, proxied };
    context = new MetaesContext(undefined, undefined, { values: { self, console } }, { interpreters });
  });

  it("should support standard get operations", async () => {
    assert.deepEqual(await evalFunctionBodyAsPromise({ context, source: self => [self.value.a, self.value.b] }), [
      1,
      2
    ]);
  });

  it("should support custom get operations", async () => {
    assert.deepEqual(await evalFunctionBodyAsPromise({ context, source: self => [self.proxied.a, self.proxied.b] }), [
      "1mln",
      "2mln"
    ]);
  });

  it("should support custom set operations", async () => {
    try {
      await context.evalFunctionBody(self => {
        self.proxied.a = "a new value";
      });
    } catch (e) {
      assert.equal(e.value.message, ERROR_MESSAGE);
    }
  });
});