blob: 33102b7ea1eb1b6efafe46d688d8e5851aee92f3 [file] [log] [blame]
// Copyright 2020 The Pigweed Authors
//
// 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
//
// https://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 "pw_status/status.h"
#include "gtest/gtest.h"
namespace pw {
namespace {
constexpr Status::Code kInvalidCode = static_cast<Status::Code>(30);
TEST(Status, Default) {
constexpr Status status;
static_assert(status.ok());
static_assert(Status() == status);
}
TEST(Status, ConstructWithStatusCode) {
constexpr Status status(PW_STATUS_ABORTED);
static_assert(status.IsAborted());
}
TEST(Status, AssignFromStatusCode) {
Status status;
status = PW_STATUS_INTERNAL;
EXPECT_EQ(Status::Internal(), status);
}
TEST(Status, Ok_OkIsTrue) {
static_assert(Status().ok());
static_assert(Status(PW_STATUS_OK).ok());
static_assert(OkStatus().ok());
}
TEST(Status, NotOk_OkIsFalse) {
static_assert(!Status::DataLoss().ok());
static_assert(!Status(kInvalidCode).ok());
}
TEST(Status, Code) {
// clang-format off
static_assert(PW_STATUS_OK == Status().code());
static_assert(PW_STATUS_OK == OkStatus().code());
static_assert(PW_STATUS_CANCELLED == Status::Cancelled().code());
static_assert(PW_STATUS_UNKNOWN == Status::Unknown().code());
static_assert(PW_STATUS_INVALID_ARGUMENT == Status::InvalidArgument().code());
static_assert(PW_STATUS_DEADLINE_EXCEEDED == Status::DeadlineExceeded().code());
static_assert(PW_STATUS_NOT_FOUND == Status::NotFound().code());
static_assert(PW_STATUS_ALREADY_EXISTS == Status::AlreadyExists().code());
static_assert(PW_STATUS_PERMISSION_DENIED == Status::PermissionDenied().code());
static_assert(PW_STATUS_RESOURCE_EXHAUSTED == Status::ResourceExhausted().code());
static_assert(PW_STATUS_FAILED_PRECONDITION == Status::FailedPrecondition().code());
static_assert(PW_STATUS_ABORTED == Status::Aborted().code());
static_assert(PW_STATUS_OUT_OF_RANGE == Status::OutOfRange().code());
static_assert(PW_STATUS_UNIMPLEMENTED == Status::Unimplemented().code());
static_assert(PW_STATUS_INTERNAL == Status::Internal().code());
static_assert(PW_STATUS_UNAVAILABLE == Status::Unavailable().code());
static_assert(PW_STATUS_DATA_LOSS == Status::DataLoss().code());
static_assert(PW_STATUS_UNAUTHENTICATED == Status::Unauthenticated().code());
// clang-format on
}
TEST(Status, EqualCodes) {
static_assert(PW_STATUS_OK == Status());
static_assert(PW_STATUS_OK == OkStatus());
static_assert(PW_STATUS_CANCELLED == Status::Cancelled());
static_assert(PW_STATUS_UNKNOWN == Status::Unknown());
static_assert(PW_STATUS_INVALID_ARGUMENT == Status::InvalidArgument());
static_assert(PW_STATUS_DEADLINE_EXCEEDED == Status::DeadlineExceeded());
static_assert(PW_STATUS_NOT_FOUND == Status::NotFound());
static_assert(PW_STATUS_ALREADY_EXISTS == Status::AlreadyExists());
static_assert(PW_STATUS_PERMISSION_DENIED == Status::PermissionDenied());
static_assert(PW_STATUS_RESOURCE_EXHAUSTED == Status::ResourceExhausted());
static_assert(PW_STATUS_FAILED_PRECONDITION == Status::FailedPrecondition());
static_assert(PW_STATUS_ABORTED == Status::Aborted());
static_assert(PW_STATUS_OUT_OF_RANGE == Status::OutOfRange());
static_assert(PW_STATUS_UNIMPLEMENTED == Status::Unimplemented());
static_assert(PW_STATUS_INTERNAL == Status::Internal());
static_assert(PW_STATUS_UNAVAILABLE == Status::Unavailable());
static_assert(PW_STATUS_DATA_LOSS == Status::DataLoss());
static_assert(PW_STATUS_UNAUTHENTICATED == Status::Unauthenticated());
}
TEST(Status, IsError) {
static_assert(Status::Cancelled().IsCancelled());
static_assert(Status::Unknown().IsUnknown());
static_assert(Status::InvalidArgument().IsInvalidArgument());
static_assert(Status::DeadlineExceeded().IsDeadlineExceeded());
static_assert(Status::NotFound().IsNotFound());
static_assert(Status::AlreadyExists().IsAlreadyExists());
static_assert(Status::PermissionDenied().IsPermissionDenied());
static_assert(Status::ResourceExhausted().IsResourceExhausted());
static_assert(Status::FailedPrecondition().IsFailedPrecondition());
static_assert(Status::Aborted().IsAborted());
static_assert(Status::OutOfRange().IsOutOfRange());
static_assert(Status::Unimplemented().IsUnimplemented());
static_assert(Status::Internal().IsInternal());
static_assert(Status::Unavailable().IsUnavailable());
static_assert(Status::DataLoss().IsDataLoss());
static_assert(Status::Unauthenticated().IsUnauthenticated());
}
TEST(Status, IsNotError) {
static_assert(!OkStatus().IsCancelled());
static_assert(!OkStatus().IsUnknown());
static_assert(!OkStatus().IsInvalidArgument());
static_assert(!OkStatus().IsDeadlineExceeded());
static_assert(!OkStatus().IsNotFound());
static_assert(!OkStatus().IsAlreadyExists());
static_assert(!OkStatus().IsPermissionDenied());
static_assert(!OkStatus().IsUnauthenticated());
static_assert(!OkStatus().IsResourceExhausted());
static_assert(!OkStatus().IsFailedPrecondition());
static_assert(!OkStatus().IsAborted());
static_assert(!OkStatus().IsOutOfRange());
static_assert(!OkStatus().IsUnimplemented());
static_assert(!OkStatus().IsInternal());
static_assert(!OkStatus().IsUnavailable());
static_assert(!OkStatus().IsDataLoss());
}
TEST(Status, Strings) {
EXPECT_STREQ("OK", Status().str());
EXPECT_STREQ("OK", OkStatus().str());
EXPECT_STREQ("CANCELLED", Status::Cancelled().str());
EXPECT_STREQ("UNKNOWN", Status::Unknown().str());
EXPECT_STREQ("INVALID_ARGUMENT", Status::InvalidArgument().str());
EXPECT_STREQ("DEADLINE_EXCEEDED", Status::DeadlineExceeded().str());
EXPECT_STREQ("NOT_FOUND", Status::NotFound().str());
EXPECT_STREQ("ALREADY_EXISTS", Status::AlreadyExists().str());
EXPECT_STREQ("PERMISSION_DENIED", Status::PermissionDenied().str());
EXPECT_STREQ("RESOURCE_EXHAUSTED", Status::ResourceExhausted().str());
EXPECT_STREQ("FAILED_PRECONDITION", Status::FailedPrecondition().str());
EXPECT_STREQ("ABORTED", Status::Aborted().str());
EXPECT_STREQ("OUT_OF_RANGE", Status::OutOfRange().str());
EXPECT_STREQ("UNIMPLEMENTED", Status::Unimplemented().str());
EXPECT_STREQ("INTERNAL", Status::Internal().str());
EXPECT_STREQ("UNAVAILABLE", Status::Unavailable().str());
EXPECT_STREQ("DATA_LOSS", Status::DataLoss().str());
EXPECT_STREQ("UNAUTHENTICATED", Status::Unauthenticated().str());
}
TEST(Status, UnknownString) {
EXPECT_STREQ("INVALID STATUS", Status(kInvalidCode).str());
}
TEST(Status, Update) {
Status status;
status.Update(Status::Cancelled());
EXPECT_EQ(status, Status::Cancelled());
status.Update(OkStatus());
EXPECT_EQ(status, Status::Cancelled());
status.Update(Status::NotFound());
EXPECT_EQ(status, Status::Cancelled());
}
// Functions for executing the C pw_Status tests.
extern "C" {
Status::Code PassStatusFromC(Status status);
Status::Code PassStatusFromCpp(Status status) { return status.code(); }
int TestStatusFromC(void);
int TestStatusStringsFromC(void);
} // extern "C"
TEST(StatusCLinkage, CallCFunctionWithStatus) {
EXPECT_EQ(Status::Aborted(), PassStatusFromC(PW_STATUS_ABORTED));
EXPECT_EQ(Status::Unknown(), PassStatusFromC(Status::Unknown()));
EXPECT_EQ(Status::NotFound(), PassStatusFromC(PW_STATUS_NOT_FOUND));
EXPECT_EQ(OkStatus(), PassStatusFromC(OkStatus()));
}
TEST(StatusCLinkage, TestStatusFromC) { EXPECT_EQ(0, TestStatusFromC()); }
TEST(StatusCLinkage, TestStatusStringsFromC) {
EXPECT_EQ(0, TestStatusStringsFromC());
}
} // namespace
} // namespace pw