import * as uut from "./genfuns";
 import { fail } from "assert";
 
 describe("matches_specializer", () => {
   test("works in expected cases", () => {
     function AThing() {}
     const an_instance = new AThing();
 
     expect(uut.matches_specializer(an_instance, AThing)).toBeTruthy();
     expect(uut.matches_specializer(an_instance, String)).toBeFalsy();
     expect(uut.matches_specializer(an_instance, Object)).toBeTruthy();
 
     expect(uut.matches_specializer([], Array)).toBeTruthy();
     expect(uut.matches_specializer([], Object)).toBeTruthy();
     expect(uut.matches_specializer([], Number)).toBeFalsy();
 
     function Foo() {}
     Foo.prototype = Object.create(null);
     const inst = new Foo();
     expect(uut.matches_specializer(inst, Foo)).toBeTruthy();
     expect(uut.matches_specializer(inst, Object)).toBeFalsy();
 
     expect(uut.matches_specializer({ a: 1 }, uut.Shape("a"))).toBeTruthy();
     expect(
       uut.matches_specializer({ a: 1, b: 2 }, uut.Shape("a"))
     ).toBeTruthy();
     expect(uut.matches_specializer({ b: 2 }, uut.Shape("a"))).toBeFalsy();
 
     expect(
       uut.matches_specializer({ a: 1, b: 2, c: 3 }, uut.Shape("a", "b", "c"))
     ).toBeTruthy();
     expect(
       uut.matches_specializer(
         { a: 1, b: 2, c: 3, d: 4 },
         uut.Shape("a", "b", "c")
       )
     ).toBeTruthy();
     expect(
       uut.matches_specializer({ a: 1, c: 3 }, uut.Shape("a", "b", "c"))
     ).toBeFalsy();
     expect(
       uut.matches_specializer({ c: 3 }, uut.Shape("a", "b", "c"))
     ).toBeFalsy();
     expect(
       uut.matches_specializer({ d: 3 }, uut.Shape("a", "b", "c"))
     ).toBeFalsy();
   });
 
   test("null behavior", () => {
     expect(uut.matches_specializer(null, null)).toBeTruthy();
     expect(uut.matches_specializer(null, Number)).toBeFalsy();
     expect(uut.matches_specializer(null, String)).toBeFalsy();
     expect(uut.matches_specializer(null, Object)).toBeFalsy();
   });
 
   test("undefined (the value) behavior", () => {
     expect(uut.matches_specializer(undefined, undefined)).toBeTruthy();
     expect(uut.matches_specializer(undefined, Number)).toBeFalsy();
     expect(uut.matches_specializer(undefined, String)).toBeFalsy();
     expect(uut.matches_specializer(undefined, Object)).toBeFalsy();
   });
 
   test("works for numbers", () => {
     expect(uut.matches_specializer(new Number(1), Number)).toBeTruthy();
     expect(uut.matches_specializer(new Number(1), Object)).toBeTruthy();
     expect(uut.matches_specializer(new Number(1), String)).toBeFalsy();
 
     expect(uut.matches_specializer(1, Number)).toBeTruthy();
     expect(uut.matches_specializer(1, Object)).toBeTruthy();
     expect(uut.matches_specializer(1, String)).toBeFalsy();
   });
 
   test("handles strings", () => {
     expect(uut.matches_specializer(new String("foobar"), String)).toBeTruthy();
     expect(uut.matches_specializer(new String("foobar"), Object)).toBeTruthy();
 
     expect(uut.matches_specializer("1", String)).toBeTruthy();
     expect(uut.matches_specializer("1", Object)).toBeTruthy();
     expect(uut.matches_specializer("1", Number)).toBeFalsy();
   });

 });
 

 describe("defgeneric", () => {
   test("methods get called appropriately", () => {
     expect(
       uut
         .defgeneric("testing1", "a", "b")
         .primary([Object, Object], (_, __) => 1)
         .fn(1, 2)
     ).toEqual(1);
 
     try {
       uut
         .defgeneric("foobar", "a")
         .primary([String], function (a) {})
         .fn({});
       fail();
     } catch (err) {
       expect(err).toBeInstanceOf(uut.NoApplicableMethodError);
     }
 
     expect(
       uut
         .defgeneric("testing1", "a", "b")
         .primary([Number, Number], (_, __) => 1)
         .fn(1, 2)
     ).toEqual(1);
 
     expect(
       uut
         .defgeneric("testing1", "a", "b")
         .primary([Number, Number], (_, __) => 2)
         .primary([String, String], (_, __) => 1)
         .fn("1", "2")
     ).toEqual(1);
 
     let firstCounts = 0;
     expect(
       uut
         .defgeneric("testing1", "a", "b")
         .primary([Number, Number], (_, __) => (firstCounts += 1))
         .primary([String, String], (_, __) => (firstCounts += 1))
         .fn("1", "2")
     ).toEqual(1);
     expect(firstCounts).toEqual(1);
 
     let secondCounts = 0;
     expect(
       uut
         .defgeneric("testing1", "a", "b")
         .primary([Object, Object], (_, __) => (secondCounts += 1))
         .primary([String, String], (_, __) => (secondCounts += 1))
         .fn("1", "2")
     ).toEqual(1);
     expect(secondCounts).toEqual(1);
 
     let thirdCounts = 0;
     expect(
       uut
         .defgeneric("testing1", "a", "b")
         .before([Object, Object], (_, __) => (thirdCounts += 1))
         .primary([String, String], (_, __) => "hi")
         .after([Object, String], (_, __) => (thirdCounts += 1))
         .fn("1", "2")
     ).toEqual("hi");
     expect(thirdCounts).toEqual(2);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([Object], function (a) {
           return 1;
         })
         .primary([String], function (a) {
           return 2;
         })
         .fn("foobar")
     ).toEqual(2);
   });
 
   test("next-method-p works", () => {
     expect.assertions(3);
 
     uut
       .defgeneric("foobar", "a")
       .primary([Object], function (a) {
         expect(this.next_method_p).toBe(false);
       })
       .fn({});
 
     uut
       .defgeneric("foobar", "a")
       .primary([Object], function (a) {
         expect(this.next_method_p).toBe(false);
       })
       .primary([String], function (a) {
         expect(this.next_method_p).toBe(true);
       })
       .fn("foobar");
 
     uut
       .defgeneric("foobar", "a")
       .primary([Object], function (a) {
         expect(this.next_method_p).toBe(false);
       })
       .primary([String], function (a) {
         expect(this.next_method_p).toBe(true);
       })
       .fn(1);
   });
 
   test("call-next-method works", () => {
     try {
       uut
         .defgeneric("foobar", "a")
         .primary([Object], function (a) {
           this.call_next_method();
         })
         .primary([String], function (a) {
           return 1;
         })
         .fn({});
       fail();
     } catch (err) {
       expect(err).toBeInstanceOf(uut.NoNextMethodError);
     }
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([Object], function (a) {
           return 1;
         })
         .primary([String], function (a) {
           return this.call_next_method();
         })
         .fn("foobar")
     ).toEqual(1);
 
     expect(
       uut
         .defgeneric("foobar", "a", "b")
         .primary([String, String], function (a, b) {
           return `1${this.call_next_method()}`;
         })
         .primary([Object, String], function (a, b) {
           return `3${this.call_next_method()}`;
         })
         .primary([String, Object], function (a, b) {
           return `2${this.call_next_method()}`;
         })
         .primary([Object, Object], function (a, b) {
           return `4`;
         })
         .fn("a", "b")
     ).toEqual("1234");
 
     try {
       uut
         .defgeneric("foobar", "a")
         .primary([Object], function (a) {
           this.call_next_method();
         })
         .fn({});
       fail();
     } catch (err) {
       expect(err).toBeInstanceOf(uut.NoNextMethodError);
     }
   });

 });
 

 describe("custom specializers", () => {
   test("Shape works", () => {
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape("a", "b")], ({ a, b }) => a + b)
         .primary([Object], _ => null)
         .fn({ a: 1, b: 2 })
     ).toEqual(3);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape("a", "b")], ({ a, b }) => a + b)
         .primary([Object], _ => null)
         .fn({ a: 1, b: 2, c: 3 })
     ).toEqual(3);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape("a", "b")], ({ a, b }) => a + b)
         .primary([Object], _ => null)
         .fn({ a: 1 })
     ).toEqual(null);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape(["a", 1], "b")], ({ a, b }) => a + b)
         .primary([Object], _ => null)
         .fn({ a: 1, b: 3 })
     ).toEqual(4);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape(["a", null], "b")], ({ a, b }) => b)
         .primary([Object], _ => null)
         .fn({ a: null, b: 3 })
     ).toEqual(3);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape(["a", undefined], "b")], ({ a, b }) => b)
         .primary([Object], _ => null)
         .fn({ b: 5 })
     ).toEqual(null); //undefined is not a permissible default: treated as if the key is missing
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape(["a", 1], "b")], ({ a, b }) => a + b)
         .primary([Object], _ => null)
         .fn({ a: 2, b: 3 })
     ).toEqual(null);
   });
 
   test("Shape, prototype precedence", () => {
     expect(
       uut
         .defgeneric("foobar4", "a")
         .primary([uut.Shape("a")], ({ a }) => a)
         .primary([uut.Shape("a", "b")], ({ a, b }) => {
           return a + b;
         })
         .primary([Object], _ => null)
         .fn({ a: 1, b: 3 })
     ).toEqual(4);
 
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape("a", "b")], ({ a, b }) => a + b)
         .primary([uut.Shape("b")], ({ b }) => b)
         .primary([Object], _ => null)
         .fn({ a: 1, b: 2 })
     ).toEqual(3);
 
     const Foo = function () {};
     Foo.prototype = { a: true, b: null };
     expect(
       uut
         .defgeneric("foobar", "a")
         .primary([uut.Shape("a")], function ({ a }) {
           return `a${this.call_next_method()}`;
         })
         .primary([uut.Shape("a", "b", "c")], function ({ a, b, c }) {
           return `c${this.call_next_method()}`;
         })
         .primary([uut.Shape("a", "b")], function ({ a, b }) {
           return `b${this.call_next_method()}`;
         })
         .primary([Object], _ => "d")
         .fn(Object.assign(new Foo(), { c: 3 }))
     ).toEqual("cbad");
   });

 });

 describe("Shape", () => {

   test("super_of", () => {
     expect(uut.Shape().super_of(uut.Shape("a", "b", "c"))).toBeTruthy();
     expect(uut.Shape("a").super_of(uut.Shape("a", "b"))).toBeTruthy();
     expect(uut.Shape("a", "b").super_of(uut.Shape("a", "b", "c"))).toBeTruthy();
     expect(uut.Shape("a", "b").super_of(uut.Shape("a", "b", 3))).toBeTruthy();
     expect(uut.Shape("a", "b").super_of(uut.Shape("a", "b"))).toBeFalsy();
     expect(uut.Shape("a", "b").super_of(uut.Shape("a"))).toBeFalsy();
   });

 });