chromium/mojo/public/cpp/bindings/tests/validation_test_input_parser.cc

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

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "mojo/public/cpp/bindings/tests/validation_test_input_parser.h"

#include "base/containers/contains.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/raw_ref.h"

#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include <limits>
#include <map>
#include <set>
#include <utility>

#include "mojo/public/c/system/macros.h"

namespace mojo {
namespace test {
namespace {

class ValidationTestInputParser { … };

#define DATA_TYPE(name, data_size, parse_data_func) …

const ValidationTestInputParser::DataType
    ValidationTestInputParser::kDataTypes[] = …;

const size_t ValidationTestInputParser::kDataTypeCount = …;

ValidationTestInputParser::ValidationTestInputParser(const std::string& input,
                                                     std::vector<uint8_t>* data,
                                                     size_t* num_handles,
                                                     std::string* error_message)
    : … { … }

ValidationTestInputParser::~ValidationTestInputParser() { … }

bool ValidationTestInputParser::Run() { … }

bool ValidationTestInputParser::GetNextItem(Range* range) { … }

bool ValidationTestInputParser::ParseItem(const Range& range) { … }

bool ValidationTestInputParser::ParseUnsignedInteger(
    const DataType& type,
    const std::string& value_string) { … }

bool ValidationTestInputParser::ParseSignedInteger(
    const DataType& type,
    const std::string& value_string) { … }

bool ValidationTestInputParser::ParseFloat(const DataType& type,
                                           const std::string& value_string) { … }

bool ValidationTestInputParser::ParseDouble(const DataType& type,
                                            const std::string& value_string) { … }

bool ValidationTestInputParser::ParseBinarySequence(
    const DataType& type,
    const std::string& value_string) { … }

bool ValidationTestInputParser::ParseDistance(const DataType& type,
                                              const std::string& value_string) { … }

bool ValidationTestInputParser::ParseAnchor(const DataType& type,
                                            const std::string& value_string) { … }

bool ValidationTestInputParser::ParseHandles(const DataType& type,
                                             const std::string& value_string) { … }

bool ValidationTestInputParser::StartsWith(const Range& range,
                                           const char* prefix,
                                           size_t prefix_length) { … }

bool ValidationTestInputParser::ConvertToUnsignedInteger(
    const std::string& value_string,
    unsigned long long int* value) { … }

}  // namespace

bool ParseValidationTestInput(const std::string& input,
                              std::vector<uint8_t>* data,
                              size_t* num_handles,
                              std::string* error_message) { … }

}  // namespace test
}  // namespace mojo