var config0 = Xa( sources.slice(0, 1) );
assert.deepEqual(config0, {a: 1, b: 1, c: 3});
var config01 = Xa( sources.slice(0, 2) );
const view01 = {
  a: 12,
  b: 12,
  c: 3,
  d: 12,
};
assert.deepEqual(config01, view01);
// extend using the config instead of the source - same results
var config01_a = X( config0, sources[1] );
assert.deepEqual(config01_a, view01);
// extend all three
const config012 = Xa(sources);
const merged012 = { a: { m: 1234, n: { p: 7777, q: 9876 } },
  d: { m: { q: 8888 }, n: { p: 7777, q: 9876 } },
  e: 7777,
  b: { m: 1234, n: { p: 7777, q: 9876 } },
  c: 3 };
assert.deepEqual(config012, merged012);
// check a few different combinations of swapping source -> config
const config012_a = X(config0, sources[1], sources[2]);
assert.deepEqual(config012_a, merged012);
const config012_b = X(config01, sources[2]);
assert.deepEqual(config012_b, merged012);

const aggregate = ℂ.private.aggregate;
var t0 = aggregate(null, 7);
assert.equal(t0.length, 1);
assert(t0 instanceof Array);
assert.equal(t0[0], 7);
var t1 = aggregate([9], 8);
assert.equal(t1.length, 2);
assert(t1 instanceof Array);
assert.equal(t1[0], 9);

const aggObjects = ℂ.private.aggObjects;
var t5 = aggObjects({}, objb);
// t5:  { a: [ 21 ], c: [ 23 ], d: [ 24 ] }
assert.equal(Object.keys(t5).length, 3);
assert.equal(t5['a'][0], 21);

const aggAllObjects = ℂ.private.aggAllObjects;
const agg = aggAllObjects(objList);
assert.deepEqual(agg,
  { a: [11, 21, 31],
    b: [12, 32],
    c: [13, 23],
    d: [24, 34],
    e: [35]
  });

const mapping = ℂ.private.mapping;
const m0 = mapping(objList);
assert.deepEqual(m0,
  { a: [11, 21, 31],
    b: [12, 32],
    c: [13, 23],
    d: [24, 34],
    e: [35]
  }
);
const m1 = mapping([{a: 1}]);
assert.deepEqual(m1, {a: [1]});

var flag = false;
const config = X(
  { a: 1,
    b: ℂ(Ɔ=> {
      flag = true;
      return 3;
    }),
  }
);
assert.isNotOk(flag);
assert.equal(config.b, 3);
assert.isOk(flag);

const config = X(
  { a: 1,
    b: ℂ(Ɔ=> function() { return 'ho'; }),
    c: function() { return 'hey'; },
  }
);
assert.instanceOf(config.c, Function);
assert.equal(config.b(), 'ho');
assert.equal(config.c(), 'hey');

const config = X(
  { a: 1,
    b: ℂ(function() { return this.a; }),
  }
);
assert.equal(config.b, 1);

const config = X(
  { a: {
      A: 79,
      B: 67,
    },
    b: ℂ(Ɔ=> ({
      A: 77,
      B: 88,
    })),
  }
);
assert.equal(config.a.A, 79);
assert.equal(config.a.B, 67);
assert.equal(config.b.A, 77);
assert.equal(config.b.B, 88);

const config = X(
  { a: {
      A: 79,
      B: 67,
    },
    b: ℂ(Ɔ=> ({
      A: 77,
      B: ℂ(Ɔ=> Ɔ.a),
    })),
  }
);
assert.deepEqual(config,
  { a: {
      A: 79,
      B: 67,
    },
    b: {
      A: 77,
      B: {
        A: 79,
        B: 67
      }
    }
  }
);

const config = X(
  { a: 42,
    b: ℂ(Ɔ=> ({
      A: 77,
      B: ℂ(Ɔ=> Ɔ.a),
    })),
    c: ℂ(Ɔ=> Ɔ.b.A),
  }
);
assert.equal(config.a, 42);
assert.equal(config.b.A, 77);
assert.equal(config.b.B, 42);
assert.equal(config.c, 77);

