Initial project import

tools/v/vlib/x/benchmark/benchmark_test.v

@@ -0,0 +1,169 @@
+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]
+			}
+		}
+	}
+}