import codewars_test as test
# TODO Write tests
import solution # or from solution import example

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test case 0")
    def test_case():
        test.assert_equals(CirclePoint(0), (1,0))
        print(CirclePoint(0))
    #@test.it("rounding")
    #def test_case_1():
    #    test.assert_equals(CirclePoint(3.14), (-1,0))
    #    print(CirclePoint(3.14))

// You can use the Mocha (JavaScript) framework for testing BF.
// TODO: replace with your own tests (TDD), these are just here to demonstrate usage.

describe("Your Test Suite", function () {
  it("should return Hello World!", function () {
    // use runBF() to run your program, you can pass it arguments
    Test.assertEquals(runBF("shen-hong-xin's cat program works properly"), "shen-hong-xin's cat program works properly");
  });
});

const chai = require("chai");
const assert = chai.assert;
chai.config.truncateThreshold = 0;

// const LC = require("LC");
const LC = {compile: ()=>compile(stress), config: Options} // Temporary. Would normally import, see line above.
LC.config.Purity = "LetRec";
LC.config.NumEncoding = "BinaryScott"

const solution = LC.compile(); // Will compile preloaded.txt + '\n' + solution.txt 

// This line does nothing at the moment. Just seeing how it looks.
// The idea is that for "int" and "bool" types, we could implicitely convert
// on input and output, allowing for very *normal* looking equations.
// solution.fibonacci.type = "int -> int -> int"; // Types = int | bool | term ? 
// const fibonacci = solution.fibonacci;

const T = new L('a', new L('b', new V('a')));
const F = new L('a', new L('b', new V('b')));

describe("Sample Tests", function() {
  it("Basics", function() {
    
/* Fib Tests
    assert.deepEqual(fibonacci(7), 13) <- How a basic function might look, with type signature.
    
    Accessing a term does an implicite evalLC call on that term (or returns a term which was already evaluated previously)
    assert.deepEqual(solution.fib(0).toInt(), 0);
    assert.deepEqual(Number(solution.fib(1)), 1);
    assert.deepEqual(solution.fib(2)*1, 1);
    assert.deepEqual(solution.fib(3).toInt(), 2);
    assert.deepEqual(solution.fib(4).toInt(), 3);
    assert.deepEqual(solution.fib(5).toInt(), 5);
    assert.deepEqual(solution.fib(6).toInt(), 8);
    assert.deepEqual(solution.fib(fromInt(25)).toInt(), 75025);
    */
    
    /* Counter tests
    assert.equal(solution.counter(F)(T), 1);
    console.log(solution.counter)
    assert.equal(solution.counter(F)(F)(T), 2);
    console.log(solution.counter)
    
    assert.equal(solution.counter(T), 0);
    assert.equal(solution.counter(F)(T), 1);
    assert.equal(solution.counter(F)(F)(F)(F)(F)(T), 5); // Weird bug, counter seems to be affected by earlier calls?
    assert.equal(solution.counter(T), 0);
    assert.equal(Array(5).fill().reduce(a=>a(F),solution.counter)(T), 5);
    assert.equal(Array(121).fill().reduce(a=>a(F),solution.counter)(T), 121);
*/
    // Stress tests?
    assert.equal(solution.pred(4327), 4326)
    
  });
});

# FactCheck example:
# TODO: replace with your own tests (TDD), these are just how-to examples.
using FactCheck
facts("Testing basics") do
  for _0 = 1:20
    _1 = rand(-1000000:1000000)
    @fact ○(_1) --> _1*π
    @fact ○(1, _1) --> sin(_1)
    @fact ○(2, _1) --> cos(_1)
    @fact ○(3, _1) --> tan(_1)
    if abs(_1) <= 1
      @fact ○(-1, _1) --> asin(_1)
      @fact ○(-2, _1) --> acos(_1)
    else
      @fact ○(-1, _1) --> asin(Complex(round(_1)))
      @fact ○(-2, _1) --> acos(Complex(round(_1)))
    end
    @fact ○(-3, _1) --> atan(_1)
  end
end

# From Ruby 3.0, RSpec is used under the hood.
# See https://rspec.info/
# Defaults to the global `describe` for backwards compatibility, but `RSpec.desribe` works as well.
describe "Basic test" do
  it "should true if edit is one or less" do
    expect(one_away('pale', 'ple')).to eq(true)
    expect(one_away('pales', 'pale')).to eq(true)
    expect(one_away('pale', 'bale')).to eq(true)
    expect(one_away('pale', 'pale')).to eq(true)
    expect(one_away('pale', 'bake')).to eq(false)
  end
end

test.assert_equals(riddle("Two?"), 3)
test.assert_equals(riddle("Ten?"), 3)
test.assert_equals(riddle("Three?"), 5)

import codewars_test as test
from solution import is_happy

# test.assert_equals(actual, expected, [optional] message)
@test.describe("Example")
def test_group():
    @test.it("test case")
    def test_case():
        test.assert_equals(is_happy(3), False)
        test.assert_equals(is_happy(4), False)
        test.assert_equals(is_happy(7), True)
        test.assert_equals(is_happy(19), True)
        test.assert_equals(is_happy(103), True)
        test.assert_equals(is_happy(487), True)
        test.assert_equals(is_happy(1663), True)
        test.assert_equals(is_happy(1665), False)
        test.assert_equals(is_happy(1000000000), True)
        test.assert_equals(is_happy(10000000001), False)
#         test.assert_equals(is_happy(), True)

const chai = require("chai");
const assert = chai.assert;

describe("Solution", function() {
  it("should test for something", function() {
    assert(factorial(5), 120);
    assert(factorial(8),40320);
    assert(factorial(15),1307674368000);
  });
});

const chai = require("chai");
const assert = chai.assert;

describe("Solution", function() {
  it("return index of searching element", function() {
    assert.strictEqual(binarySearch([1, 2, 3, 4, 5, 6, 7], 4), 3);
    assert.strictEqual(binarySearch([1, 2, 3, 4, 5, 6, 7], 2), 1);
    assert.strictEqual(binarySearch([1, 2, 3, 4, 5, 6, 7], 8), -1);
  });
});