const config0 = {
  ver: '1.0.0',
  mdlib: 'markdown-it',
  libs: ℂ(Ɔ=> ({
    mdlib: Ɔ.mdlib,
    jqlib: 'jQuery',
  })),
  cdn: 'https://cdn.org/',
  jqurl: ℂ(Ɔ=> Ɔ.cdn + Ɔ.libs.jqlib + '-' + Ɔ.ver),
};
const config1 = {
  ver: '1.1.0',
  libs: { funclib: 'ramda', },
  clibs: ℂ(Ɔ=> Ɔ.libs),
};
const config = X(config0, config1);
assert.deepEqual(config,
  { ver: '1.1.0',
    mdlib: 'markdown-it',
    libs: {
      mdlib: 'markdown-it',
      jqlib: 'jQuery',
      funclib: 'ramda'
    },
    cdn: 'https://cdn.org/',
    jqurl: 'https://cdn.org/jQuery-1.1.0',
    clibs: {
      mdlib: 'markdown-it',
      jqlib: 'jQuery',
      funclib: 'ramda'
    },
  }
);

var config = X(
  { a: 1,
    b: ℂ(Ɔ=> 5 + Ɔ.a),
  }
);
assert.equal(config.b, 6);

// Symbols for recipe
var [ᗏ, ρ, 食, ᐸ, Ⱉ, ᴙ, ᐧ, ǀ, ᗕ, ᑕ, ᐳ, ᐸ] = R.repeat(ℂ.recipe, 20);
var config = X(
  {
    // One of my favorites, for the looks:
    m: ᗏ(ᑕ=> 3 + ᑕ.a),
    a: 1,
    b: ρ(X=> 3),
    f: 食(X=> 3),
    // Symbols just for their looks
    c: ᐸ(ᐳ=> 3 + ᐳ.a),
    d: Ⱉ(X=> 3 + X.a),
    e: ᴙ(X=> 7),
    g: ᐧ(ǀ=> 9),
    h: ǀ(ᐧ=> 9 + ᐧ.a),
    i: ᗕ(Ⅰ=> 20 + Ⅰ.a),
    j: ᑕ(ǀ=> 3 + ǀ.a),
    // I like these, because the symbols are clean and symmetrical, and
    // the "ᑕ" looks like a capital "C", for "config". But the characters
    // for recipe, "ᐳ" and "ᐸ", look too much like "<" and ">".
    k: ᐳ(ᑕ=> 3 + ᑕ.a),
    n: ᐸ(ᑕ=> 3 + ᑕ.a),
  }
);
assert.equal(config.b, 3);
assert.equal(config.f, 3);
assert.equal(config.c, 4);
assert.equal(config.d, 4);
assert.equal(config.e, 7);
assert.equal(config.g, 9);
assert.equal(config.h, 10);

const seed = ℂ.private.seed;
const clone = ℂ.private.clone;
const seed2 = clone();
// This is a different object
assert.notEqual(seed2, seed);
assert.instanceOf(seed, Function);
assert.strictEqual(seed.private.clone, clone);

const view = ℂ.extend({a: 11});
assert.equal(typeof view, 'object');
assert('__config1__' in view);
assert.equal(view.a, 11);
// I used to have a `view` property in c1; bad idea.
assert(!('view' in ℂ));

const viewb = ℂ.extend({a: 21, b: 22, c: 23});
assert.equal(viewb.a, 21);
assert.equal(viewb.b, 22);
assert.equal(viewb.c, 23);
const viewc = ℂ.extend(
  {a: 31, b: 32, c: 33},
  {a: 35}
);
assert(viewc.a == 35 && viewc.b == 32 && viewc.c == 33);
const viewd = ℂ.extend(obja, objb, objc);
assert.equal(viewb.a, 21);
assert.deepEqual(viewd,
  { a: 31,
    b: 32,
    c: 23,
    d: 34,
    e: 35,
  }
);

const src = {
  a: 1,
  b: {a: 3, c: 2}
};
const view = ℂ.extend(src);
assert.equal(view.a, 1);
assert.equal(view.b.a, 3);
assert.equal(view.b.c, 2);
assert.deepEqual(view, src);

const nested = [
  {
    b: 2,
    c: {
      a: 'cat',
      b: {
        b: 'b',
        d: 'd',
      },
    }
  },
  {
    a: 1,
    b: 9,
    c: {
      b: {
        a: {
          a: 'x',
        },
        b: 'b',
        c: 'wart',
        d: 'freckle',
      },
      c: 'dog',
    }
  },
  {
    a: 1,
    b: 2,
    c: {
      b: {
        a: {
          b: 'y',
          c: 'z',
        },
        d: 'mole',
      },
      x: 'doggy',
    },
    y: 'awesome!',
  },
];
const view = ℂ.extend(...nested);
const exp = {
  a: 1,
  b: 2,
  c: {
    a: 'cat',
    b: {
      a: {
        a: 'x',
        b: 'y',
        c: 'z',
      },
      b: 'b',
      c: 'wart',
      d: 'mole',
    },
    c: 'dog',
    x: 'doggy',
  },
  y: 'awesome!',
};
assert.deepEqual(view, exp);