diff options
author | Rich Gowman <rgowman@google.com> | 2018-06-12 10:50:07 -0400 |
---|---|---|
committer | Rich Gowman <rgowman@google.com> | 2018-06-12 10:50:07 -0400 |
commit | 86cdae83a0b7b36d8a7c61eb3704b28f9f31a041 (patch) | |
tree | bb1dc7167d8eddb9e872780da357026f7ce1d83c /Firestore/core | |
parent | cf2899a085f7ceca3fad2d1fb5336be25cecd7ff (diff) | |
parent | f5bf0a37a7dd40e7538a1aed77af05471b7fe713 (diff) |
Merge remote-tracking branch 'origin/master' into rsgowman/protobuf_cpp
Diffstat (limited to 'Firestore/core')
12 files changed, 511 insertions, 40 deletions
diff --git a/Firestore/core/src/firebase/firestore/auth/credentials_provider.h b/Firestore/core/src/firebase/firestore/auth/credentials_provider.h index 0a1930a..d6ed39a 100644 --- a/Firestore/core/src/firebase/firestore/auth/credentials_provider.h +++ b/Firestore/core/src/firebase/firestore/auth/credentials_provider.h @@ -46,11 +46,14 @@ class CredentialsProvider { virtual ~CredentialsProvider(); + /** Requests token for the current user. */ + virtual void GetToken(TokenListener completion) = 0; + /** - * Requests token for the current user, optionally forcing a refreshed token - * to be fetched. + * Marks the last retrieved token as invalid, making the next `GetToken` + * request force refresh the token. */ - virtual void GetToken(bool force_refresh, TokenListener completion) = 0; + virtual void InvalidateToken() = 0; /** * Sets the listener to be notified of user changes (sign-in / sign-out). It diff --git a/Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.cc b/Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.cc index da4198d..77156cc 100644 --- a/Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.cc +++ b/Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.cc @@ -14,17 +14,13 @@ * limitations under the License. */ -#define UNUSED(x) (void)(x) - #include "Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.h" namespace firebase { namespace firestore { namespace auth { -void EmptyCredentialsProvider::GetToken(bool force_refresh, - TokenListener completion) { - UNUSED(force_refresh); +void EmptyCredentialsProvider::GetToken(TokenListener completion) { if (completion) { // Unauthenticated token will force the GRPC fallback to use default // settings. @@ -39,6 +35,9 @@ void EmptyCredentialsProvider::SetUserChangeListener( } } +void EmptyCredentialsProvider::InvalidateToken() { +} + } // namespace auth } // namespace firestore } // namespace firebase diff --git a/Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.h b/Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.h index 55b3cc6..3ea0cab 100644 --- a/Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.h +++ b/Firestore/core/src/firebase/firestore/auth/empty_credentials_provider.h @@ -26,7 +26,8 @@ namespace auth { /** `EmptyCredentialsProvider` always yields an empty token. */ class EmptyCredentialsProvider : public CredentialsProvider { public: - void GetToken(bool force_refresh, TokenListener completion) override; + void GetToken(TokenListener completion) override; + void InvalidateToken() override; void SetUserChangeListener(UserChangeListener listener) override; }; diff --git a/Firestore/core/src/firebase/firestore/auth/firebase_credentials_provider_apple.h b/Firestore/core/src/firebase/firestore/auth/firebase_credentials_provider_apple.h index 0e1da31..f54b72f 100644 --- a/Firestore/core/src/firebase/firestore/auth/firebase_credentials_provider_apple.h +++ b/Firestore/core/src/firebase/firestore/auth/firebase_credentials_provider_apple.h @@ -65,10 +65,12 @@ class FirebaseCredentialsProvider : public CredentialsProvider { ~FirebaseCredentialsProvider() override; - void GetToken(bool force_refresh, TokenListener completion) override; + void GetToken(TokenListener completion) override; void SetUserChangeListener(UserChangeListener listener) override; + void InvalidateToken() override; + private: /** * Most contents of the FirebaseCredentialProvider are kept in this @@ -95,6 +97,8 @@ class FirebaseCredentialsProvider : public CredentialsProvider { int user_counter = 0; std::mutex mutex; + + bool force_refresh = false; }; /** diff --git a/Firestore/core/src/firebase/firestore/auth/firebase_credentials_provider_apple.mm b/Firestore/core/src/firebase/firestore/auth/firebase_credentials_provider_apple.mm index 9d5b89e..74858c6 100644 --- a/Firestore/core/src/firebase/firestore/auth/firebase_credentials_provider_apple.mm +++ b/Firestore/core/src/firebase/firestore/auth/firebase_credentials_provider_apple.mm @@ -78,8 +78,7 @@ FirebaseCredentialsProvider::~FirebaseCredentialsProvider() { } } -void FirebaseCredentialsProvider::GetToken(bool force_refresh, - TokenListener completion) { +void FirebaseCredentialsProvider::GetToken(TokenListener completion) { HARD_ASSERT(auth_listener_handle_, "GetToken cannot be called after listener removed."); @@ -121,8 +120,13 @@ void FirebaseCredentialsProvider::GetToken(bool force_refresh, } }; - [contents_->app getTokenForcingRefresh:force_refresh + [contents_->app getTokenForcingRefresh:contents_->force_refresh withCallback:get_token_callback]; + contents_->force_refresh = false; +} + +void FirebaseCredentialsProvider::InvalidateToken() { + contents_->force_refresh = true; } void FirebaseCredentialsProvider::SetUserChangeListener( diff --git a/Firestore/core/src/firebase/firestore/util/CMakeLists.txt b/Firestore/core/src/firebase/firestore/util/CMakeLists.txt index 30589a0..b2c4195 100644 --- a/Firestore/core/src/firebase/firestore/util/CMakeLists.txt +++ b/Firestore/core/src/firebase/firestore/util/CMakeLists.txt @@ -184,6 +184,8 @@ cc_library( iterator_adaptors.h ordered_code.cc ordered_code.h + path.cc + path.h range.h secure_random.h status.cc diff --git a/Firestore/core/src/firebase/firestore/util/path.cc b/Firestore/core/src/firebase/firestore/util/path.cc new file mode 100644 index 0000000..940f12a --- /dev/null +++ b/Firestore/core/src/firebase/firestore/util/path.cc @@ -0,0 +1,84 @@ +/* + * Copyright 2018 Google + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "Firestore/core/src/firebase/firestore/util/path.h" + +namespace firebase { +namespace firestore { +namespace util { + +absl::string_view Path::Basename(absl::string_view pathname) { + size_t slash = pathname.find_last_of('/'); + + if (slash == absl::string_view::npos) { + // No path separator found => the whole string. + return pathname; + } + + // Otherwise everything after the slash is the basename (even if empty string) + return pathname.substr(slash + 1); +} + +absl::string_view Path::Dirname(absl::string_view pathname) { + size_t last_slash = pathname.find_last_of('/'); + + if (last_slash == absl::string_view::npos) { + // No path separator found => empty string. Conformance with POSIX would + // have us return "." here. + return pathname.substr(0, 0); + } + + // Collapse runs of slashes. + size_t nonslash = pathname.find_last_not_of('/', last_slash); + if (nonslash == absl::string_view::npos) { + // All characters preceding the last path separator are slashes + return pathname.substr(0, 1); + } + + last_slash = nonslash + 1; + + // Otherwise everything up to the slash is the parent directory + return pathname.substr(0, last_slash); +} + +bool Path::IsAbsolute(absl::string_view path) { +#if defined(_WIN32) +#error "Handle drive letters" + +#else + return !path.empty() && path.front() == '/'; +#endif +} + +void Path::JoinAppend(std::string* base, absl::string_view path) { + if (IsAbsolute(path)) { + base->assign(path.data(), path.size()); + + } else { + size_t nonslash = base->find_last_not_of('/'); + if (nonslash != std::string::npos) { + base->resize(nonslash + 1); + base->push_back('/'); + } + + // If path started with a slash we'd treat it as absolute above + base->append(path.data(), path.size()); + } +} + +} // namespace util +} // namespace firestore +} // namespace firebase diff --git a/Firestore/core/src/firebase/firestore/util/path.h b/Firestore/core/src/firebase/firestore/util/path.h new file mode 100644 index 0000000..3eda40a --- /dev/null +++ b/Firestore/core/src/firebase/firestore/util/path.h @@ -0,0 +1,101 @@ +/* + * Copyright 2018 Google + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_PATH_H_ +#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_PATH_H_ + +#include <string> +#include <utility> + +#include "absl/strings/string_view.h" + +namespace firebase { +namespace firestore { +namespace util { + +struct Path { + /** + * Returns the unqualified trailing part of the pathname, e.g. "c" for + * "/a/b/c". + */ + static absl::string_view Basename(absl::string_view pathname); + + /** + * Returns the parent directory name, e.g. "/a/b" for "/a/b/c". + * + * Note: + * * Trailing slashes are treated as a separator between an empty path + * segment and the dirname, so Dirname("/a/b/c/") is "/a/b/c". + * * Runs of more than one slash are treated as a single separator, so + * Dirname("/a/b//c") is "/a/b". + * * Paths are not canonicalized, so Dirname("/a//b//c") is "/a//b". + * * Presently only UNIX style paths are supported (but compilation + * intentionally fails on Windows to prompt implementation there). + */ + static absl::string_view Dirname(absl::string_view pathname); + + /** + * Returns true if the given `pathname` is an absolute path. + */ + static bool IsAbsolute(absl::string_view pathname); + + /** + * Returns the paths separated by path separators. + * + * @param base If base is of type std::string&& the result is moved from this + * value. Otherwise the first argument is copied. + * @param paths The rest of the path segments. + */ + template <typename S1, typename... SA> + static std::string Join(S1&& base, const SA&... paths) { + std::string result{std::forward<S1>(base)}; + JoinAppend(&result, paths...); + return result; + } + + /** + * Returns the paths separated by path separators. + */ + static std::string Join() { + return {}; + } + + private: + /** + * Joins the given base path with a suffix. If `path` is relative, appends it + * to the given base path. If `path` is absolute, replaces `base`. + */ + static void JoinAppend(std::string* base, absl::string_view path); + + template <typename... S> + static void JoinAppend(std::string* base, + absl::string_view path, + const S&... rest) { + JoinAppend(base, path); + JoinAppend(base, rest...); + } + + static void JoinAppend(std::string* base) { + // Recursive base case; nothing to do. + (void)base; + } +}; + +} // namespace util +} // namespace firestore +} // namespace firebase + +#endif // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_PATH_H_ diff --git a/Firestore/core/test/firebase/firestore/auth/empty_credentials_provider_test.cc b/Firestore/core/test/firebase/firestore/auth/empty_credentials_provider_test.cc index 60845e5..a2f5780 100644 --- a/Firestore/core/test/firebase/firestore/auth/empty_credentials_provider_test.cc +++ b/Firestore/core/test/firebase/firestore/auth/empty_credentials_provider_test.cc @@ -25,15 +25,14 @@ namespace auth { TEST(EmptyCredentialsProvider, GetToken) { EmptyCredentialsProvider credentials_provider; - credentials_provider.GetToken( - /*force_refresh=*/true, [](util::StatusOr<Token> result) { - EXPECT_TRUE(result.ok()); - const Token& token = result.ValueOrDie(); - EXPECT_ANY_THROW(token.token()); - const User& user = token.user(); - EXPECT_EQ("", user.uid()); - EXPECT_FALSE(user.is_authenticated()); - }); + credentials_provider.GetToken([](util::StatusOr<Token> result) { + EXPECT_TRUE(result.ok()); + const Token& token = result.ValueOrDie(); + EXPECT_ANY_THROW(token.token()); + const User& user = token.user(); + EXPECT_EQ("", user.uid()); + EXPECT_FALSE(user.is_authenticated()); + }); } TEST(EmptyCredentialsProvider, SetListener) { @@ -46,6 +45,13 @@ TEST(EmptyCredentialsProvider, SetListener) { credentials_provider.SetUserChangeListener(nullptr); } +TEST(EmptyCredentialsProvider, InvalidateToken) { + EmptyCredentialsProvider credentials_provider; + credentials_provider.InvalidateToken(); + credentials_provider.GetToken( + [](util::StatusOr<Token> result) { EXPECT_TRUE(result.ok()); }); +} + } // namespace auth } // namespace firestore } // namespace firebase diff --git a/Firestore/core/test/firebase/firestore/auth/firebase_credentials_provider_test.mm b/Firestore/core/test/firebase/firestore/auth/firebase_credentials_provider_test.mm index 9d358b5..873f1b2 100644 --- a/Firestore/core/test/firebase/firestore/auth/firebase_credentials_provider_test.mm +++ b/Firestore/core/test/firebase/firestore/auth/firebase_credentials_provider_test.mm @@ -51,30 +51,28 @@ TEST(FirebaseCredentialsProviderTest, GetTokenUnauthenticated) { FIRApp* app = AppWithFakeUid(nil); FirebaseCredentialsProvider credentials_provider(app); - credentials_provider.GetToken( - /*force_refresh=*/true, [](util::StatusOr<Token> result) { - EXPECT_TRUE(result.ok()); - const Token& token = result.ValueOrDie(); - EXPECT_ANY_THROW(token.token()); - const User& user = token.user(); - EXPECT_EQ("", user.uid()); - EXPECT_FALSE(user.is_authenticated()); - }); + credentials_provider.GetToken([](util::StatusOr<Token> result) { + EXPECT_TRUE(result.ok()); + const Token& token = result.ValueOrDie(); + EXPECT_ANY_THROW(token.token()); + const User& user = token.user(); + EXPECT_EQ("", user.uid()); + EXPECT_FALSE(user.is_authenticated()); + }); } TEST(FirebaseCredentialsProviderTest, GetToken) { FIRApp* app = AppWithFakeUidAndToken(@"fake uid", @"token for fake uid"); FirebaseCredentialsProvider credentials_provider(app); - credentials_provider.GetToken( - /*force_refresh=*/true, [](util::StatusOr<Token> result) { - EXPECT_TRUE(result.ok()); - const Token& token = result.ValueOrDie(); - EXPECT_EQ("token for fake uid", token.token()); - const User& user = token.user(); - EXPECT_EQ("fake uid", user.uid()); - EXPECT_TRUE(user.is_authenticated()); - }); + credentials_provider.GetToken([](util::StatusOr<Token> result) { + EXPECT_TRUE(result.ok()); + const Token& token = result.ValueOrDie(); + EXPECT_EQ("token for fake uid", token.token()); + const User& user = token.user(); + EXPECT_EQ("fake uid", user.uid()); + EXPECT_TRUE(user.is_authenticated()); + }); } TEST(FirebaseCredentialsProviderTest, SetListener) { @@ -89,6 +87,34 @@ TEST(FirebaseCredentialsProviderTest, SetListener) { credentials_provider.SetUserChangeListener(nullptr); } +FIRApp* FakeAppExpectingForceRefreshToken(NSString* _Nullable uid, + NSString* _Nullable token) { + FIRApp* app = testutil::AppForUnitTesting(); + app.getUIDImplementation = ^NSString* { + return uid; + }; + app.getTokenImplementation = + ^(BOOL force_refresh, FIRTokenCallback callback) { + EXPECT_TRUE(force_refresh); + callback(token, nil); + }; + return app; +} + +TEST(FirebaseCredentialsProviderTest, InvalidateToken) { + FIRApp* app = + FakeAppExpectingForceRefreshToken(@"fake uid", @"token for fake uid"); + + FirebaseCredentialsProvider credentials_provider{app}; + credentials_provider.InvalidateToken(); + credentials_provider.GetToken([](util::StatusOr<Token> result) { + EXPECT_TRUE(result.ok()); + const Token& token = result.ValueOrDie(); + EXPECT_EQ("token for fake uid", token.token()); + EXPECT_EQ("fake uid", token.user().uid()); + }); +} + } // namespace auth } // namespace firestore } // namespace firebase diff --git a/Firestore/core/test/firebase/firestore/util/CMakeLists.txt b/Firestore/core/test/firebase/firestore/util/CMakeLists.txt index 44a3b61..f540d7c 100644 --- a/Firestore/core/test/firebase/firestore/util/CMakeLists.txt +++ b/Firestore/core/test/firebase/firestore/util/CMakeLists.txt @@ -126,6 +126,7 @@ cc_test( hashing_test.cc iterator_adaptors_test.cc ordered_code_test.cc + path_test.cc status_test.cc status_test_util.h statusor_test.cc diff --git a/Firestore/core/test/firebase/firestore/util/path_test.cc b/Firestore/core/test/firebase/firestore/util/path_test.cc new file mode 100644 index 0000000..a60e839 --- /dev/null +++ b/Firestore/core/test/firebase/firestore/util/path_test.cc @@ -0,0 +1,240 @@ +/* + * Copyright 2018 Google + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "Firestore/core/src/firebase/firestore/util/path.h" + +#include "gtest/gtest.h" + +namespace firebase { +namespace firestore { +namespace util { + +// There are several potential sources of inspiration for what is correct +// behavior for these functions. +// +// Python: test with +// +// python -c 'import os.path; print(os.path.basename("a/b/c//"))' +// +// POSIX shell: test with +// +// dirname "a/b/c//" +// +// libc++: std::filesystem does not yet ship with Xcode (as of 9.4). Test with a +// new (non-default installed) llvm, e.g. llvm-6.0: +// +// brew install llvm +// llvm=$(brew --prefix)/opt/llvm +// $llvm/bin/clang++ -I$llvm/include -I$llvm/include/c++/v1 -L$llvm/lib +// -Wl,-rpath,$llvm/lib test.cc -lc++experimental && ./a.out +// +// test.cc contains something like: +// #include <experimental/filesystem> +// #include <iostream> +// namespace fs = std::experimental::filesystem; +// int main() { +// std::cout << fs::path("/a/b/c//").parent_path() << std::endl; +// } +// +// cppreference: look up example output in functions declared here: +// https://en.cppreference.com/w/cpp/filesystem/path +// +// This implementation mostly follows python's example: +// +// * It's pretty simple to implement +// * POSIX is more complicated than we need +// * std::filesystem is still too experimental (as of 2018-06-05) + +#define EXPECT_BASENAME_EQ(expected, source) \ + do { \ + EXPECT_EQ(std::string{expected}, Path::Basename(source)); \ + } while (0) + +TEST(Path, Basename_NoSeparator) { + // POSIX would require all of these to be ".". + // python and libc++ agree this is "". + EXPECT_BASENAME_EQ("", ""); + EXPECT_BASENAME_EQ("a", "a"); + EXPECT_BASENAME_EQ("foo", "foo"); + EXPECT_BASENAME_EQ(".", "."); + EXPECT_BASENAME_EQ("..", ".."); +} + +TEST(Path, Basename_LeadingSlash) { + EXPECT_BASENAME_EQ("", "/"); + EXPECT_BASENAME_EQ("", "///"); + EXPECT_BASENAME_EQ("a", "/a"); + EXPECT_BASENAME_EQ("a", "//a"); + + EXPECT_BASENAME_EQ(".", "/."); + EXPECT_BASENAME_EQ("..", "/.."); + EXPECT_BASENAME_EQ("..", "//.."); +} + +TEST(Path, Basename_IntermediateSlash) { + EXPECT_BASENAME_EQ("b", "/a/b"); + EXPECT_BASENAME_EQ("b", "/a//b"); + EXPECT_BASENAME_EQ("b", "//a/b"); + EXPECT_BASENAME_EQ("b", "//a//b"); + + EXPECT_BASENAME_EQ("b", "//..//b"); + EXPECT_BASENAME_EQ("b", "//a/./b"); + EXPECT_BASENAME_EQ("b", "//a/.//b"); +} + +TEST(Path, Basename_TrailingSlash) { + // python: "a/b//" => "" + // POSIX: "a/b//" => "b" + // libc++ path::filename(): "a/b//" => "." (cppreference suggests "") + EXPECT_BASENAME_EQ("", "/a/"); + EXPECT_BASENAME_EQ("", "/a///"); + + EXPECT_BASENAME_EQ("", "/a/b/"); + EXPECT_BASENAME_EQ("", "/a/b//"); + EXPECT_BASENAME_EQ("", "/a//b//"); + EXPECT_BASENAME_EQ("", "//a//b//"); +} + +TEST(Path, Basename_RelativePath) { + EXPECT_BASENAME_EQ("b", "a/b"); + EXPECT_BASENAME_EQ("b", "a//b"); + + EXPECT_BASENAME_EQ("b", "..//b"); + EXPECT_BASENAME_EQ("b", "a/./b"); + EXPECT_BASENAME_EQ("b", "a/.//b"); + EXPECT_BASENAME_EQ("b", "a//.//b"); +} + +#define EXPECT_DIRNAME_EQ(expected, source) \ + do { \ + EXPECT_EQ(std::string{expected}, Path::Dirname(source)); \ + } while (0) + +TEST(Path, Dirname_NoSeparator) { + // POSIX would require all of these to be ".". + // python and libc++ agree this is "". + EXPECT_DIRNAME_EQ("", ""); + EXPECT_DIRNAME_EQ("", "a"); + EXPECT_DIRNAME_EQ("", "foo"); + EXPECT_DIRNAME_EQ("", "."); + EXPECT_DIRNAME_EQ("", ".."); +} + +TEST(Path, Dirname_LeadingSlash) { + // POSIX says all "/". + // python starts with "/" but does not strip trailing slashes. + // libc++ path::parent_path() considers all of these be "", though + // cppreference.com indicates this should be "/" in example output so this is + // likely a bug. + EXPECT_DIRNAME_EQ("/", "/"); + EXPECT_DIRNAME_EQ("/", "///"); + EXPECT_DIRNAME_EQ("/", "/a"); + EXPECT_DIRNAME_EQ("/", "//a"); + + EXPECT_DIRNAME_EQ("/", "/."); + EXPECT_DIRNAME_EQ("/", "/.."); + EXPECT_DIRNAME_EQ("/", "//.."); +} + +TEST(Path, Dirname_IntermediateSlash) { + EXPECT_DIRNAME_EQ("/a", "/a/b"); + EXPECT_DIRNAME_EQ("/a", "/a//b"); + EXPECT_DIRNAME_EQ("//a", "//a/b"); + EXPECT_DIRNAME_EQ("//a", "//a//b"); + + EXPECT_DIRNAME_EQ("//..", "//..//b"); + EXPECT_DIRNAME_EQ("//a/.", "//a/./b"); + EXPECT_DIRNAME_EQ("//a/.", "//a/.//b"); +} + +TEST(Path, Dirname_TrailingSlash) { + // POSIX demands stripping trailing slashes before computing dirname, while + // python and libc++ effectively seem to consider the path to contain an empty + // path segment there. + EXPECT_DIRNAME_EQ("/a", "/a/"); + EXPECT_DIRNAME_EQ("/a", "/a///"); + + EXPECT_DIRNAME_EQ("/a/b", "/a/b/"); + EXPECT_DIRNAME_EQ("/a/b", "/a/b//"); + EXPECT_DIRNAME_EQ("/a//b", "/a//b//"); + EXPECT_DIRNAME_EQ("//a//b", "//a//b//"); +} + +TEST(Path, Dirname_RelativePath) { + EXPECT_DIRNAME_EQ("a", "a/b"); + EXPECT_DIRNAME_EQ("a", "a//b"); + + EXPECT_DIRNAME_EQ("..", "..//b"); + EXPECT_DIRNAME_EQ("a/.", "a/./b"); + EXPECT_DIRNAME_EQ("a/.", "a/.//b"); + EXPECT_DIRNAME_EQ("a//.", "a//.//b"); +} + +TEST(Path, IsAbsolute) { + EXPECT_FALSE(Path::IsAbsolute("")); + EXPECT_TRUE(Path::IsAbsolute("/")); + EXPECT_TRUE(Path::IsAbsolute("//")); + EXPECT_TRUE(Path::IsAbsolute("/foo")); + EXPECT_FALSE(Path::IsAbsolute("foo")); + EXPECT_FALSE(Path::IsAbsolute("foo/bar")); +} + +TEST(Path, Join_Absolute) { + EXPECT_EQ("/", Path::Join("/")); + + EXPECT_EQ("/", Path::Join("", "/")); + EXPECT_EQ("/", Path::Join("a", "/")); + EXPECT_EQ("/b", Path::Join("a", "/b")); + + // Alternate root names should be preserved. + EXPECT_EQ("//", Path::Join("a", "//")); + EXPECT_EQ("//b", Path::Join("a", "//b")); + EXPECT_EQ("///b///", Path::Join("a", "///b///")); + + EXPECT_EQ("/", Path::Join("/", "/")); + EXPECT_EQ("/b", Path::Join("/", "/b")); + EXPECT_EQ("//b", Path::Join("//host/a", "//b")); + EXPECT_EQ("//b", Path::Join("//host/a/", "//b")); + + EXPECT_EQ("/", Path::Join("/", "")); + EXPECT_EQ("/a", Path::Join("/", "a")); + EXPECT_EQ("/a/b/c", Path::Join("/", "a", "b", "c")); + EXPECT_EQ("/a/", Path::Join("/", "a/")); + EXPECT_EQ("/.", Path::Join("/", ".")); + EXPECT_EQ("/..", Path::Join("/", "..")); +} + +TEST(Path, Join_Relative) { + EXPECT_EQ("", Path::Join("")); + + EXPECT_EQ("", Path::Join("", "", "", "")); + EXPECT_EQ("a/b/c", Path::Join("a/b", "c")); + EXPECT_EQ("/c/d", Path::Join("a/b", "/c", "d")); + EXPECT_EQ("/c/d", Path::Join("a/b/", "/c", "d")); +} + +TEST(Path, Join_Types) { + EXPECT_EQ("a/b", Path::Join(absl::string_view{"a"}, "b")); + EXPECT_EQ("a/b", Path::Join(std::string{"a"}, "b")); + + std::string a_string{"a"}; + EXPECT_EQ("a/b", Path::Join(a_string, "b")); + EXPECT_EQ("a", a_string); +} + +} // namespace util +} // namespace firestore +} // namespace firebase |