1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91


gpu / config / gpu_test_expectations_parser.h [blame]

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_
#define GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_

#include <stddef.h>
#include <stdint.h>

#include <string>
#include <vector>

#include "base/files/file_path.h"
#include "gpu/config/gpu_test_config.h"
#include "gpu/gpu_export.h"

namespace gpu {

class GPU_EXPORT GPUTestExpectationsParser {
 public:
  enum GPUTestExpectation {
    kGpuTestPass = 1 << 0,
    kGpuTestFail = 1 << 1,
    kGpuTestFlaky = 1 << 2,
    kGpuTestTimeout = 1 << 3,
    kGpuTestSkip = 1 << 4,
  };

  GPUTestExpectationsParser();
  ~GPUTestExpectationsParser();

  // Parse the text expectations, and if no error is encountered,
  // save all the entries. Otherwise, generate error messages.
  // Return true if parsing succeeds.
  bool LoadTestExpectations(const std::string& data);
  bool LoadTestExpectations(const base::FilePath& path);

  // Query error messages from the last LoadTestExpectations() call.
  const std::vector<std::string>& GetErrorMessages() const;

  // Get the test expectation of a given test on a given bot.
  int32_t GetTestExpectation(const std::string& test_name,
                             const GPUTestBotConfig& bot_config) const;

  // Parse a list of config modifiers. If we have a valid entry with no
  // conflicts, | config | stores it, and the function returns true.
  bool ParseConfig(const std::string& config_data, GPUTestConfig* config);

 private:
  struct GPUTestExpectationEntry {
    GPUTestExpectationEntry();

    std::string test_name;
    GPUTestConfig test_config;
    int32_t test_expectation;
    size_t line_number;
  };

  // Parse a line of text. If we have a valid entry, save it; otherwise,
  // generate error messages.
  bool ParseLine(const std::string& line_data, size_t line_number);

  // Update OS/GPUVendor/BuildType modifiers. May generate an error message.
  bool UpdateTestConfig(GPUTestConfig* config,
                        int32_t token,
                        size_t line_number);

  // Update GPUDeviceID modifier. May generate an error message.
  bool UpdateTestConfig(GPUTestConfig* config,
                        const std::string & gpu_device_id,
                        size_t line_number);

  // Check if two entries' config overlap with each other. May generate an
  // error message.
  bool DetectConflictsBetweenEntries();

  // Save an error message, which can be queried later.
  void PushErrorMessage(const std::string& message, size_t line_number);
  void PushErrorMessage(const std::string& message,
                        size_t entry1_line_number,
                        size_t entry2_line_number);

  std::vector<GPUTestExpectationEntry> entries_;
  std::vector<std::string> error_messages_;
};

}  // namespace gpu

#endif  // GPU_CONFIG_GPU_TEST_EXPECTATIONS_PARSER_H_