package kata_test
import (
  . "github.com/onsi/ginkgo"
  . "github.com/onsi/gomega"
  . "codewarrior/kata"
)

func dotest(a string, b string, expected bool) {
  actual := SumLetters(a, b)

  Expect(actual).To(Equal(expected))
}

var _ = Describe("Tests", func() {
  It("Example 1", func() {
   dotest("Sebastian", "Patricia", false)
  })
  It("Example 2", func() {
   dotest("Anna", "Nana", true)
  })
  It("Example 3", func() {
   dotest("John", "", false)
  })
  It("Example 4", func() {
   dotest("", "", false)
  })    
})

describe "basic tests" do
  specify { expect(riddle("Two?")).to eq(3) }
  specify { expect(riddle("Ten?")).to eq(3) }
  specify { expect(riddle("Three?")).to eq(5) }
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.
require 'benchmark'

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)
    expect(one_away('ale', 'pale')).to eq(true)
    expect(one_away('ale', 'pales')).to eq(false)
  end
end

describe "Benchmarks" do
  let(:pairs) do 
    pairs = []
    ALPHABET = ('a'..'z').to_a

    10000.times do
      string = Array.new(500) { ALPHABET.sample }.join
      modified = string.dup

      while rand < 0.5 # 50% chance to modify single letter in a random location
        modified[rand(25)] = ALPHABET.sample
      end

      while rand < 0.1 # 10% chance to drop a letter at a random location
        modified.slice!(rand(modified.size))
      end

      pairs << [string, modified]
    end
    
    pairs
  end

  it 'is fast!' do
    Benchmark.bmbm do |x|
      x.report do pairs.each { |pair| solution1(*pair)    } end # Eileenandrea
      x.report do pairs.each { |pair| solution1mod(*pair) } end # Eileenandrea, much faster to check a == b up front
      x.report do pairs.each { |pair| solution2(*pair)    } end # 深紅心
      x.report do pairs.each { |pair| solution2mod(*pair) } end # 深紅心, much faster to check a == b up front
      x.report do pairs.each { |pair| solution3(*pair)    } end # pawptart
      x.report do pairs.each { |pair| one_away(*pair)     } end # pawptart
    end
  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.
require 'benchmark'

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)
    expect(one_away('ale', 'pale')).to eq(true)
    expect(one_away('ale', 'pales')).to eq(false)
  end
end

describe "Benchmarks" do
  let(:pairs) do 
    pairs = []
    ALPHABET = ('a'..'z').to_a

    10000.times do
      string = Array.new(500) { ALPHABET.sample }.join
      modified = string.dup

      while rand < 0.5 # 50% chance to modify single letter in a random location
        modified[rand(25)] = ALPHABET.sample
      end

      while rand < 0.1 # 10% chance to drop a letter at a random location
        modified.slice!(rand(modified.size))
      end

      pairs << [string, modified]
    end
    
    pairs
  end

  it 'is fast!' do
    Benchmark.bmbm do |x|
      x.report do pairs.each { |pair| solution1(*pair)    } end # Eileenandrea
      x.report do pairs.each { |pair| solution2(*pair)    } end # 深紅心
      x.report do pairs.each { |pair| solution2mod(*pair) } end # 深紅心, much faster to check a == b up front
      x.report do pairs.each { |pair| one_away(*pair)     } end # pawptart
    end
  end
end

import codewars_test as test
import random

@test.describe("Simple tests")
def test_group():
    @test.it("Test 1")
    def test_case1():
        test.assert_equals(minimal_square(2, 3), 16)
    @test.it("Test 2")
    def test_case2():
        test.assert_equals(minimal_square(3, 7), 49)
    @test.it("Test 3")
    def test_case3():
        test.assert_equals(minimal_square(4, 10), 100)
@test.describe("Edge cases")
def test_group():
    @test.it("Impossible rectangle")
    def impossible_case():
        test.assert_equals(minimal_square(0, 0), 0)
    @test.it("Rectangle is a square")
    def square_case():
        test.assert_equals(minimal_square(1, 1), 4)
@test.describe("Random cases")
def test_group():
    for x in range(1, 101):
        a = random.randint(1, 100)
        b = random.randint(1, 100)
        test.assert_equals(minimal_square(a,b), solution(a,b))

from random import randint, choice

Test.describe("Basic Tests")
Test.assert_equals(calculator(2, "-", 2), 0)
Test.assert_equals(calculator(5, "+", 5), 10)
Test.assert_equals(calculator(10, "-", 20), -10)
Test.assert_equals(calculator(1, "=", 1), "Not a valid operation")

Test.describe("Complex Test")
Test.assert_equals(calculator(-10, "/", -5), 2.0)
Test.assert_equals(calculator(100, "*", 0), 0)

Test.describe("Random Test")
for x in range(150):
    a = randint(-10000, 10000)
    b = randint(-10000, 10000)
    operator = choice(["+", "-", "*", "/", "="])
    operations = {"+": lambda x, y: x + y, "-": lambda x, y: x - y,
    "*": lambda x, y: x * y, "/": lambda x, y: x / y,
    "=": lambda x, y: "Not a valid operation"}
    Test.assert_equals(calculator(a, operator, b), operations[operator](a, b))