v/vlib/x/benchmark/benchmark_test.v

module benchmark

import time

// if n == 0, n predict == 1
fn test_predict_n_zero() {
	mut b := Benchmark{
		n:          0
		duration:   0
		bench_time: time.second
		bench_func: fn () ! {}
	}
	expected := 1
	println(b.predict_n())
	assert b.predict_n() == expected
}

// n can't be more 1000000000
fn test_predict_n_limit() {
	mut b := Benchmark{
		n:          10000000000
		duration:   0
		bench_time: time.second
		bench_func: fn () ! {}
	}
	expected := 1000000000
	assert b.predict_n() == expected
}

// test prediction for slow bench function
fn test_slow_fn() {
	mut b := Benchmark{
		duration:   time.second
		bench_func: fn () ! {}
	}
	assert b.predict_n() == 1
}

// if bench_func cause error set failed true, n = 1
fn test_fn_with_error() {
	f := fn () ! {
		return error('error')
	}
	mut bench := setup(f) or {
		eprintln('Error creating benchmark: ${err}')
		return
	}

	bench.run()

	assert bench.failed == true
	assert bench.benchmark_result.n == 1
}

fn test_n_must_be_over_1() {
	f := fn () ! {
		mut i := 0
		i++
	}
	mut bench := setup(f) or {
		eprintln('Error creating benchmark: ${err}')
		return
	}

	bench.run()

	assert bench.benchmark_result.n > 1
}

fn test_n() {
	f := fn () ! {
		mut i := 0
		i++
	}
	mut bench := setup(f, BenchmarkDefaults{
		n: 1000
	}) or {
		eprintln('Error creating benchmark: ${err}')
		return
	}

	bench.run()

	assert bench.benchmark_result.n == 1000
}

fn test_max_bench_time() {
	f := fn () ! {
		time.sleep(500 * time.millisecond)
	}
	mut bench := setup(f) or {
		eprintln('Error creating benchmark: ${err}')
		return
	}

	bench.run()

	assert bench.benchmark_result.n == 3
	assert bench.benchmark_result.t >= time.second
}

fn test_performance() {
	scheduler := [func_1, func_2, func_3]
	expected := [false, false, false]
	mut actual := []bool{}

	for i in scheduler {
		mut bench := setup(i) or {
			eprintln('Error creating benchmark: ${err}')
			return
		}

		bench.run()
		actual << bench.failed
	}

	assert expected.len == actual.len
	for i := 0; i < expected.len; i++ {
		assert expected[i] == actual[i]
	}
}

fn func_1() ! {
	mut arr := []int{}
	appender(mut arr)
	assert arr.len == 10
}

fn appender(mut arr []int) {
	if arr.len == 10 {
		return
	}
	arr << 1
	appender(mut arr)
}

fn func_2() ! {
	target := 2
	arr := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

	mut left := 0
	mut right := arr.len - 1

	for left <= right {
		mid := left + (right - left) / 2
		if arr[mid] == target {
			return
		}
		if arr[mid] < target {
			left = mid + 1
		}
		if arr[mid] > target {
			right = mid - 1
		}
	}
	return
}

fn func_3() ! {
	mut arr := [10, 2, 13, 4, 5, 16, 7, 1, 9, 20]

	for i := 0; i < arr.len - 1; i++ {
		for j := 0; j < arr.len - i - 1; j++ {
			if arr[j] > arr[j + 1] {
				arr[j], arr[j + 1] = arr[j + 1], arr[j]
			}
		}
	}
}