zircon/system/ulib/fs-test-utils/include/fs-test-utils/perftest.h

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file

#pragma once

#include <stdint.h>
#include <stdio.h>
#include <unistd.h>

#include <fbl/function.h>
#include <fbl/string.h>
#include <fbl/vector.h>
#include <fs-test-utils/fixture.h>
#include <perftest/perftest.h>
#include <unittest/unittest.h>
#include <zircon/errors.h>

namespace fs_test_utils {

// Options that define how a performance test is run.
struct PerformanceTestOptions {
    // Returns options which allow fast execution. No measurements will
    // be recorded.
    static PerformanceTestOptions UnitTest() {
        PerformanceTestOptions options;
        options.result_path = "";
        options.summary_path = "";
        options.sample_count = 1;
        options.print_statistics = false;
        options.is_unittest = true;
        return options;
    }

    static PerformanceTestOptions PerformanceTest() {
        PerformanceTestOptions options = UnitTest();
        options.is_unittest = false;
        return options;
    }

    // Returns true if the current set of options is valid.
    bool IsValid(fbl::String* err) const;

    // Path to output file.
    fbl::String result_path;

    // Path to summary statistics file.
    fbl::String summary_path;

    // Number of times to sample each operation. An operation is either a test or a stage that
    // will be executed multiple times.
    uint32_t sample_count;

    // Whether summary statistics should be printed or not.
    bool print_statistics;

    // True if we are running in unittest mode.
    // Benchmark tests are required to be implemented in such a way, that unittest mode validates
    // that the workflow is correct, and exit quickly.
    bool is_unittest;
};

struct TestInfo {
    // Function that executes the test.
    fbl::Function<bool(perftest::RepeatState*, Fixture*)> test_fn;

    // Name of the test.
    fbl::String name;

    // Estimation of the required disk space for this test. If set to 0, will
    // always be executed (may lead to OOS or OOM(ramdisk) errors.
    // This is optional.
    size_t required_disk_space = 0;
};

struct TestCaseInfo {
    // Ordered list of tests be executed as part of this test case.
    fbl::Vector<TestInfo> tests;

    // TestCase name.
    fbl::String name;

    // Whether there should be teardown between each test. If your tests depend
    // on the leftover state in the underlying FS from previous state, set this to false.
    bool teardown;

    // Number of times to run each test. Will overwrite |PerformanceTestOptions::sample_count|
    // if set and will be ignored if in unittest mode.
    // This is optional.
    uint32_t sample_count = 0;
};

// Returns true if the parsed args should trigger a test run. The usage information is
// written to |out|.
// Note: |performance_test| will be completely overwritten by the data parsed. If caller
// wants to fix a  |performance_test|, it should be done after parsing.
bool ParseCommandLineArgs(int argc, const char* const* argv, FixtureOptions* fixture_options,
                          PerformanceTestOptions* performance_test, FILE* out = stdout);

// Runs all tests in the given testcase.
// Test's status and results will be printed into |out|. Errors will still be logged into
// |stdout|.
bool RunTestCases(const FixtureOptions& fixture_options,
                  const PerformanceTestOptions& performance_test_options,
                  const fbl::Vector<TestCaseInfo>& test_case, FILE* out = stdout);

} // namespace fs_test_utils