File: test_util.cc

package info (click to toggle)
chromium 139.0.7258.127-1
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 6,122,068 kB
  • sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (115 lines) | stat: -rw-r--r-- 4,412 bytes parent folder | download | duplicates (6)
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/services/on_device_translation/test/test_util.h"

#include "base/check.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/native_library.h"
#include "base/path_service.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool.h"

namespace on_device_translation {
namespace {

const char kMockLibraryName[] = "mock_translate_kit_lib";
const char kMockInvalidFunctionPointerLibraryName[] =
    "mock_invalid_function_pointer_lib";
const char kMockFailingLibraryName[] = "mock_failing_translate_kit_lib";

}  // namespace

base::FilePath GetMockLibraryPath() {
  base::FilePath exe_path;
  CHECK(base::PathService::Get(base::DIR_EXE, &exe_path));
  return exe_path.AppendASCII(base::GetNativeLibraryName(kMockLibraryName));
}

base::FilePath GetMockInvalidFunctionPointerLibraryPath() {
  base::FilePath exe_path;
  CHECK(base::PathService::Get(base::DIR_EXE, &exe_path));
  return exe_path.AppendASCII(
      base::GetNativeLibraryName(kMockInvalidFunctionPointerLibraryName));
}

base::FilePath GetMockFailingLibraryPath() {
  base::FilePath exe_path;
  CHECK(base::PathService::Get(base::DIR_EXE, &exe_path));
  return exe_path.AppendASCII(
      base::GetNativeLibraryName(kMockFailingLibraryName));
}

// static
std::unique_ptr<FakeFileOperationProxy, base::OnTaskRunnerDeleter>
FakeFileOperationProxy::Create(
    mojo::PendingReceiver<mojom::FileOperationProxy> proxy_receiver,
    const std::vector<TestFile>& files) {
  scoped_refptr<base::SequencedTaskRunner> task_runner =
      base::ThreadPool::CreateSequencedTaskRunner(
          {base::MayBlock(), base::TaskPriority::USER_VISIBLE});
  return std::unique_ptr<FakeFileOperationProxy, base::OnTaskRunnerDeleter>(
      new FakeFileOperationProxy(std::move(proxy_receiver), task_runner, files,
                                 base::PassKey<FakeFileOperationProxy>()),
      base::OnTaskRunnerDeleter(task_runner));
}

FakeFileOperationProxy::FakeFileOperationProxy(
    mojo::PendingReceiver<mojom::FileOperationProxy> proxy_receiver,
    scoped_refptr<base::SequencedTaskRunner> task_runner,
    const std::vector<TestFile>& files,
    base::PassKey<FakeFileOperationProxy>)
    : receiver_(this, std::move(proxy_receiver), task_runner),
      package_dir_(SetupDataDir(files)) {}
FakeFileOperationProxy::~FakeFileOperationProxy() = default;

void FakeFileOperationProxy::FileExists(uint32_t package_index,
                                        const base::FilePath& relative_path,
                                        FileExistsCallback callback) {
  const base::FilePath file_path = GetFilePath(package_index, relative_path);
  if (!base::PathExists(file_path)) {
    // File doesn't exist.
    std::move(callback).Run(/*exists=*/false, /*is_directory=*/false);
    return;
  }
  std::move(callback).Run(
      /*exists=*/true,
      /*is_directory=*/base::DirectoryExists(file_path));
}

void FakeFileOperationProxy::Open(uint32_t package_index,
                                  const base::FilePath& relative_path,
                                  OpenCallback callback) {
  const base::FilePath file_path = GetFilePath(package_index, relative_path);
  std::move(callback).Run(
      file_path.empty() ? base::File()
                        : base::File(file_path, base::File::FLAG_OPEN |
                                                    base::File::FLAG_READ));
}

base::ScopedTempDir SetupDataDir(const std::vector<TestFile>& files) {
  base::ScopedTempDir tmp_dir;
  CHECK(tmp_dir.CreateUniqueTempDir());
  for (const auto& file : files) {
    const auto path =
        tmp_dir.GetPath().Append(base::FilePath::FromASCII(file.relative_path));
    if (!base::DirectoryExists(path.DirName())) {
      CHECK(base::CreateDirectory(path.DirName()));
    }
    CHECK(base::File(path, base::File::FLAG_CREATE | base::File::FLAG_WRITE)
              .WriteAndCheck(0, base::as_byte_span(file.content)));
  }
  return tmp_dir;
}

base::FilePath FakeFileOperationProxy::GetFilePath(
    uint32_t package_index,
    const base::FilePath& relative_path) {
  return package_dir_.GetPath()
      .AppendASCII(base::NumberToString(package_index))
      .Append(relative_path);
}

}  // namespace on_device_translation