README

[inverse-tax] / tax.test.js

"use strict";

var assert = require('assert');

function test(description, f) {
  f();
}

function rand(limit = 99) {
  return Math.round(Math.random() * limit);
}

function make_random_tax_table() {
  function make_random_table(min_threshold) {
    if (rand(4) == 0) return [];
    const start = min_threshold === undefined ? rand() : min_threshold;
    const end = start + 1 + rand();
    return [[start, rand()]].concat(make_random_table(end));
  }
  return tax_table_from_table(make_random_table());
}

test("parse tax table", () => {
  const parsed = parse_tax_table(' 1  2\n10  4\n');
  assert.strictEqual(parsed.length, 2);
  assert.deepStrictEqual(parsed[0], [1, 10, .02]);
  assert.deepStrictEqual(parsed[1], [10, Infinity, .04]);
});

test("sum", () => {
  assert.strictEqual(sum([]), 0);
  assert.strictEqual(sum([7]), 7);
  assert.strictEqual(sum([100, 1, 10]), 111);
});

test("tax", () => {
  assert.strictEqual(tax([[10, 100, .01], [100, Infinity, .1]], 150), 5.9);
});

test("merge tax tables", () => {
  for (var i = 0; i < 1000; i++) {
    const t1 = make_random_tax_table();
    const t2 = make_random_tax_table();
    const combined = merge_tax_tables(t1, t2);
    for (var j = 0; j < 10; j++) {
      const income = rand(250);
      assert.ok(near(tax(t1, income) + tax(t2, income), tax(combined, income)));
    }
  }
});

test("invert", () => {
  assert.strictEqual(invert([                  ])(10), 10);
  assert.strictEqual(invert([[ 0, Infinity, .1]])( 9), 10);
  assert.strictEqual(invert([[10, Infinity, .1]])(19), 20);
  assert.strictEqual(invert([[10, Infinity, .1]])( 9),  9);
  assert.strictEqual(invert([[0, 100, .1], [100, Infinity, .2]])(170), 200);
  assert.strictEqual(invert([[0, 100, .1], [100, Infinity, .2]])(112), 127.5);
  assert.strictEqual(invert([[6, 90, 0.75], [90, Infinity, 0.12]])(27), 90);

  for (var i = 0; i < 1000; i++) {
    const t = make_random_tax_table();
    const inverted_t = invert(t);
    for (var j = 0; j < 20; j++) {
      const net = rand(250);
      const gross = inverted_t(net);
      assert.ok(near(net, gross - tax(t, gross)));
    }
  }
});