experiments/STT-tensorflow
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #35287 from kiszk:spelling_tweaks_tf

Browse Source 
PiperOrigin-RevId: 290650352
Change-Id: I7035782c1c55848bb71460964874aa89a3c85454
This commit is contained in:
TensorFlower Gardener 2020-01-20 14:45:04 -08:00
commit f04ae382e8
86 changed files with 387 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tensorflow/c/eager/c_api.cc
View File

@ -516,7 +516,7 @@ tensorflow::Status UpdateTFE_ContextWithServerDef(
grpc_server->worker_env()->device_mgr->ListDeviceAttributes(
&local_device_attributes);
// This request make sure that we can create Rendevzous properly between
// This request make sure that we can create Rendezvous properly between
// Local and Remote context.
tensorflow::eager::CreateContextRequest base_request;
for (const auto& da : cluster_device_attributes) {

2
tensorflow/c/eager/c_api.h
View File

@ -213,7 +213,7 @@ TF_CAPI_EXPORT extern void TFE_DeleteTensorDebugInfo(
TFE_TensorDebugInfo* debug_info);
// Returns the number of dimensions used to represent the tensor on its device.
// The number of dimensions used to reprensent the tensor on device can be
// The number of dimensions used to represent the tensor on device can be
// different from the number returned by TFE_TensorHandleNumDims.
// The return value was current at the time of TFE_TensorDebugInfo creation.
TF_CAPI_EXPORT extern int TFE_TensorDebugInfoOnDeviceNumDims(

2
tensorflow/c/eager/tape.h
View File

@ -284,7 +284,7 @@ class ForwardAccumulator {
// Temporarily push or pop transient state for this accumulator.
//
// Allows an accumulator which is currently processing an operation to
// temporarily reset its state. Without pushing and poping, accumulators
// temporarily reset its state. Without pushing and popping, accumulators
// ignore operations executed as a direct result of their own jvp
// computations.
void PushState() { call_state_.emplace(nullptr, false); }

2
tensorflow/c/experimental/filesystem/filesystem_interface.h
View File

@ -529,7 +529,7 @@ typedef struct TF_FilesystemOps {
/// If `statuses` is not null, plugins must fill each element with detailed
/// status for each file, as if calling `path_exists` on each one. Core
/// TensorFlow initializes the `statuses` array and plugins must use
/// `TF_SetStatus` to set each element instead of dirrectly assigning.
/// `TF_SetStatus` to set each element instead of directly assigning.
///
/// DEFAULT IMPLEMENTATION: Checks existence of every file. Needs
/// `path_exists`.

2
tensorflow/c/experimental/filesystem/modular_filesystem.h
View File

@ -32,7 +32,7 @@ namespace tensorflow {
// TODO(b/143949615): After all filesystems are converted, this file will be
// moved to core/platform, and this class can become a singleton and replace the
// need for `Env::Default()`. At that time, we might decide to remove the need
// for `Env::Default()` altoghether, but that's a different project, not in
// for `Env::Default()` altogether, but that's a different project, not in
// scope for now. I'm just mentioning this here as that transition will mean
// removal of the registration part from `Env` and adding it here instead: we
// will need tables to hold for each scheme the function tables that implement

226
tensorflow/c/experimental/filesystem/modular_filesystem_test.cc
View File

@ -144,7 +144,7 @@ int ModularFileSystemTest::rng_val_;
// As some of the implementations might be missing, the tests should still pass
// if the returned `Status` signals the unimplemented state.
bool UninmplementedOrReturnsCode(Status actual_status, Code expected_code) {
bool UnimplementedOrReturnsCode(Status actual_status, Code expected_code) {
Code actual_code = actual_status.code();
return (actual_code == Code::UNIMPLEMENTED) || (actual_code == expected_code);
}
@ -191,14 +191,14 @@ TEST_P(ModularFileSystemTest, TestCreateFile) {
const std::string filepath = GetURIForPath("a_file");
std::unique_ptr<WritableFile> new_file;
Status status = env_->NewWritableFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestCreateFileNonExisting) {
const std::string filepath = GetURIForPath("dir_not_found/a_file");
std::unique_ptr<WritableFile> new_file;
Status status = env_->NewWritableFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestCreateFileExistingDir) {
@ -208,7 +208,7 @@ TEST_P(ModularFileSystemTest, TestCreateFileExistingDir) {
std::unique_ptr<WritableFile> new_file;
status = env_->NewWritableFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCreateFilePathIsInvalid) {
@ -220,21 +220,21 @@ TEST_P(ModularFileSystemTest, TestCreateFilePathIsInvalid) {
const std::string new_path = GetURIForPath("a_file/a_file");
std::unique_ptr<WritableFile> new_file;
status = env_->NewWritableFile(new_path, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestAppendFile) {
const std::string filepath = GetURIForPath("a_file");
std::unique_ptr<WritableFile> new_file;
Status status = env_->NewAppendableFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestAppendFileNonExisting) {
const std::string filepath = GetURIForPath("dir_not_found/a_file");
std::unique_ptr<WritableFile> new_file;
Status status = env_->NewAppendableFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestAppendFileExistingDir) {
@ -244,7 +244,7 @@ TEST_P(ModularFileSystemTest, TestAppendFileExistingDir) {
std::unique_ptr<WritableFile> new_file;
status = env_->NewAppendableFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCreateThenAppendFile) {
@ -256,7 +256,7 @@ TEST_P(ModularFileSystemTest, TestCreateThenAppendFile) {
std::unique_ptr<WritableFile> same_file;
status = env_->NewAppendableFile(filepath, &same_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestAppendFilePathIsInvalid) {
@ -269,21 +269,21 @@ TEST_P(ModularFileSystemTest, TestAppendFilePathIsInvalid) {
const std::string new_path = GetURIForPath("a_file/a_file");
std::unique_ptr<WritableFile> same_file;
status = env_->NewAppendableFile(new_path, &same_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestReadFile) {
const std::string filepath = GetURIForPath("a_file");
std::unique_ptr<RandomAccessFile> new_file;
Status status = env_->NewRandomAccessFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestReadFileNonExisting) {
const std::string filepath = GetURIForPath("dir_not_found/a_file");
std::unique_ptr<RandomAccessFile> new_file;
Status status = env_->NewRandomAccessFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestReadFileExistingDir) {
@ -293,7 +293,7 @@ TEST_P(ModularFileSystemTest, TestReadFileExistingDir) {
std::unique_ptr<RandomAccessFile> new_file;
status = env_->NewRandomAccessFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCreateThenReadFile) {
@ -305,7 +305,7 @@ TEST_P(ModularFileSystemTest, TestCreateThenReadFile) {
std::unique_ptr<RandomAccessFile> same_file;
status = env_->NewRandomAccessFile(filepath, &same_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestReadFilePathIsInvalid) {
@ -318,21 +318,21 @@ TEST_P(ModularFileSystemTest, TestReadFilePathIsInvalid) {
const std::string new_path = GetURIForPath("a_file/a_file");
std::unique_ptr<RandomAccessFile> same_file;
status = env_->NewRandomAccessFile(new_path, &same_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCreateMemoryRegion) {
const std::string filepath = GetURIForPath("a_file");
std::unique_ptr<ReadOnlyMemoryRegion> region;
Status status = env_->NewReadOnlyMemoryRegionFromFile(filepath, &region);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestCreateMemoryRegionNonExisting) {
const std::string filepath = GetURIForPath("dir_not_found/a_file");
std::unique_ptr<ReadOnlyMemoryRegion> region;
Status status = env_->NewReadOnlyMemoryRegionFromFile(filepath, &region);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestCreateMemoryRegionExistingDir) {
@ -342,7 +342,7 @@ TEST_P(ModularFileSystemTest, TestCreateMemoryRegionExistingDir) {
std::unique_ptr<ReadOnlyMemoryRegion> new_file;
status = env_->NewReadOnlyMemoryRegionFromFile(filepath, &new_file);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCreateMemoryRegionFromEmptyFile) {
@ -354,7 +354,7 @@ TEST_P(ModularFileSystemTest, TestCreateMemoryRegionFromEmptyFile) {
std::unique_ptr<ReadOnlyMemoryRegion> region;
status = env_->NewReadOnlyMemoryRegionFromFile(filepath, &region);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::INVALID_ARGUMENT);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::INVALID_ARGUMENT);
}
TEST_P(ModularFileSystemTest, TestCreateMemoryRegionFromFile) {
@ -374,7 +374,7 @@ TEST_P(ModularFileSystemTest, TestCreateMemoryRegionFromFile) {
std::unique_ptr<ReadOnlyMemoryRegion> region;
status = env_->NewReadOnlyMemoryRegionFromFile(filepath, &region);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok())
GTEST_SKIP() << "NewReadOnlyMemoryRegionFromFile() not supported: "
<< status;
@ -393,19 +393,19 @@ TEST_P(ModularFileSystemTest, TestCreateMemoryRegionFromFilePathIsInvalid) {
std::string new_path = GetURIForPath("a_file/a_file");
std::unique_ptr<ReadOnlyMemoryRegion> region;
status = env_->NewReadOnlyMemoryRegionFromFile(new_path, &region);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCreateDir) {
const std::string dirpath = GetURIForPath("a_dir");
Status status = env_->CreateDir(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestCreateDirNoParent) {
const std::string dirpath = GetURIForPath("dir_not_found/a_dir");
Status status = env_->CreateDir(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestCreateDirWhichIsFile) {
@ -416,7 +416,7 @@ TEST_P(ModularFileSystemTest, TestCreateDirWhichIsFile) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->CreateDir(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::ALREADY_EXISTS);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::ALREADY_EXISTS);
}
TEST_P(ModularFileSystemTest, TestCreateDirTwice) {
@ -425,7 +425,7 @@ TEST_P(ModularFileSystemTest, TestCreateDirTwice) {
if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;
status = env_->CreateDir(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::ALREADY_EXISTS);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::ALREADY_EXISTS);
}
TEST_P(ModularFileSystemTest, TestCreateDirPathIsInvalid) {
@ -437,7 +437,7 @@ TEST_P(ModularFileSystemTest, TestCreateDirPathIsInvalid) {
const std::string new_path = GetURIForPath("a_file/a_dir");
status = env_->CreateDir(new_path);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestRecursivelyCreateDir) {
@ -526,7 +526,7 @@ TEST_P(ModularFileSystemTest, TestDeleteFile) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->DeleteFile(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestDeleteFileFromDirectory) {
@ -541,13 +541,13 @@ TEST_P(ModularFileSystemTest, TestDeleteFileFromDirectory) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->DeleteFile(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestDeleteFileDoesNotExist) {
const std::string filepath = GetURIForPath("a_file");
Status status = env_->DeleteFile(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestDeleteFileWhichIsDirectory) {
@ -556,7 +556,7 @@ TEST_P(ModularFileSystemTest, TestDeleteFileWhichIsDirectory) {
if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;
status = env_->DeleteFile(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestDeleteFilePathIsInvalid) {
@ -568,7 +568,7 @@ TEST_P(ModularFileSystemTest, TestDeleteFilePathIsInvalid) {
const std::string new_path = GetURIForPath("a_file/a_new_file");
status = env_->DeleteFile(new_path);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestDeleteDirectory) {
@ -577,7 +577,7 @@ TEST_P(ModularFileSystemTest, TestDeleteDirectory) {
if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;
status = env_->DeleteDir(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestDeleteDirectoryFromDirectory) {
@ -589,13 +589,13 @@ TEST_P(ModularFileSystemTest, TestDeleteDirectoryFromDirectory) {
EXPECT_EQ(env_->CreateDir(target_path).code(), Code::OK);
status = env_->DeleteDir(target_path);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestDeleteDirectoryDoesNotExist) {
const std::string dirpath = GetURIForPath("a_dir");
Status status = env_->DeleteDir(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestDeleteDirectoryNotEmpty) {
@ -610,7 +610,7 @@ TEST_P(ModularFileSystemTest, TestDeleteDirectoryNotEmpty) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->DeleteDir(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestDeleteDirectoryWhichIsFile) {
@ -621,7 +621,7 @@ TEST_P(ModularFileSystemTest, TestDeleteDirectoryWhichIsFile) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->DeleteDir(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestDeleteDirectoryPathIsInvalid) {
@ -633,7 +633,7 @@ TEST_P(ModularFileSystemTest, TestDeleteDirectoryPathIsInvalid) {
const std::string new_path = GetURIForPath("a_file/a_dir");
status = env_->DeleteDir(new_path);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestDeleteRecursivelyEmpty) {
@ -772,13 +772,13 @@ TEST_P(ModularFileSystemTest, TestRenameFile) {
const std::string new_filepath = GetURIForPath("a_new_file");
status = env_->RenameFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "RenameFile() not supported: " << status;
status = env_->FileExists(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
status = env_->FileExists(new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestRenameFileOverwrite) {
@ -795,20 +795,20 @@ TEST_P(ModularFileSystemTest, TestRenameFileOverwrite) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->RenameFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "RenameFile() not supported: " << status;
status = env_->FileExists(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
status = env_->FileExists(new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestRenameFileSourceNotFound) {
const std::string filepath = GetURIForPath("a_file");
const std::string new_filepath = GetURIForPath("a_new_file");
Status status = env_->RenameFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestRenameFileDestinationParentNotFound) {
@ -820,7 +820,7 @@ TEST_P(ModularFileSystemTest, TestRenameFileDestinationParentNotFound) {
const std::string new_filepath = GetURIForPath("a_dir/a_file");
status = env_->RenameFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestRenameFileSourceIsDirectory) {
@ -830,7 +830,7 @@ TEST_P(ModularFileSystemTest, TestRenameFileSourceIsDirectory) {
const std::string new_filepath = GetURIForPath("a_new_file");
status = env_->RenameFile(dirpath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestRenameFileTargetIsDirectory) {
@ -845,7 +845,7 @@ TEST_P(ModularFileSystemTest, TestRenameFileTargetIsDirectory) {
if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;
status = env_->RenameFile(filepath, dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestRenameFileSourcePathIsInvalid) {
@ -858,7 +858,7 @@ TEST_P(ModularFileSystemTest, TestRenameFileSourcePathIsInvalid) {
const std::string old_filepath = GetURIForPath("a_file/x");
const std::string new_filepath = GetURIForPath("a_new_file");
status = env_->RenameFile(old_filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestRenameFileTargetPathIsInvalid) {
@ -876,7 +876,7 @@ TEST_P(ModularFileSystemTest, TestRenameFileTargetPathIsInvalid) {
const std::string new_filepath = GetURIForPath("a_file/a_new_file");
status = env_->RenameFile(old_filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestRenameFileCompareContents) {
@ -896,12 +896,12 @@ TEST_P(ModularFileSystemTest, TestRenameFileCompareContents) {
const std::string new_filepath = GetURIForPath("a_new_file");
status = env_->RenameFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "RenameFile() not supported: " << status;
uint64 size;
status = env_->GetFileSize(new_filepath, &size);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "GetFileSize() not supported: " << status;
EXPECT_EQ(size, test_data.size());
}
@ -915,13 +915,13 @@ TEST_P(ModularFileSystemTest, TestCopyFile) {
const std::string new_filepath = GetURIForPath("a_new_file");
status = env_->CopyFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "CopyFile() not supported: " << status;
status = env_->FileExists(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
status = env_->FileExists(new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestCopyFileOverwrite) {
@ -938,20 +938,20 @@ TEST_P(ModularFileSystemTest, TestCopyFileOverwrite) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->CopyFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "CopyFile() not supported: " << status;
status = env_->FileExists(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
status = env_->FileExists(new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestCopyFileSourceNotFound) {
const std::string filepath = GetURIForPath("a_file");
const std::string new_filepath = GetURIForPath("a_new_file");
Status status = env_->CopyFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestCopyFileSourceIsDirectory) {
@ -961,7 +961,7 @@ TEST_P(ModularFileSystemTest, TestCopyFileSourceIsDirectory) {
const std::string new_filepath = GetURIForPath("a_new_file");
status = env_->CopyFile(dirpath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCopyFileTargetIsDirectory) {
@ -976,7 +976,7 @@ TEST_P(ModularFileSystemTest, TestCopyFileTargetIsDirectory) {
if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;
status = env_->CopyFile(filepath, dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCopyFileSourcePathIsInvalid) {
@ -989,7 +989,7 @@ TEST_P(ModularFileSystemTest, TestCopyFileSourcePathIsInvalid) {
const std::string old_filepath = GetURIForPath("a_file/x");
const std::string new_filepath = GetURIForPath("a_new_file");
status = env_->CopyFile(old_filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCopyFileTargetPathIsInvalid) {
@ -1007,7 +1007,7 @@ TEST_P(ModularFileSystemTest, TestCopyFileTargetPathIsInvalid) {
const std::string new_filepath = GetURIForPath("a_file/a_new_file");
status = env_->CopyFile(old_filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestCopyFileCompareContents) {
@ -1027,17 +1027,17 @@ TEST_P(ModularFileSystemTest, TestCopyFileCompareContents) {
const std::string new_filepath = GetURIForPath("a_new_file");
status = env_->CopyFile(filepath, new_filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "RenameFile() not supported: " << status;
uint64 size;
status = env_->GetFileSize(filepath, &size);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "GetFileSize() not supported: " << status;
EXPECT_EQ(size, test_data.size());
status = env_->GetFileSize(new_filepath, &size);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "GetFileSize() not supported: " << status;
EXPECT_EQ(size, test_data.size());
}
@ -1050,7 +1050,7 @@ TEST_P(ModularFileSystemTest, TestFileExists) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->FileExists(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestFileExistsButIsDirectory) {
@ -1059,13 +1059,13 @@ TEST_P(ModularFileSystemTest, TestFileExistsButIsDirectory) {
if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;
status = env_->FileExists(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestFileExistsNotFound) {
const std::string filepath = GetURIForPath("a_file");
Status status = env_->FileExists(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestFileExistsPathIsInvalid) {
@ -1077,7 +1077,7 @@ TEST_P(ModularFileSystemTest, TestFileExistsPathIsInvalid) {
const std::string target_path = GetURIForPath("a_file/a_new_file");
status = env_->FileExists(target_path);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestFilesExist) {
@ -1096,7 +1096,7 @@ TEST_P(ModularFileSystemTest, TestFilesExist) {
EXPECT_TRUE(env_->FilesExist(filenames, &statuses));
EXPECT_EQ(statuses.size(), filenames.size());
for (const auto& status : statuses)
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestFilesExistAllFailureModes) {
@ -1119,11 +1119,11 @@ TEST_P(ModularFileSystemTest, TestFilesExistAllFailureModes) {
std::vector<Status> statuses;
EXPECT_FALSE(env_->FilesExist(filenames, &statuses));
EXPECT_EQ(statuses.size(), filenames.size());
EXPECT_PRED2(UninmplementedOrReturnsCode, statuses[0], Code::OK);
EXPECT_PRED2(UninmplementedOrReturnsCode, statuses[1], Code::OK);
EXPECT_PRED2(UninmplementedOrReturnsCode, statuses[2],
EXPECT_PRED2(UnimplementedOrReturnsCode, statuses[0], Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, statuses[1], Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, statuses[2],
Code::FAILED_PRECONDITION);
EXPECT_PRED2(UninmplementedOrReturnsCode, statuses[3], Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, statuses[3], Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestFilesExistsNoFiles) {
@ -1144,7 +1144,7 @@ TEST_P(ModularFileSystemTest, TestStatEmptyFile) {
FileStatistics stat;
status = env_->Stat(filepath, &stat);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Stat() not supported: " << status;
EXPECT_FALSE(stat.is_directory);
EXPECT_EQ(stat.length, 0);
@ -1167,7 +1167,7 @@ TEST_P(ModularFileSystemTest, TestStatNonEmptyFile) {
FileStatistics stat;
status = env_->Stat(filepath, &stat);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Stat() not supported: " << status;
EXPECT_FALSE(stat.is_directory);
EXPECT_EQ(stat.length, test_data.size());
@ -1180,7 +1180,7 @@ TEST_P(ModularFileSystemTest, TestStatDirectory) {
FileStatistics stat;
status = env_->Stat(dirpath, &stat);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Stat() not supported: " << status;
EXPECT_TRUE(stat.is_directory);
}
@ -1189,7 +1189,7 @@ TEST_P(ModularFileSystemTest, TestStatNotFound) {
const std::string dirpath = GetURIForPath("a_dir");
FileStatistics stat;
Status status = env_->Stat(dirpath, &stat);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestStatPathIsInvalid) {
@ -1202,7 +1202,7 @@ TEST_P(ModularFileSystemTest, TestStatPathIsInvalid) {
const std::string target_path = GetURIForPath("a_file/a_new_file");
FileStatistics stat;
status = env_->Stat(target_path, &stat);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestIsDirectory) {
@ -1211,7 +1211,7 @@ TEST_P(ModularFileSystemTest, TestIsDirectory) {
if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;
status = env_->IsDirectory(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
}
TEST_P(ModularFileSystemTest, TestIsDirectoryFile) {
@ -1222,13 +1222,13 @@ TEST_P(ModularFileSystemTest, TestIsDirectoryFile) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = env_->IsDirectory(filepath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestIsDirectoryNotFound) {
const std::string dirpath = GetURIForPath("a_dir");
Status status = env_->IsDirectory(dirpath);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestIsDirectoryPathIsInvalid) {
@ -1240,7 +1240,7 @@ TEST_P(ModularFileSystemTest, TestIsDirectoryPathIsInvalid) {
const std::string target_path = GetURIForPath("a_file/a_new_file");
status = env_->IsDirectory(target_path);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestGetFileSizeEmptyFile) {
@ -1252,7 +1252,7 @@ TEST_P(ModularFileSystemTest, TestGetFileSizeEmptyFile) {
uint64 size;
status = env_->GetFileSize(filepath, &size);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "GetFileSize() not supported: " << status;
EXPECT_EQ(size, 0);
}
@ -1274,7 +1274,7 @@ TEST_P(ModularFileSystemTest, TestGetFileSizeNonEmptyFile) {
uint64 size;
status = env_->GetFileSize(filepath, &size);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "GetFileSize() not supported: " << status;
EXPECT_EQ(size, test_data.size());
}
@ -1286,14 +1286,14 @@ TEST_P(ModularFileSystemTest, TestGetFileSizeDirectory) {
uint64 size;
status = env_->GetFileSize(dirpath, &size);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestGetFileSizeNotFound) {
const std::string filepath = GetURIForPath("a_dir");
uint64 size;
Status status = env_->GetFileSize(filepath, &size);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestGetFileSizePathIsInvalid) {
@ -1306,7 +1306,7 @@ TEST_P(ModularFileSystemTest, TestGetFileSizePathIsInvalid) {
const std::string target_path = GetURIForPath("a_file/a_new_file");
uint64 size;
status = env_->GetFileSize(target_path, &size);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestGetChildren) {
@ -1338,7 +1338,7 @@ TEST_P(ModularFileSystemTest, TestGetChildren) {
std::vector<std::string> children;
status = env_->GetChildren(dirpath, &children);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "GetChildren() not supported: " << status;
// All entries must show up in the vector.
@ -1358,7 +1358,7 @@ TEST_P(ModularFileSystemTest, TestGetChildrenEmpty) {
std::vector<std::string> children;
status = env_->GetChildren(dirpath, &children);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
EXPECT_EQ(children.size(), 0);
}
@ -1371,14 +1371,14 @@ TEST_P(ModularFileSystemTest, TestGetChildrenOfFile) {
std::vector<std::string> children;
status = env_->GetChildren(filepath, &children);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestGetChildrenPathNotFound) {
const std::string target_path = GetURIForPath("a_dir");
std::vector<std::string> children;
Status status = env_->GetChildren(target_path, &children);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::NOT_FOUND);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::NOT_FOUND);
}
TEST_P(ModularFileSystemTest, TestGetChildrenPathIsInvalid) {
@ -1391,7 +1391,7 @@ TEST_P(ModularFileSystemTest, TestGetChildrenPathIsInvalid) {
const std::string target_path = GetURIForPath("a_file/a_new_dir");
std::vector<std::string> children;
status = env_->GetChildren(target_path, &children);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::FAILED_PRECONDITION);
}
TEST_P(ModularFileSystemTest, TestGetMatchingPaths) {
@ -1420,7 +1420,7 @@ TEST_P(ModularFileSystemTest, TestGetMatchingPaths) {
std::vector<std::string> results;
Status status = env_->GetMatchingPaths(GetURIForPath("/a*"), &results);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok())
GTEST_SKIP() << "GetMatchingPaths() not supported: " << status;
EXPECT_EQ(results.size(), matching_filenames.size());
@ -1431,7 +1431,7 @@ TEST_P(ModularFileSystemTest, TestGetMatchingPaths) {
TEST_P(ModularFileSystemTest, TestGetMatchingPathsEmptyFileSystem) {
std::vector<std::string> results;
Status status = env_->GetMatchingPaths(GetURIForPath("a*"), &results);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
EXPECT_EQ(results.size(), 0);
}
@ -1452,7 +1452,7 @@ TEST_P(ModularFileSystemTest, TestGetMatchingPathsEmptyPattern) {
std::vector<std::string> results;
Status status = env_->GetMatchingPaths(GetURIForPath(""), &results);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok())
GTEST_SKIP() << "GetMatchingPaths() not supported: " << status;
EXPECT_EQ(results.size(), 1);
@ -1477,7 +1477,7 @@ TEST_P(ModularFileSystemTest, TestGetMatchingPathsLiteralMatch) {
std::vector<std::string> results;
Status status = env_->GetMatchingPaths(filenames[0], &results);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok())
GTEST_SKIP() << "GetMatchingPaths() not supported: " << status;
EXPECT_EQ(results.size(), 1);
@ -1504,7 +1504,7 @@ TEST_P(ModularFileSystemTest, TestGetMatchingPathsNoMatch) {
Status status = env_->GetMatchingPaths(GetURIForPath("x?y*"), &results);
if (!status.ok())
GTEST_SKIP() << "GetMatchingPaths() not supported: " << status;
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
EXPECT_EQ(results.size(), 0);
}
@ -1517,13 +1517,13 @@ TEST_P(ModularFileSystemTest, TestAppendAndTell) {
int64 position;
status = file->Tell(&position);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Tell() not supported: " << status;
EXPECT_EQ(position, 0);
const std::string test_data("asdf");
status = file->Append(test_data);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Append() not supported: " << status;
status = file->Tell(&position);
@ -1539,7 +1539,7 @@ TEST_P(ModularFileSystemTest, TestClose) {
GTEST_SKIP() << "NewWritableFile() not supported: " << status;
status = file->Close();
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Close() not supported: " << status;
}
@ -1552,15 +1552,15 @@ TEST_P(ModularFileSystemTest, TestRoundTrip) {
const std::string test_data("asdf");
status = file->Append(test_data);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Append() not supported: " << status;
status = file->Flush();
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Flush() not supported: " << status;
status = file->Close();
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Close() not supported: " << status;
std::unique_ptr<RandomAccessFile> read_file;
@ -1571,7 +1571,7 @@ TEST_P(ModularFileSystemTest, TestRoundTrip) {
char scratch[64 /* big enough to accomodate test_data */] = {0};
StringPiece result;
status = read_file->Read(0, test_data.size(), &result, scratch);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
EXPECT_EQ(test_data, result);
}
@ -1584,15 +1584,15 @@ TEST_P(ModularFileSystemTest, TestRoundTripWithAppendableFile) {
const std::string test_data("asdf");
status = file->Append(test_data);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Append() not supported: " << status;
status = file->Flush();
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Flush() not supported: " << status;
status = file->Close();
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Close() not supported: " << status;
std::unique_ptr<WritableFile> same_file;
@ -1614,7 +1614,7 @@ TEST_P(ModularFileSystemTest, TestRoundTripWithAppendableFile) {
StringPiece result;
status = read_file->Read(0, test_data.size() + more_test_data.size(), &result,
scratch);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
EXPECT_EQ(test_data + more_test_data, result);
EXPECT_EQ(
read_file->Read(test_data.size(), more_test_data.size(), &result, scratch)
@ -1632,15 +1632,15 @@ TEST_P(ModularFileSystemTest, TestReadOutOfRange) {
const std::string test_data("asdf");
status = file->Append(test_data);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Append() not supported: " << status;
status = file->Flush();
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Flush() not supported: " << status;
status = file->Close();
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OK);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OK);
if (!status.ok()) GTEST_SKIP() << "Close() not supported: " << status;
std::unique_ptr<RandomAccessFile> read_file;
@ -1652,7 +1652,7 @@ TEST_P(ModularFileSystemTest, TestReadOutOfRange) {
StringPiece result;
// read at least 1 byte more than test_data
status = read_file->Read(0, test_data.size() + 1, &result, scratch);
EXPECT_PRED2(UninmplementedOrReturnsCode, status, Code::OUT_OF_RANGE);
EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::OUT_OF_RANGE);
}
// The URI schemes that need to be tested are provided by the user via flags

2
tensorflow/c/experimental/filesystem/plugins/posix/posix_filesystem_helper.cc
View File

@ -44,7 +44,7 @@ int TransferFileContents(const char* src, const char* dst, mode_t mode,
}
// Both files have been opened, do the transfer.
// Since errno would be overriden by `close` below, save it here.
// Since errno would be overridden by `close` below, save it here.
int error_code = 0;
if (CopyFileContents(dst_fd, src_fd, size) < 0) error_code = errno;

4
tensorflow/c/ops_test.cc
View File

@ -133,7 +133,7 @@ TEST(OpsTest, TestShapeInference_VectorizeFunction) {
TEST(OpsTest, AttributeAccessors) {
TF_OpDefinitionBuilder* builder =
TF_NewOpDefinitionBuilder("AttributeAccesorsOp");
TF_NewOpDefinitionBuilder("AttributeAccessorsOp");
TF_OpDefinitionBuilderAddAttr(builder, "foo1: int >= 2");
TF_OpDefinitionBuilderAddAttr(builder, "foo2: string=\"my string\"");
TF_OpDefinitionBuilderSetIsCommutative(builder, true);
@ -151,7 +151,7 @@ TEST(OpsTest, AttributeAccessors) {
op_list.ParseFromArray(op_list_buffer->data, op_list_buffer->length);
bool found = false;
for (const auto& op : op_list.op()) {
if (op.name() == "AttributeAccesorsOp") {
if (op.name() == "AttributeAccessorsOp") {
ASSERT_TRUE(op.is_commutative());
ASSERT_TRUE(op.is_aggregate());
ASSERT_TRUE(op.allows_uninitialized_input());

2
tensorflow/c/tf_tensor.cc
View File

@ -383,7 +383,7 @@ Status TensorInterface::ToTensor(Tensor* dst) const {
if (!dst->scalar<tensorflow::ResourceHandle>()().ParseFromString(
string(static_cast<const char*>(Data()), ByteSize()))) {
return InvalidArgument(
"Malformed TF_RESOUCE tensor: unable to parse resource handle");
"Malformed TF_RESOURCE tensor: unable to parse resource handle");
}
return Status::OK();
}

6
tensorflow/cc/framework/gradients.cc
View File

@ -346,8 +346,8 @@ Status SymbolicGradientBuilder::SumGradients(const Output& src, Output* grad) {
"Unable to find backprop list for node.id ", src.node()->name());
}
const auto& grads = iter->second;
// Filter any backproped 'NoGradient' Outputs from 'grads' (if needed).
// Return any valid backproped gradients that remain after filtering,
// Filter any backpropped 'NoGradient' Outputs from 'grads' (if needed).
// Return any valid backpropped gradients that remain after filtering,
// or 'NoGradient' otherwise.
std::vector<Output> grads_to_keep;
for (const Output& o : grads) {
@ -519,7 +519,7 @@ Status SymbolicGradientBuilder::AddGradients() {
// Backprop along the in edges.
// TODO(andydavis) Find cleaner way to map each grad output returned by
// gradient function to the src node/output to which it should be
// backproped. Maybe grad functions can return a vector of Output pairs to
// backpropped. Maybe grad functions can return a vector of Output pairs to
// make this association explicit.
size_t dx_index = 0;
for (const Edge* e : n->in_edges()) {

2
tensorflow/cc/gradients/nn_grad.cc
View File

@ -64,7 +64,7 @@ bool IsZero(const Scope& scope, const Output& grad) {
// Multiply after broadcasting vec to match dimensions of mat.
// Args:
// vec: A 1-D tensor of dimension [D0]
// mat: A 2-D tensor of dimesnion [D0, D1]
// mat: A 2-D tensor of dimension [D0, D1]
//
// Returns:
// A tensor of dimension [D0, D1], the result fo vec * mat.

2
tensorflow/compiler/mlir/tensorflow/analysis/side_effect_analysis.cc
View File

@ -432,7 +432,7 @@ void SideEffectAnalysis::AnalyzeRegion(
// Returns whether an access to `resource` can skip control edges from
// previous accesses to unknown resources, due to that earlier accesses to
// `resource` already indirectly tracked previous accesses to uknown
// `resource` already indirectly tracked previous accesses to unknown
// resources. `read_only` specifies the type of access of the current op being
// considered.
auto unknown_access_indirectly_tracked_by_resource = [&](int64_t resource,

2
tensorflow/compiler/mlir/tensorflow/analysis/side_effect_analysis.h
View File

@ -62,7 +62,7 @@ class ResourceAliasAnalysis {
// An analysis that runs on a function and infers the control predecessors and
// successors for each op, based on side-effects on known and unknown resources.
// Side-effecting ops on uknown resources are conservatively treated as
// Side-effecting ops on unknown resources are conservatively treated as
// interfering with all known resource op accesses. It distinguishes accesses
// based on whether they are read-only, and read-only ops do not interfer with
// each other.

4
tensorflow/compiler/mlir/tensorflow/translate/control_to_executor_dialect.cc
View File

@ -13,8 +13,8 @@ See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
// This transformation pass transforms MLIR TF contol dialect into a combination
// of the TF and TF executor dialects.
// This transformation pass transforms MLIR TF control dialect into a
// combination of the TF and TF executor dialects.
//
// !! This code is only intended for migration purpose and will be deleted when
// !! the importer is updated to directly emit the tf_executor dialect.

2
tensorflow/compiler/tf2tensorrt/kernels/trt_engine_op.cc
View File

@ -617,7 +617,7 @@ bool TRTEngineOp::ExecuteTrtEngine(OpKernelContext* ctx,
}
} else {
const string msg =
StrCat("Ouput node ", output_name, " not found, at ", name());
StrCat("Output node ", output_name, " not found, at ", name());
LOG(ERROR) << msg;
ctx->SetStatus(errors::NotFound(msg));
return !kRetry;

2
tensorflow/compiler/xla/client/xla_builder.h
View File

@ -329,7 +329,7 @@ class XlaBuilder {
int64 target_param_num,
ShapeIndex target_param_index, int64 target_dim_num);
// Adds a new input/output alias. Since the input/ouput shape information are
// Adds a new input/output alias. Since the input/output shape information are
// not available until the computation is built, and eventual error in the
// arguments of this API will be detected only at computation Build() time.
void SetUpAlias(const ShapeIndex& output_index, int64 param_number,

2
tensorflow/compiler/xla/layout_util.cc
View File

@ -66,7 +66,7 @@ void SetDefaultLayoutToContainer(T* minor_to_major) {
for (Tile tile : tiles) {
for (int64 dim : tile.dimensions()) {
if (dim < 0 && dim != Tile::kCombineDimension) {
LOG(FATAL) << "Tile dimension size needs to be mininum int64 value if "
LOG(FATAL) << "Tile dimension size needs to be minimum int64 value if "
"it's negative. Value is "
<< dim;
}

2
tensorflow/compiler/xla/service/cpu/cpu_executable.cc
View File

@ -271,7 +271,7 @@ StatusOr<ScopedShapedBuffer> CpuExecutable::CreateResultShapedBuffer(
slice.allocation()->parameter_number(),
slice.allocation()->param_shape_index());
CHECK(output_alias)
<< "Ouput buffer is coming from parameter "
<< "Output buffer is coming from parameter "
<< slice.allocation()->parameter_number() << " at index "
<< slice.allocation()->param_shape_index()
<< ", but no alias exists";

2
tensorflow/compiler/xla/service/elemental_ir_emitter.cc
View File

@ -734,7 +734,7 @@ StatusOr<llvm::Value*> ElementalIrEmitter::EmitComplexUnaryOp(
// is finite and b is either +/-Inf or NaN, then our normal
// calculation would end up returing (+/-1, NaN), as opposed to (NaN,
// NaN).
// 5/6) We always calculate the imagninary value as sin(2b)/denominator.
// 5/6) We always calculate the imaginary value as sin(2b)/denominator.
// When the denominator is infinity, this assures us that the zero is
// the correct sign. However if our imaginary input results in
// sin(2b) = NaN, we calculate our imaginary result as NaN.

3
tensorflow/compiler/xla/service/gpu/custom_call_test.cc
View File

@ -48,7 +48,8 @@ TEST_F(CustomCallTest, IsInvoked) {
TEST_F(CustomCallTest, UnknownTarget) {
XlaBuilder b(TestName());
CustomCall(&b, "UknownTarget", /*operands=*/{}, ShapeUtil::MakeShape(F32, {}),
CustomCall(&b, "UnknownTarget", /*operands=*/{},
ShapeUtil::MakeShape(F32, {}),
/*opaque=*/"");
ASSERT_FALSE(Execute(&b, {}).ok());
}

2
tensorflow/compiler/xla/service/gpu/gpu_executable.cc
View File

@ -417,7 +417,7 @@ StatusOr<ExecutionOutput> GpuExecutable::ExecuteAsyncOnStream(
slice.allocation()->parameter_number(),
slice.allocation()->param_shape_index());
CHECK(output_alias)
<< "Ouput buffer is coming from parameter "
<< "Output buffer is coming from parameter "
<< slice.allocation()->parameter_number() << " at index "
<< slice.allocation()->param_shape_index()
<< ", but no alias exists";

2
tensorflow/compiler/xla/service/hlo_verifier.cc
View File

@ -1599,7 +1599,7 @@ class InstructionVerifier : public DfsHloVisitorWithDefault {
for (int b = 0; b < conditional->branch_count(); ++b) {
if (conditional->branch_computation(b)->num_parameters() != 1) {
return FailedPrecondition(
"Branch computation %s of %s must have 1 parameter insted of %d",
"Branch computation %s of %s must have 1 parameter instead of %d",
conditional->branch_computation(b)->name(), conditional->ToString(),
conditional->branch_computation(b)->num_parameters());
}

4
tensorflow/compiler/xla/service/layout_assignment.h
View File

@ -394,10 +394,10 @@ class LayoutAssignment : public HloModulePass {
return Status::OK();
}
// Construct contraints and assign layouts to all instructions in the
// Construct constraints and assign layouts to all instructions in the
// computation satisfying the given ComputationLayout, if not nullptr.
// Otherwise the ComputationLayout will be calculated by propagating the
// computation instruction contraints.
// computation instruction constraints.
// Layouts constraints are added, then propagated until all LogicalBuffers in
// the computation are constrained.
Status RunOnComputation(ComputationLayout* computation_layout,

2
tensorflow/examples/android/jni/object_tracking/frame_pair.cc
View File

@ -56,7 +56,7 @@ void FramePair::AdjustBox(const BoundingBox box,
*scale_y = 1.0f;
// The assumption is that all deltas that make it to this stage with a
// correspondending optical_flow_found_keypoint_[i] == true are not in
// corresponding optical_flow_found_keypoint_[i] == true are not in
// themselves degenerate.
//
// The degeneracy with scale arose because if the points are too close to the

4
tensorflow/examples/android/jni/object_tracking/tracked_object.cc
View File

@ -50,7 +50,7 @@ TrackedObject::~TrackedObject() {}
void TrackedObject::UpdatePosition(const BoundingBox& new_position,
const int64_t timestamp,
const ImageData& image_data,
const bool authoratative) {
const bool authoritative) {
last_known_position_ = new_position;
position_last_computed_time_ = timestamp;
@ -88,7 +88,7 @@ void TrackedObject::UpdatePosition(const BoundingBox& new_position,
if (object_model_ != NULL) {
object_model_->TrackStep(last_known_position_, *image_data.GetImage(),
*image_data.GetIntegralImage(), authoratative);
*image_data.GetIntegralImage(), authoritative);
}
} else if (tracked_match_score_ < kMatchScoreForImmediateTermination) {
if (num_consecutive_frames_below_threshold_ < 1000) {

2
tensorflow/examples/android/jni/object_tracking/tracked_object.h
View File

@ -37,7 +37,7 @@ class TrackedObject {
~TrackedObject();
void UpdatePosition(const BoundingBox& new_position, const int64_t timestamp,
const ImageData& image_data, const bool authoratative);
const ImageData& image_data, const bool authoritative);
// This method is called when the tracked object is detected at a
// given position, and allows the associated Model to grow and/or prune

2
tensorflow/examples/speech_commands/recognize_commands.py
View File

@ -26,7 +26,7 @@ class RecognizeResult(object):
"""Save recognition result temporarily.
Attributes:
founded_command: A string indicating the word just founded. Defualt value
founded_command: A string indicating the word just founded. Default value
is '_silence_'
score: An float representing the confidence of founded word. Default
value is zero.

3
tensorflow/examples/speech_commands/train.py
View File

@ -398,7 +398,8 @@ if __name__ == '__main__':
'--window_stride_ms',
type=float,
default=10.0,
help='How far to move in time between spectogram timeslices.',)
help='How far to move in time between spectrogram timeslices.',
)
parser.add_argument(
'--feature_bin_count',
type=int,

5
tensorflow/examples/speech_commands/wav_to_features.py
View File

@ -53,7 +53,7 @@ def wav_to_features(sample_rate, clip_duration_ms, window_size_ms,
sample_rate: Expected sample rate of the wavs.
clip_duration_ms: Expected duration in milliseconds of the wavs.
window_size_ms: How long each spectrogram timeslice is.
window_stride_ms: How far to move in time between spectogram timeslices.
window_stride_ms: How far to move in time between spectrogram timeslices.
feature_bin_count: How many bins to use for the feature fingerprint.
quantize: Whether to train the model for eight-bit deployment.
preprocess: Spectrogram processing mode; "mfcc", "average" or "micro".
@ -153,7 +153,8 @@ if __name__ == '__main__':
'--window_stride_ms',
type=float,
default=10.0,
help='How far to move in time between spectogram timeslices.',)
help='How far to move in time between spectrogram timeslices.',
)
parser.add_argument(
'--feature_bin_count',
type=int,

4
tensorflow/go/op/scope.go
View File

@ -25,12 +25,12 @@ import (
// Scope encapsulates common operation properties when building a Graph.
//
// A Scope object (and its derivates, e.g., obtained from Scope.SubScope)
// A Scope object (and its derivatives, e.g., obtained from Scope.SubScope)
// act as a builder for graphs. They allow common properties (such as
// a name prefix) to be specified for multiple operations being added
// to the graph.
//
// A Scope object and all its derivates (e.g., obtained from Scope.SubScope)
// A Scope object and all its derivatives (e.g., obtained from Scope.SubScope)
// are not safe for concurrent use by multiple goroutines.
type Scope struct {
graph *tf.Graph

28
tensorflow/go/op/wrappers.go
View File

@ -3614,7 +3614,7 @@ func BoostedTreesSparseCalculateBestFeatureSplitSplitType(value string) BoostedT
// l1: l1 regularization factor on leaf weights, per instance based.
// l2: l2 regularization factor on leaf weights, per instance based.
// tree_complexity: adjustment to the gain, per leaf based.
// min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
// min_node_weight: minimum avg of hessians in a node before required for the node to be considered for splitting.
// logits_dimension: The dimension of logit, i.e., number of classes.
//
// Returns:
@ -3711,7 +3711,7 @@ func BoostedTreesCalculateBestFeatureSplitV2(scope *Scope, node_id_range tf.Outp
// l1: l1 regularization factor on leaf weights, per instance based.
// l2: l2 regularization factor on leaf weights, per instance based.
// tree_complexity: adjustment to the gain, per leaf based.
// min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
// min_node_weight: minimum avg of hessians in a node before required for the node to be considered for splitting.
// max_splits: the number of nodes that can be split in the whole tree. Used as a dimension of output tensors.
//
// Returns:
@ -3764,7 +3764,7 @@ func BoostedTreesCalculateBestGainsPerFeature(scope *Scope, node_id_range tf.Out
// Checks whether a tree ensemble has been initialized.
//
// Arguments:
// tree_ensemble_handle: Handle to the tree ensemble resouce.
// tree_ensemble_handle: Handle to the tree ensemble resource.
//
// Returns output boolean on whether it is initialized or not.
func IsBoostedTreesEnsembleInitialized(scope *Scope, tree_ensemble_handle tf.Output) (is_initialized tf.Output) {
@ -5160,7 +5160,7 @@ func CudnnRNNParamsToCanonicalV2NumProj(value int64) CudnnRNNParamsToCanonicalV2
// num_layers: Specifies the number of layers in the RNN model.
// num_units: Specifies the size of the hidden state.
// input_size: Specifies the size of the input state.
// num_params_weigths: number of weight parameter matrix for all layers.
// num_params_weights: number of weight parameter matrix for all layers.
// num_params_biases: number of bias parameter vector for all layers.
// weights: the canonical form of weights that can be used for saving
// and restoration. They are more likely to be compatible across different
@ -8378,7 +8378,7 @@ func BoostedTreesCalculateBestFeatureSplitSplitType(value string) BoostedTreesCa
// l1: l1 regularization factor on leaf weights, per instance based.
// l2: l2 regularization factor on leaf weights, per instance based.
// tree_complexity: adjustment to the gain, per leaf based.
// min_node_weight: mininum avg of hessians in a node before required for the node to be considered for splitting.
// min_node_weight: minimum avg of hessians in a node before required for the node to be considered for splitting.
// logits_dimension: The dimension of logit, i.e., number of classes.
//
// Returns:
@ -13774,7 +13774,7 @@ func DebugNumericSummaryV2OutputDtype(value tf.DataType) DebugNumericSummaryV2At
// element is a bit which is set to 1 if the input tensor has an
// infinity or nan value, or zero otherwise.
//
// 3 (CONCISE_HEALTH): Ouput a float32/64 tensor of shape [5]. The 1st
// 3 (CONCISE_HEALTH): Output a float32/64 tensor of shape [5]. The 1st
// element is the tensor_id, if provided, and -1 otherwise. The
// remaining four slots are the total number of elements, -infs,
// +infs, and nans in the input tensor respectively.
@ -14132,11 +14132,11 @@ func TridiagonalSolve(scope *Scope, diagonals tf.Output, rhs tf.Output, optional
//
// Arguments:
// superdiag: Tensor of shape `[..., 1, M]`, representing superdiagonals of
// tri-diagonal matrices to the left of multiplication. Last element is ingored.
// tri-diagonal matrices to the left of multiplication. Last element is ignored.
// maindiag: Tensor of shape `[..., 1, M]`, representing main diagonals of tri-diagonal
// matrices to the left of multiplication.
// subdiag: Tensor of shape `[..., 1, M]`, representing subdiagonals of tri-diagonal
// matrices to the left of multiplication. First element is ingored.
// matrices to the left of multiplication. First element is ignored.
// rhs: Tensor of shape `[..., M, N]`, representing MxN matrices to the right of
// multiplication.
//
@ -17744,7 +17744,7 @@ func CudnnRNNCanonicalToParamsV2NumProj(value int64) CudnnRNNCanonicalToParamsV2
// biases: the canonical form of biases that can be used for saving
// and restoration. They are more likely to be compatible across different
// generations.
// num_params_weigths: number of weight parameter matrix for all layers.
// num_params_weights: number of weight parameter matrix for all layers.
// num_params_biases: number of bias parameter vector for all layers.
// rnn_mode: Indicates the type of the RNN model.
// input_mode: Indicate whether there is a linear projection between the input and
@ -30968,8 +30968,8 @@ func ResourceApplyFtrlV2UseLocking(value bool) ResourceApplyFtrlV2Attr {
// linear: Should be from a Variable().
// grad: The gradient.
// lr: Scaling factor. Must be a scalar.
// l1: L1 regulariation. Must be a scalar.
// l2: L2 shrinkage regulariation. Must be a scalar.
// l1: L1 regularization. Must be a scalar.
// l2: L2 shrinkage regularization. Must be a scalar.
//
// lr_power: Scaling factor. Must be a scalar.
//
@ -36345,8 +36345,8 @@ func ResourceApplyFtrlUseLocking(value bool) ResourceApplyFtrlAttr {
// linear: Should be from a Variable().
// grad: The gradient.
// lr: Scaling factor. Must be a scalar.
// l1: L1 regulariation. Must be a scalar.
// l2: L2 regulariation. Must be a scalar.
// l1: L1 regularization. Must be a scalar.
// l2: L2 regularization. Must be a scalar.
// lr_power: Scaling factor. Must be a scalar.
//
// Returns the created operation.
@ -42995,7 +42995,7 @@ func ResourceSparseApplyFtrlV2UseLocking(value bool) ResourceSparseApplyFtrlV2At
// indices: A vector of indices into the first dimension of var and accum.
// lr: Scaling factor. Must be a scalar.
// l1: L1 regularization. Must be a scalar.
// l2: L2 shrinkage regulariation. Must be a scalar.
// l2: L2 shrinkage regularization. Must be a scalar.
//
// lr_power: Scaling factor. Must be a scalar.
//

2
tensorflow/java/src/gen/cc/op_specs.h
View File

@ -36,7 +36,7 @@ class EndpointSpec {
// package: package of this endpoint (from which also derives its package)
// name: name of this endpoint class
// javadoc: the endpoint class documentation
// TODO(annarev): hardcode depcreated to false until deprecated is possible
// TODO(annarev): hardcode deprecated to false until deprecated is possible
EndpointSpec(const string& package, const string& name,
const Javadoc& javadoc)
: package_(package), name_(name), javadoc_(javadoc), deprecated_(false) {}

4
tensorflow/java/src/gen/cc/source_writer_test.cc
View File

@ -361,7 +361,7 @@ TEST(WriteType, ParameterizedClassAndSupertypes) {
clazz.add_parameter(type_t);
Type type_u = Type::Generic("U").add_supertype(Type::Class("Number"));
clazz.add_parameter(type_u);
clazz.add_supertype(Type::Interface("Parametrizable").add_parameter(type_u));
clazz.add_supertype(Type::Interface("Parameterizable").add_parameter(type_u));
clazz.add_supertype(Type::Interface("Runnable"));
clazz.add_supertype(Type::Class("SuperTest").add_parameter(type_t));
@ -370,7 +370,7 @@ TEST(WriteType, ParameterizedClassAndSupertypes) {
const char* expected =
"package org.tensorflow;\n\n"
"public class Test<T, U extends Number>"
" extends SuperTest<T> implements Parametrizable<U>, Runnable {\n}\n";
" extends SuperTest<T> implements Parameterizable<U>, Runnable {\n}\n";
ASSERT_STREQ(expected, writer.str().data());
}

2
tensorflow/python/BUILD
View File

@ -5710,7 +5710,7 @@ cc_import(
name = "pywrap_tensorflow_import_lib",
interface_library = select({
"//tensorflow:windows": ":pywrap_tensorflow_import_lib_file",
"//conditions:default": "not_exsiting_on_unix.lib", # Just a placeholder for Unix platforms
"//conditions:default": "not_existing_on_unix.lib", # Just a placeholder for Unix platforms
}),
system_provided = 1,
)

2
tensorflow/python/keras/layers/recurrent_v2.py
View File

@ -837,7 +837,7 @@ class LSTMCell(recurrent.LSTMCell):
inputs: A 2D tensor, with shape of `[batch, feature]`.
states: List of 2 tensors that corresponding to the cell's units. Both of
them have shape `[batch, units]`, the first tensor is the memory state
from previous time step, the second tesnor is the carry state from
from previous time step, the second tensor is the carry state from
previous time step. For timestep 0, the initial state provided by user
will be feed to cell.
training: Python boolean indicating whether the layer should behave in

4
tensorflow/python/keras/saving/hdf5_format_test.py
View File

@ -616,7 +616,7 @@ class TestWholeModelSaving(test.TestCase, parameterized.TestCase):
# out of proportion. Note that it fits into the internal HDF5
# attribute memory limit on its own but because h5py converts
# the list of layer names into numpy array, which uses the same
# amout of memory for every item, it increases the memory
# amount of memory for every item, it increases the memory
# requirements substantially.
x = keras.Input(shape=(2,), name='input_' + ('x' * (2**15)))
f = x
@ -1217,7 +1217,7 @@ class TestWeightSavingAndLoadingTFFormat(test.TestCase):
self.assertEqual(44., self.evaluate(v))
@test_util.run_in_graph_and_eager_modes
def test_nonexistant_prefix_directory(self):
def test_nonexistent_prefix_directory(self):
m = keras.Model()
v = m.add_weight(name='v', shape=[])
self.evaluate(v.assign(42.))

2
tensorflow/python/kernel_tests/scatter_ops_test.py
View File

@ -329,7 +329,7 @@ class ScatterTest(test.TestCase):
indices = np.array([2, 0, 5])
self.evaluate(op(ref, indices, updates))
# Indicies out of range should not fail.
# Indices out of range should not fail.
indices = np.array([-1, 0, 5])
self.evaluate(op(ref, indices, updates))
indices = np.array([2, 0, 6])

2
tensorflow/python/module/module_test.py
View File

@ -151,7 +151,7 @@ class TestModuleNaming(test_util.TensorFlowTestCase):
with self.assertRaises(ErrorModuleError):
# If super ctor is not called then the name scope isn't opened. We need to
# ensure that this doesn't trigger an exception (e.g. the metaclass trying
# to __exit__ a non-existant name scope).
# to __exit__ a non-existent name scope).
ErrorModule(call_super=False)
self.assertEqual("", get_name_scope())

2
tensorflow/python/ops/metrics_impl.py
View File

@ -291,7 +291,7 @@ def _aggregate_across_replicas(metrics_collections, metric_value_fn, *args):
# inside a while_loop (and perhaps a TPU rewrite context). But we don't
# want the value op to be evaluated every step or on the TPU. So we
# create it outside so that it can be evaluated at the end on the host,
# once the update ops have been evaluted.
# once the update ops have been evaluated.
# pylint: disable=protected-access
if distribution.extended._outer_control_flow_context is None:

2
tensorflow/python/profiler/internal/model_analyzer_testlib.py
View File

@ -72,7 +72,7 @@ def BuildFullModel():
return sgd_op.minimize(loss)
def BuildSplitableModel():
def BuildSplittableModel():
"""Build a small model that can be run partially in each step."""
image = array_ops.zeros([2, 6, 6, 3])

2
tensorflow/python/profiler/profiler_test.py
View File

@ -111,7 +111,7 @@ class ProfilerTest(test.TestCase):
opts = builder.time_and_memory(min_bytes=0)
with session.Session() as sess:
r1, r2, r3 = lib.BuildSplitableModel()
r1, r2, r3 = lib.BuildSplittableModel()
sess.run(variables.global_variables_initializer())
profiler = model_analyzer.Profiler(sess.graph)

2
tensorflow/python/saved_model/utils_test.py
View File

@ -163,7 +163,7 @@ class UtilsTest(test.TestCase):
def testGetTensorFromInfoRaisesErrors(self):
expected = array_ops.placeholder(dtypes.float32, 1, name="x")
tensor_info = utils.build_tensor_info(expected)
tensor_info.name = "blah:0" # Nonexistant name.
tensor_info.name = "blah:0" # Nonexistent name.
with self.assertRaises(KeyError):
utils.get_tensor_from_tensor_info(tensor_info)
tensor_info.ClearField("name") # Malformed (missing encoding).

2
tensorflow/python/training/momentum_test.py
View File

@ -260,7 +260,7 @@ class MomentumOptimizerTest(test.TestCase):
self.assertAllCloseAccordingToType([[-111, -138]], self.evaluate(var0))
@test_util.run_in_graph_and_eager_modes(reset_test=True)
def testMinimizeWith2DIndiciesForEmbeddingLookup(self):
def testMinimizeWith2DIndicesForEmbeddingLookup(self):
# This test invokes the ResourceSparseApplyMomentum operation, which
# did not have a registered GPU kernel as of April 2018. With graph
# execution, the placement algorithm notices this and automatically

2
tensorflow/stream_executor/blas.h
View File

@ -92,7 +92,7 @@ string SideString(Side s);
// Type with which intermediate computations of a blas routine are performed.
//
// Some blas calls can perform computations with a type that's different than
// the type of their inputs/outputs. This lets you e.g. multiply two matricies
// the type of their inputs/outputs. This lets you e.g. multiply two matrices
// of int8s using float32s to store the matmul's intermediate values.
enum class ComputationType {
kF16, // 16-bit floating-point

2
tensorflow/stream_executor/cuda/cuda_dnn.cc
View File

@ -1240,7 +1240,7 @@ class CudnnCtcLossDescriptor {
namespace {
// Check if the LSTM projection is used. If yes, an additional weigth matrix
// Check if the LSTM projection is used. If yes, an additional weight matrix
// (projection matrix) will be fetched to the 'weights'. Otherwise, nothing will
// be done.
port::Status CheckAndFetchProjectionWeights(

4
tensorflow/stream_executor/cuda/cudnn_6_0.inc
View File

@ -516,11 +516,11 @@ cudnnStatus_t CUDNNWINAPI cudnnGetConvolutionNdForwardOutputDim(
const cudnnTensorDescriptor_t inputTensorDesc,
const cudnnFilterDescriptor_t filterDesc,
int nbDims,
int tensorOuputDimA[] ) {
int tensorOutputDimA[] ) {
using FuncPtr = cudnnStatus_t (CUDNNWINAPI *)(const cudnnConvolutionDescriptor_t, const cudnnTensorDescriptor_t, const cudnnFilterDescriptor_t, int, int []);
static auto func_ptr = LoadSymbol<FuncPtr>("cudnnGetConvolutionNdForwardOutputDim");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOuputDimA);
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOutputDimA);
}
cudnnStatus_t CUDNNWINAPI cudnnDestroyConvolutionDescriptor(

4
tensorflow/stream_executor/cuda/cudnn_7_0.inc
View File

@ -559,11 +559,11 @@ cudnnStatus_t CUDNNWINAPI cudnnGetConvolutionNdForwardOutputDim(
const cudnnTensorDescriptor_t inputTensorDesc,
const cudnnFilterDescriptor_t filterDesc,
int nbDims,
int tensorOuputDimA[] ) {
int tensorOutputDimA[] ) {
using FuncPtr = cudnnStatus_t (CUDNNWINAPI *)(const cudnnConvolutionDescriptor_t, const cudnnTensorDescriptor_t, const cudnnFilterDescriptor_t, int, int []);
static auto func_ptr = LoadSymbol<FuncPtr>("cudnnGetConvolutionNdForwardOutputDim");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOuputDimA);
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOutputDimA);
}
cudnnStatus_t CUDNNWINAPI cudnnDestroyConvolutionDescriptor(

4
tensorflow/stream_executor/cuda/cudnn_7_1.inc
View File

@ -559,11 +559,11 @@ cudnnStatus_t CUDNNWINAPI cudnnGetConvolutionNdForwardOutputDim(
const cudnnTensorDescriptor_t inputTensorDesc,
const cudnnFilterDescriptor_t filterDesc,
int nbDims,
int tensorOuputDimA[] ) {
int tensorOutputDimA[] ) {
using FuncPtr = cudnnStatus_t (CUDNNWINAPI *)(const cudnnConvolutionDescriptor_t, const cudnnTensorDescriptor_t, const cudnnFilterDescriptor_t, int, int []);
static auto func_ptr = LoadSymbol<FuncPtr>("cudnnGetConvolutionNdForwardOutputDim");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOuputDimA);
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOutputDimA);
}
cudnnStatus_t CUDNNWINAPI cudnnDestroyConvolutionDescriptor(

4
tensorflow/stream_executor/cuda/cudnn_7_3.inc
View File

@ -557,11 +557,11 @@ cudnnGetConvolutionNdForwardOutputDim(const cudnnConvolutionDescriptor_t convDes
const cudnnTensorDescriptor_t inputTensorDesc,
const cudnnFilterDescriptor_t filterDesc,
int nbDims,
int tensorOuputDimA[]) {
int tensorOutputDimA[]) {
using FuncPtr = cudnnStatus_t (CUDNNWINAPI *)(const cudnnConvolutionDescriptor_t, const cudnnTensorDescriptor_t, const cudnnFilterDescriptor_t, int, int []);
static auto func_ptr = LoadSymbol<FuncPtr>("cudnnGetConvolutionNdForwardOutputDim");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOuputDimA);
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOutputDimA);
}
cudnnStatus_t CUDNNWINAPI

4
tensorflow/stream_executor/cuda/cudnn_7_4.inc
View File

@ -557,11 +557,11 @@ cudnnGetConvolutionNdForwardOutputDim(const cudnnConvolutionDescriptor_t convDes
const cudnnTensorDescriptor_t inputTensorDesc,
const cudnnFilterDescriptor_t filterDesc,
int nbDims,
int tensorOuputDimA[]) {
int tensorOutputDimA[]) {
using FuncPtr = cudnnStatus_t (CUDNNWINAPI *)(const cudnnConvolutionDescriptor_t, const cudnnTensorDescriptor_t, const cudnnFilterDescriptor_t, int, int []);
static auto func_ptr = LoadSymbol<FuncPtr>("cudnnGetConvolutionNdForwardOutputDim");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOuputDimA);
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOutputDimA);
}
cudnnStatus_t CUDNNWINAPI

4
tensorflow/stream_executor/cuda/cudnn_7_6.inc
View File

@ -702,11 +702,11 @@ cudnnGetConvolutionNdForwardOutputDim(const cudnnConvolutionDescriptor_t convDes
const cudnnTensorDescriptor_t inputTensorDesc,
const cudnnFilterDescriptor_t filterDesc,
int nbDims,
int tensorOuputDimA[]) {
int tensorOutputDimA[]) {
using FuncPtr = cudnnStatus_t (CUDNNWINAPI *)(const cudnnConvolutionDescriptor_t, const cudnnTensorDescriptor_t, const cudnnFilterDescriptor_t, int, int []);
static auto func_ptr = LoadSymbol<FuncPtr>("cudnnGetConvolutionNdForwardOutputDim");
if (!func_ptr) return GetSymbolNotFoundError();
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOuputDimA);
return func_ptr(convDesc, inputTensorDesc, filterDesc, nbDims, tensorOutputDimA);
}
cudnnStatus_t CUDNNWINAPI

6
tensorflow/stream_executor/cuda/cusparse_9_0.inc
View File

@ -4887,7 +4887,7 @@ cusparseStatus_t CUSPARSEAPI cusparseDcsr2csr_compress(
int m, // number of rows
int n, const cusparseMatDescr_t descra,
const double *csrValA, // csr values array-the elements which are below a
// certain tolerance will be remvoed
// certain tolerance will be removed
const int *csrColIndA,
const int *csrRowPtrA, // corresponding input noncompressed row pointer
int nnzA, const int *nnzPerRow, double *csrValC, int *csrColIndC,
@ -4907,7 +4907,7 @@ cusparseStatus_t CUSPARSEAPI cusparseCcsr2csr_compress(
int m, // number of rows
int n, const cusparseMatDescr_t descra,
const cuComplex *csrValA, // csr values array-the elements which are below
// a certain tolerance will be remvoed
// a certain tolerance will be removed
const int *csrColIndA,
const int *csrRowPtrA, // corresponding input noncompressed row pointer
int nnzA, const int *nnzPerRow, cuComplex *csrValC, int *csrColIndC,
@ -4927,7 +4927,7 @@ cusparseStatus_t CUSPARSEAPI cusparseZcsr2csr_compress(
int m, // number of rows
int n, const cusparseMatDescr_t descra,
const cuDoubleComplex *csrValA, // csr values array-the elements which are
// below a certain tolerance will be remvoed
// below a certain tolerance will be removed
const int *csrColIndA,
const int *csrRowPtrA, // corresponding input noncompressed row pointer
int nnzA, const int *nnzPerRow, cuDoubleComplex *csrValC, int *csrColIndC,

2
tensorflow/stream_executor/device_description.cc
View File

@ -137,7 +137,7 @@ bool ThreadDimOk(const DeviceDescription &device_description,
thread_dim.z <= limit.z;
if (!ok) {
VLOG(2) << "thread dim " << thread_dim.ToString()
<< " exceeds limit contraints of " << limit.ToString();
<< " exceeds limit constraints of " << limit.ToString();
}
return ok;
}

2
tensorflow/stream_executor/device_memory.h
View File

@ -109,7 +109,7 @@ class DeviceMemoryBase {
private:
void *opaque_; // Platform-dependent value representing allocated memory.
uint64 size_; // Size in bytes of this allocation.
uint64 payload_ = 0; // Payload data associtated with this allocation.
uint64 payload_ = 0; // Payload data associated with this allocation.
};
// Typed wrapper around "void *"-like DeviceMemoryBase.

2
tensorflow/stream_executor/dnn.h
View File

@ -2148,7 +2148,7 @@ class DnnSupport {
// max_seq_length: the max length of the sequences.
// batch_size: the size of a minibatch.
// data_size: the size of the state.
// seq_lenghs: the lengths of sequences in a batch.
// seq_lengths: the lengths of sequences in a batch.
// data_type: an enum to specify the type for the underlying data.
virtual port::StatusOr<std::unique_ptr<dnn::RnnSequenceTensorDescriptor>>
createRnnSequenceTensorDescriptor(int max_seq_length, int batch_size,

6
tensorflow/stream_executor/gpu/gpu_executor.h
View File

@ -40,7 +40,7 @@ namespace stream_executor {
namespace gpu {
// CUDA-platform implementation of the platform-agnostic
// StreamExecutorInferface.
// StreamExecutorInterface.
class GpuExecutor : public internal::StreamExecutorInterface {
public:
// sub_platform indicates the subplatform used in this executor; it must
@ -328,10 +328,10 @@ class GpuExecutor : public internal::StreamExecutorInterface {
// for use in getting device metadata. Immutable post-initialization.
int device_ordinal_;
// The major verion of the compute capability for device_.
// The major version of the compute capability for device_.
int cc_major_;
// The minor verion of the compute capability for device_.
// The minor version of the compute capability for device_.
int cc_minor_;
// GPU ISA version for device_.

2
tensorflow/stream_executor/gpu/gpu_timer.h
View File

@ -30,7 +30,7 @@ class GpuExecutor;
class GpuStream;
// Wraps a pair of GpuEventHandles in order to satisfy the platform-independent
// TimerInferface -- both a start and a stop event are present which may be
// TimerInterface -- both a start and a stop event are present which may be
// recorded in a stream.
class GpuTimer : public internal::TimerInterface {
public:

4
tensorflow/stream_executor/multi_platform_manager.h
View File

@ -116,7 +116,7 @@ class MultiPlatformManager {
static port::StatusOr<Platform*> InitializePlatformWithId(
const Platform::Id& id, const std::map<string, string>& options);
// Retrives the platforms satisfying the given filter, i.e. returns true.
// Retrieves the platforms satisfying the given filter, i.e. returns true.
// Returned Platforms are always initialized.
static port::StatusOr<std::vector<Platform*>> PlatformsWithFilter(
const std::function<bool(const Platform*)>& filter);
@ -134,7 +134,7 @@ class MultiPlatformManager {
// during allocation of such Platforms, to avoid spurious reporting at program
// exit.
// Interface for a listener that gets notfied at certain events.
// Interface for a listener that gets notified at certain events.
class Listener {
public:
virtual ~Listener() = default;

262
tensorflow/stream_executor/rocm/rocm_blas.cc
View File

File diff suppressed because it is too large Load Diff

2
tensorflow/stream_executor/rocm/rocm_blas.h
View File

@ -110,7 +110,7 @@ class ROCMBlas : public blas::BlasSupport {
/*err_on_failure=*/false, args...);
}
// A helper allocation funciton to convert raw pointers memory layout to
// A helper allocation function to convert raw pointers memory layout to
// strided flavor
template <typename T>
port::Status AllocateStridedBuffer(

8
tensorflow/stream_executor/rocm/rocm_dnn.cc
View File

@ -2633,7 +2633,7 @@ void* MIOpenAllocatorCallback(void* ctx, size_t size_in_bytes) {
}
void MIOpenDeallocatorCallback(void* ctx, void* mem) {
// Don't need dealloactor since the TensorFlow heap will automatically reclaim
// Don't need deallocator since the TensorFlow heap will automatically reclaim
// the memory
}
@ -3910,7 +3910,7 @@ bool MIOpenSupport::DoPoolBackward(
return false;
}
} else {
LOG(ERROR) << "Failed to calcuate tensor size to chain forward and "
LOG(ERROR) << "Failed to calculate tensor size to chain forward and "
"backward pooling";
}
@ -4006,7 +4006,7 @@ bool MIOpenSupport::DoPoolBackward(
return false;
}
} else {
LOG(ERROR) << "Failed to calcuate tensor size to chain forward and "
LOG(ERROR) << "Failed to calculate tensor size to chain forward and "
"backward pooling";
}
@ -4144,7 +4144,7 @@ bool MIOpenSupport::DoNormalizeBackwardWithDimensions(
}
} else {
LOG(ERROR)
<< "Failed to calcuate tensor size to chain forward and backward LRN";
<< "Failed to calculate tensor size to chain forward and backward LRN";
}
status = wrap::miopenLRNForward(miopen.handle(), normalize.handle(), &alpha,

10
tensorflow/stream_executor/rocm/rocm_fft.cc
View File

@ -298,14 +298,14 @@ port::Status ROCMFftPlan::Initialize(
if (ret != HIPFFT_SUCCESS) {
LOG(ERROR) << "failed to create rocFFT batched plan:" << ret;
return port::Status{port::error::INTERNAL,
"Failed to create rocFFT bacthed plan."};
"Failed to create rocFFT batched plan."};
}
} else {
auto ret = wrap::hipfftCreate(parent, &plan_);
if (ret != HIPFFT_SUCCESS) {
LOG(ERROR) << "failed to create rocFFT batched plan:" << ret;
return port::Status{port::error::INTERNAL,
"Failed to create rocFFT bacthed plan."};
"Failed to create rocFFT batched plan."};
}
ret = wrap::hipfftSetAutoAllocation(parent, plan_, 0);
if (ret != HIPFFT_SUCCESS) {
@ -313,7 +313,7 @@ port::Status ROCMFftPlan::Initialize(
<< ret;
return port::Status{
port::error::INTERNAL,
"Failed to set auto allocation for rocFFT bacthed plan."};
"Failed to set auto allocation for rocFFT batched plan."};
}
size_t size_in_bytes;
ret = wrap::hipfftMakePlanMany(
@ -324,7 +324,7 @@ port::Status ROCMFftPlan::Initialize(
if (ret != HIPFFT_SUCCESS) {
LOG(ERROR) << "failed to make rocFFT batched plan:" << ret;
return port::Status{port::error::INTERNAL,
"Failed to make rocFFT bacthed plan."};
"Failed to make rocFFT batched plan."};
}
if (size_in_bytes != 0) {
auto allocated = scratch_allocator->AllocateBytes(size_in_bytes);
@ -338,7 +338,7 @@ port::Status ROCMFftPlan::Initialize(
if (ret != HIPFFT_SUCCESS) {
LOG(ERROR) << "failed to set work area for rocFFT batched plan:" << ret;
return port::Status{port::error::INTERNAL,
"Failed to set work area for rocFFT bacthed plan."};
"Failed to set work area for rocFFT batched plan."};
}
}
}

4
tensorflow/stream_executor/scratch_allocator.h
View File

@ -31,8 +31,8 @@ class Stream;
// buffers it has allocated at destruction. Returned memory pointers are not
// owning.
//
// Used by stream operations (e.g. Stream::ThenConvolveWithScratch) to optonally
// request scratch space to speed up the operation.
// Used by stream operations (e.g. Stream::ThenConvolveWithScratch) to
// optionally request scratch space to speed up the operation.
class ScratchAllocator {
public:
virtual ~ScratchAllocator();

2
tensorflow/stream_executor/stream_executor_pimpl.h
View File

@ -685,7 +685,7 @@ class StreamExecutor {
std::unique_ptr<rng::RngSupport> rng_ GUARDED_BY(mu_);
// Slot to cache the owned DeviceDescription for the underlying device
// once it has been quieried from DeviceDescription().
// once it has been queried from DeviceDescription().
mutable std::unique_ptr<DeviceDescription> device_description_
GUARDED_BY(mu_);

2
tensorflow/tools/ci_build/Dockerfile.rbe.cuda10.0-cudnn7-centos6.sh
View File

@ -15,7 +15,7 @@
# ==============================================================================
#
# Script to create a centos6 docker image.
# Before running, copy tensorrt into /tmp after downlading it from:
# Before running, copy tensorrt into /tmp after downloading it from:
# https://developer.nvidia.com/nvidia-tensorrt-5x-download
#
# TODO(klimek): once there are downloadable images for tensorrt for centos6

2
tensorflow/tools/ci_build/Dockerfile.rbe.cuda10.1-cudnn7-centos6.sh
View File

@ -15,7 +15,7 @@
# ==============================================================================
#
# Script to create a centos6 docker image.
# Before running, copy tensorrt into /tmp after downlading it from:
# Before running, copy tensorrt into /tmp after downloading it from:
# https://developer.nvidia.com/nvidia-tensorrt-5x-download
#
# TODO(klimek): once there are downloadable images for tensorrt for centos6

2
tensorflow/tools/ci_build/builds/docker_test.sh
View File

@ -75,7 +75,7 @@ fi
BASE_DIR=$(upsearch "${DOCKERFILE}")
if [[ -z "${BASE_DIR}" ]]; then
die "FAILED: Unable to find the base directory where the dockerfile "\
"${DOCKERFFILE} resides"
"${DOCKERFILE} resides"
fi
echo "Base directory: ${BASE_DIR}"

2
tensorflow/tools/ci_build/builds/pip.sh
View File

@ -30,7 +30,7 @@
#
# TF_BUILD_INSTALL_EXTRA_PIP_PACKAGES overrides the default extra pip packages
# to be installed in virtualenv before run_pip_tests.sh is called. Multiple
# pakcage names are separated with spaces.
# package names are separated with spaces.
#
# If NO_TEST_ON_INSTALL has any non-empty and non-0 value, the test-on-install
# part will be skipped.

2
tensorflow/tools/ci_build/builds/pip_new.sh
View File

@ -72,7 +72,7 @@
# GIT_TAG_OVERRIDE: Values for `--git_tag_override`. This flag gets passed
# in as `--action_env` for bazel build and tests.
# TF_BUILD_INSTALL_EXTRA_PIP_PACKAGES:
# Additonal pip packages to be installed.
# Additional pip packages to be installed.
# Caveat: pip version needs to be checked prior.
#
# ==============================================================================

2
tensorflow/tools/ci_build/builds/test_user_ops.sh
View File

@ -196,7 +196,7 @@ else
"/usr/local/cuda/lib and /usr/local/cuda/lib64"
fi
echo "Found CUDA library diretory at: ${CUDA_LIB_DIR}"
echo "Found CUDA library directory at: ${CUDA_LIB_DIR}"
echo ""
# USER_OP_SO=$(basename $(echo "${OP_KERNEL_CC}" | sed -e 's/\.cc/\.so/'))

2
tensorflow/tools/ci_build/linux/cpu/run_mkl.sh
View File

@ -42,7 +42,7 @@ if [[ "$MODE" == "eigen" ]]; then
else
CONFIG="--config=mkl"
# Setting OMP_THREADS for low performing benchmarks.
# Default value(=core count) degrades perfrmance of some banchmark cases.
# Default value(=core count) degrades performance of some benchmark cases.
# Optimal thread count is case specific.
# An argument can be passed to script, the value of which is used if given.
# Otherwise OMP_NUM_THREADS is set to 10

2
tensorflow/tools/compatibility/all_renames_v2.py
View File

@ -612,7 +612,7 @@ addons_symbol_mappings = {
"tf.contrib.image.angles_to_projective_transforms":
"tfa.image.angles_to_projective_transforms",
"tf.contrib.image.matrices_to_flat_transforms":
"tfa.image.matricies_to_flat_transforms",
"tfa.image.matrices_to_flat_transforms",
"tf.contrib.image.rotate":
"tfa.image.rotate",
"tf.contrib.image.transform":

2
tensorflow/tools/compatibility/tf_upgrade_v2.py
View File

@ -1992,7 +1992,7 @@ def _pool_seed_transformer(parent, node, full_name, name, logs):
def _extract_glimpse_transformer(parent, node, full_name, name, logs):
def _replace_uniform_noise_node(parent, old_value):
"""Replaces old_value with 'uniform' or 'guassian'."""
"""Replaces old_value with 'uniform' or 'gaussian'."""
uniform = ast.Str(s="uniform")
gaussian = ast.Str(s="gaussian")
new_value = ast.IfExp(body=uniform, test=old_value, orelse=gaussian)

2
tensorflow/tools/compatibility/tf_upgrade_v2_test.py
View File

@ -449,7 +449,7 @@ bazel-bin/tensorflow/tools/compatibility/update/generate_v2_reorders_map
_, _, _, new_text = self._upgrade(text)
self.assertEqual("tf.compat.v1." + ns_prefix + v + "(a, b)", new_text)
def testIntializers(self):
def testInitializers(self):
initializers = [
"zeros",
"ones",

2
tensorflow/tools/graph_transforms/remove_control_dependencies.cc
View File

@ -19,7 +19,7 @@ limitations under the License.
namespace tensorflow {
namespace graph_transforms {
// Remove control depdencies in preparation for inference.
// Remove control dependencies in preparation for inference.
// In the tensorflow graph, control dependencies are represented as extra
// inputs which are referenced with "^tensor_name".
// See node_def.proto for more details.

2
tensorflow/tools/graph_transforms/transform_utils.cc
View File

@ -596,7 +596,7 @@ Status GetInOutTypes(const NodeDef& node_def, DataTypeVector* inputs,
Status TensorShapeFromString(const string& shape_string, TensorShape* result) {
if (shape_string.empty()) {
return errors::InvalidArgument("Specificed shape is empty.");
return errors::InvalidArgument("Specified shape is empty.");
}
std::vector<string> dims_as_str = str_util::Split(shape_string, ",");
std::vector<int64> dims;

2
tensorflow/tools/proto_text/gen_proto_text_functions_lib_test.cc
View File

@ -456,7 +456,7 @@ TEST(CreateProtoDebugStringLibTest, Enums) {
EXPECT_PARSE_SUCCESS("", "optional_nested_enum: -0");
// TODO(amauryfa): restore the line below when protobuf::TextFormat also
// supports unknonwn enum values.
// supports unknown enum values.
// EXPECT_PARSE_SUCCESS("optional_nested_enum: 6", "optional_nested_enum: 6");
EXPECT_PARSE_FAILURE("optional_nested_enum: 2147483648"); // > INT32_MAX
EXPECT_PARSE_FAILURE("optional_nested_enum: BARNONE");

12
tensorflow/tools/tensorflow_builder/compat_checker/compat_checker.py
View File

@ -117,7 +117,7 @@ def _get_func_name():
class ConfigCompatChecker(object):
"""Class that checks configuration versions and depencency compatibilities.
"""Class that checks configuration versions and dependency compatibilities.
`ConfigCompatChecker` checks a given set of configurations and their versions
against supported versions and dependency rules defined in `.ini` config file.
@ -180,7 +180,7 @@ class ConfigCompatChecker(object):
"""Prints a requirement and its components.
Returns:
String that has concantenated information about a requirement.
String that has concatenated information about a requirement.
"""
info = {
"section": self._section,
@ -200,7 +200,7 @@ class ConfigCompatChecker(object):
req_str += "Range: {range}\n"
req_str += "Exclude: {exclude}\n"
req_str += "Include: {include}\n"
req_str += "Initilalized: {init}\n\n"
req_str += "Initialized: {init}\n\n"
return req_str.format(**info)
@ -214,7 +214,7 @@ class ConfigCompatChecker(object):
[1] String that includes `range` indicating range syntax for defining
a requirement.
e.g. `range(1.0, 2.0) include(3.0) exclude(1.5)`
[2] List that includes inidividual supported versions or items.
[2] List that includes individual supported versions or items.
e.g. [`1.0`, `3.0`, `7.1`]
For a list type requirement, it directly stores the list to
@ -380,7 +380,7 @@ class ConfigCompatChecker(object):
parser.read(self.req_file)
if not parser.sections():
err_msg = "[Error] Empty confie file. "
err_msg = "[Error] Empty config file. "
err_msg += "(file = %s, " % str(self.req_file)
err_msg += "parser sectons = %s)" % str(parser.sections())
self.error_msg.append(err_msg)
@ -427,7 +427,7 @@ class ConfigCompatChecker(object):
self.warning_msg.append(warn_msg)
# Last dependency item may only or not have `]` depending
# on the identation style in the config (.ini) file.
# on the indentation style in the config (.ini) file.
# If it has `[`, then either skip or remove from string.
if spec_split[-1] == "]":
spec_split = spec_split[:-1]

2
tensorflow/tools/tensorflow_builder/config_detector/config_detector.py
View File

@ -327,7 +327,7 @@ def get_cuda_version_all():
def get_cuda_version_default():
"""Retrieves default CUDA version.
Default verion is the version found in `/usr/local/cuda/` installation.
Default version is the version found in `/usr/local/cuda/` installation.
stderr is silenced by default. Setting FLAGS.debug mode will not enable it.
Remove `2> /dev/null` command from `cmds_linux['cuda_ver_dflt']` to enable

4
third_party/clang_toolchain/cc_configure_clang.bzl vendored
View File

@ -15,8 +15,8 @@ def _cc_clang_autoconf(repo_ctx):
return
download_clang(repo_ctx, out_folder = "extra_tools")
overriden_tools = {"gcc": "extra_tools/bin/clang"}
cc_autoconf_impl(repo_ctx, overriden_tools)
overridden_tools = {"gcc": "extra_tools/bin/clang"}
cc_autoconf_impl(repo_ctx, overridden_tools)
cc_download_clang_toolchain = repository_rule(
environ = [

6
third_party/flatbuffers/build_defs.bzl vendored
View File

@ -17,7 +17,7 @@ def flatbuffer_library_public(
include_paths = [],
flatc_args = DEFAULT_FLATC_ARGS,
reflection_name = "",
reflection_visiblity = None,
reflection_visibility = None,
output_to_bindir = False):
"""Generates code files for reading/writing the given flatbuffers in the requested language using the public compiler.
@ -101,7 +101,7 @@ def flatbuffer_library_public(
# entries = [
# native.FilesetEntry(files = reflection_outs),
# ],
# visibility = reflection_visiblity,
# visibility = reflection_visibility,
# )
def flatbuffer_cc_library(
@ -191,7 +191,7 @@ def flatbuffer_cc_library(
include_paths = include_paths,
flatc_args = flatc_args,
reflection_name = reflection_name,
reflection_visiblity = visibility,
reflection_visibility = visibility,
)
native.cc_library(
name = name,

4
third_party/gpus/crosstool/windows/msvc_wrapper_for_nvcc.py.tpl vendored
View File

@ -117,7 +117,7 @@ def InvokeNvcc(argv, log=False):
out_file = [ f for f in argv if f.startswith('/Fo') ]
if len(out_file) != 1:
raise Error('Please sepecify exactly one output file for cuda compilation.')
raise Error('Please specify exactly one output file for cuda compilation.')
out = ['-o', out_file[0][len('/Fo'):]]
nvcc_compiler_options, argv = GetNvccOptions(argv)
@ -136,7 +136,7 @@ def InvokeNvcc(argv, log=False):
undefines, argv = GetOptionValue(argv, 'U')
undefines = ['-U' + define for define in undefines]
# The rest of the unrecongized options should be passed to host compiler
# The rest of the unrecognized options should be passed to host compiler
host_compiler_options = [option for option in argv if option not in (src_files + out_file)]
m_options = ["-m64"]

4
third_party/toolchains/preconfig/centos6/gcc7-nvcc-cuda10.0/windows/msvc_wrapper_for_nvcc.py vendored
View File

@ -110,7 +110,7 @@ def InvokeNvcc(argv, log=False):
out_file = [ f for f in argv if f.startswith('/Fo') ]
if len(out_file) != 1:
raise Error('Please sepecify exactly one output file for cuda compilation.')
raise Error('Please specify exactly one output file for cuda compilation.')
out = ['-o', out_file[0][len('/Fo'):]]
nvcc_compiler_options, argv = GetNvccOptions(argv)
@ -129,7 +129,7 @@ def InvokeNvcc(argv, log=False):
undefines, argv = GetOptionValue(argv, 'U')
undefines = ['-U' + define for define in undefines]
# The rest of the unrecongized options should be passed to host compiler
# The rest of the unrecognized options should be passed to host compiler
host_compiler_options = [option for option in argv if option not in (src_files + out_file)]
m_options = ["-m64"]

5
third_party/toolchains/preconfig/centos6/gcc7-nvcc-cuda10.1/windows/msvc_wrapper_for_nvcc.py vendored
View File

@ -114,7 +114,8 @@ def InvokeNvcc(argv, log=False):
out_file = [f for f in argv if f.startswith('/Fo')]
if len(out_file) != 1:
raise RuntimeError('Please sepecify exactly one output file for cuda compilation.')
raise RuntimeError(
'Please specify exactly one output file for cuda compilation.')
out = ['-o', out_file[0][len('/Fo'):]]
nvcc_compiler_options, argv = GetNvccOptions(argv)
@ -133,7 +134,7 @@ def InvokeNvcc(argv, log=False):
undefines, argv = GetOptionValue(argv, 'U')
undefines = ['-U' + define for define in undefines]
# The rest of the unrecongized options should be passed to host compiler
# The rest of the unrecognized options should be passed to host compiler
host_compiler_options = [
option for option in argv if option not in (src_files + out_file)
]

4
third_party/toolchains/preconfig/ubuntu14.04/gcc-nvcc-cuda10.0/windows/msvc_wrapper_for_nvcc.py vendored
View File

@ -110,7 +110,7 @@ def InvokeNvcc(argv, log=False):
out_file = [ f for f in argv if f.startswith('/Fo') ]
if len(out_file) != 1:
raise Error('Please sepecify exactly one output file for cuda compilation.')
raise Error('Please specify exactly one output file for cuda compilation.')
out = ['-o', out_file[0][len('/Fo'):]]
nvcc_compiler_options, argv = GetNvccOptions(argv)
@ -129,7 +129,7 @@ def InvokeNvcc(argv, log=False):
undefines, argv = GetOptionValue(argv, 'U')
undefines = ['-U' + define for define in undefines]
# The rest of the unrecongized options should be passed to host compiler
# The rest of the unrecognized options should be passed to host compiler
host_compiler_options = [option for option in argv if option not in (src_files + out_file)]
m_options = ["-m64"]

4
third_party/toolchains/preconfig/ubuntu16.04/gcc7_manylinux2010-nvcc-cuda10.0/windows/msvc_wrapper_for_nvcc.py vendored
View File

@ -117,7 +117,7 @@ def InvokeNvcc(argv, log=False):
out_file = [ f for f in argv if f.startswith('/Fo') ]
if len(out_file) != 1:
raise Error('Please sepecify exactly one output file for cuda compilation.')
raise Error('Please specify exactly one output file for cuda compilation.')
out = ['-o', out_file[0][len('/Fo'):]]
nvcc_compiler_options, argv = GetNvccOptions(argv)
@ -136,7 +136,7 @@ def InvokeNvcc(argv, log=False):
undefines, argv = GetOptionValue(argv, 'U')
undefines = ['-U' + define for define in undefines]
# The rest of the unrecongized options should be passed to host compiler
# The rest of the unrecognized options should be passed to host compiler
host_compiler_options = [option for option in argv if option not in (src_files + out_file)]
m_options = ["-m64"]