third_party/pigweed/repo/pw_status/status_with_size_test.cc

   1 // Copyright 2020 The Pigweed Authors
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
   4 // use this file except in compliance with the License. You may obtain a copy of
   5 // the License at
   6 //
   7 //     https://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  12 // License for the specific language governing permissions and limitations under
  13 // the License.
  14
  15 #include "pw_status/status_with_size.h"
  16
  17 #include "gtest/gtest.h"
  18
  19 namespace pw {
  20 namespace {
  21
  22 static_assert(StatusWithSize::max_size() ==
  23                   (static_cast<size_t>(1) << (sizeof(size_t) * 8 - 5)) - 1,
  24               "max_size() should use all but the top 5 bits of a size_t.");
  25
  26 TEST(StatusWithSize, Default) {
  27   StatusWithSize result;
  28   EXPECT_TRUE(result.ok());
  29   EXPECT_EQ(Status(), result.status());
  30   EXPECT_EQ(0u, result.size());
  31 }
  32
  33 TEST(StatusWithSize, ConstructWithSize) {
  34   StatusWithSize result = StatusWithSize(456);
  35   EXPECT_TRUE(result.ok());
  36   EXPECT_EQ(Status(), result.status());
  37   EXPECT_EQ(456u, result.size());
  38 }
  39
  40 TEST(StatusWithSize, ConstructWithError) {
  41   StatusWithSize result(Status::ResourceExhausted(), 123);
  42   EXPECT_FALSE(result.ok());
  43   EXPECT_EQ(Status::ResourceExhausted(), result.status());
  44   EXPECT_EQ(123u, result.size());
  45 }
  46
  47 TEST(StatusWithSize, ConstructWithOkAndSize) {
  48   StatusWithSize result(Status(), 99);
  49   EXPECT_TRUE(result.ok());
  50   EXPECT_EQ(Status(), result.status());
  51   EXPECT_EQ(99u, result.size());
  52 }
  53
  54 TEST(StatusWithSize, ConstructFromConstant) {
  55   StatusWithSize result(StatusWithSize::AlreadyExists());
  56
  57   EXPECT_EQ(Status::AlreadyExists(), result.status());
  58   EXPECT_EQ(0u, result.size());
  59
  60   result = StatusWithSize::NotFound();
  61
  62   EXPECT_EQ(Status::NotFound(), result.status());
  63   EXPECT_EQ(0u, result.size());
  64 }
  65
  66 TEST(StatusWithSize, AllStatusValues_ZeroSize) {
  67   for (int i = 0; i < 32; ++i) {
  68     StatusWithSize result(static_cast<Status::Code>(i), 0);
  69     EXPECT_EQ(result.ok(), i == 0);
  70     EXPECT_EQ(i, static_cast<int>(result.status().code()));
  71     EXPECT_EQ(0u, result.size());
  72   }
  73 }
  74
  75 TEST(StatusWithSize, AllStatusValues_SameSize) {
  76   for (int i = 0; i < 32; ++i) {
  77     StatusWithSize result(static_cast<Status::Code>(i), i);
  78     EXPECT_EQ(result.ok(), i == 0);
  79     EXPECT_EQ(i, static_cast<int>(result.status().code()));
  80     EXPECT_EQ(static_cast<size_t>(i), result.size());
  81   }
  82 }
  83
  84 TEST(StatusWithSize, AllStatusValues_MaxSize) {
  85   for (int i = 0; i < 32; ++i) {
  86     StatusWithSize result(static_cast<Status::Code>(i),
  87                           StatusWithSize::max_size());
  88     EXPECT_EQ(result.ok(), i == 0);
  89     EXPECT_EQ(i, static_cast<int>(result.status().code()));
  90     EXPECT_EQ(result.max_size(), result.size());
  91   }
  92 }
  93
  94 TEST(StatusWithSize, Assignment) {
  95   StatusWithSize result = StatusWithSize(Status::Internal(), 0x123);
  96   EXPECT_FALSE(result.ok());
  97   EXPECT_EQ(Status::Internal(), result.status());
  98   EXPECT_EQ(0x123u, result.size());
  99
 100   result = StatusWithSize(300);
 101   EXPECT_TRUE(result.ok());
 102   EXPECT_EQ(Status(), result.status());
 103   EXPECT_EQ(300u, result.size());
 104 }
 105
 106 TEST(StatusWithSize, Constexpr) {
 107   constexpr StatusWithSize result(Status::Cancelled(), 1234);
 108   static_assert(Status::Cancelled() == result.status());
 109   static_assert(!result.ok());
 110   static_assert(1234u == result.size());
 111 }
 112
 113 TEST(StatusWithSize, Functions_Status) {
 114   // clang-format off
 115   static_assert(StatusWithSize(0).status() == Status());
 116   static_assert(StatusWithSize::Cancelled().status() == Status::Cancelled());
 117   static_assert(StatusWithSize::Unknown().status() == Status::Unknown());
 118   static_assert(StatusWithSize::InvalidArgument().status() == Status::InvalidArgument());
 119   static_assert(StatusWithSize::DeadlineExceeded().status() == Status::DeadlineExceeded());
 120   static_assert(StatusWithSize::NotFound().status() == Status::NotFound());
 121   static_assert(StatusWithSize::AlreadyExists().status() == Status::AlreadyExists());
 122   static_assert(StatusWithSize::PermissionDenied().status() == Status::PermissionDenied());
 123   static_assert(StatusWithSize::Unauthenticated().status() == Status::Unauthenticated());
 124   static_assert(StatusWithSize::ResourceExhausted().status() == Status::ResourceExhausted());
 125   static_assert(StatusWithSize::FailedPrecondition().status() == Status::FailedPrecondition());
 126   static_assert(StatusWithSize::Aborted().status() == Status::Aborted());
 127   static_assert(StatusWithSize::OutOfRange().status() == Status::OutOfRange());
 128   static_assert(StatusWithSize::Unimplemented().status() == Status::Unimplemented());
 129   static_assert(StatusWithSize::Internal().status() == Status::Internal());
 130   static_assert(StatusWithSize::Unavailable().status() == Status::Unavailable());
 131   static_assert(StatusWithSize::DataLoss().status() == Status::DataLoss());
 132
 133   static_assert(StatusWithSize(123).status() == Status());
 134   static_assert(StatusWithSize::Cancelled(123).status() == Status::Cancelled());
 135   static_assert(StatusWithSize::Unknown(123).status() == Status::Unknown());
 136   static_assert(StatusWithSize::InvalidArgument(123).status() == Status::InvalidArgument());
 137   static_assert(StatusWithSize::DeadlineExceeded(123).status() == Status::DeadlineExceeded());
 138   static_assert(StatusWithSize::NotFound(123).status() == Status::NotFound());
 139   static_assert(StatusWithSize::AlreadyExists(123).status() == Status::AlreadyExists());
 140   static_assert(StatusWithSize::PermissionDenied(123).status() == Status::PermissionDenied());
 141   static_assert(StatusWithSize::Unauthenticated(123).status() == Status::Unauthenticated());
 142   static_assert(StatusWithSize::ResourceExhausted(123).status() == Status::ResourceExhausted());
 143   static_assert(StatusWithSize::FailedPrecondition(123).status() == Status::FailedPrecondition());
 144   static_assert(StatusWithSize::Aborted(123).status() == Status::Aborted());
 145   static_assert(StatusWithSize::OutOfRange(123).status() == Status::OutOfRange());
 146   static_assert(StatusWithSize::Unimplemented(123).status() == Status::Unimplemented());
 147   static_assert(StatusWithSize::Internal(123).status() == Status::Internal());
 148   static_assert(StatusWithSize::Unavailable(123).status() == Status::Unavailable());
 149   static_assert(StatusWithSize::DataLoss(123).status() == Status::DataLoss());
 150   // clang-format on
 151 }
 152
 153 TEST(StatusWithSize, Functions_DefaultSize) {
 154   static_assert(StatusWithSize::Cancelled().size() == 0u);
 155   static_assert(StatusWithSize::Unknown().size() == 0u);
 156   static_assert(StatusWithSize::InvalidArgument().size() == 0u);
 157   static_assert(StatusWithSize::DeadlineExceeded().size() == 0u);
 158   static_assert(StatusWithSize::NotFound().size() == 0u);
 159   static_assert(StatusWithSize::AlreadyExists().size() == 0u);
 160   static_assert(StatusWithSize::PermissionDenied().size() == 0u);
 161   static_assert(StatusWithSize::Unauthenticated().size() == 0u);
 162   static_assert(StatusWithSize::ResourceExhausted().size() == 0u);
 163   static_assert(StatusWithSize::FailedPrecondition().size() == 0u);
 164   static_assert(StatusWithSize::Aborted().size() == 0u);
 165   static_assert(StatusWithSize::OutOfRange().size() == 0u);
 166   static_assert(StatusWithSize::Unimplemented().size() == 0u);
 167   static_assert(StatusWithSize::Internal().size() == 0u);
 168   static_assert(StatusWithSize::Unavailable().size() == 0u);
 169   static_assert(StatusWithSize::DataLoss().size() == 0u);
 170 }
 171
 172 TEST(StatusWithSize, Functions_SpecifiedSize) {
 173   static_assert(StatusWithSize(123).size() == 123u);
 174   static_assert(StatusWithSize::Cancelled(123).size() == 123u);
 175   static_assert(StatusWithSize::Unknown(123).size() == 123u);
 176   static_assert(StatusWithSize::InvalidArgument(123).size() == 123u);
 177   static_assert(StatusWithSize::DeadlineExceeded(123).size() == 123u);
 178   static_assert(StatusWithSize::NotFound(123).size() == 123u);
 179   static_assert(StatusWithSize::AlreadyExists(123).size() == 123u);
 180   static_assert(StatusWithSize::PermissionDenied(123).size() == 123u);
 181   static_assert(StatusWithSize::Unauthenticated(123).size() == 123u);
 182   static_assert(StatusWithSize::ResourceExhausted(123).size() == 123u);
 183   static_assert(StatusWithSize::FailedPrecondition(123).size() == 123u);
 184   static_assert(StatusWithSize::Aborted(123).size() == 123u);
 185   static_assert(StatusWithSize::OutOfRange(123).size() == 123u);
 186   static_assert(StatusWithSize::Unimplemented(123).size() == 123u);
 187   static_assert(StatusWithSize::Internal(123).size() == 123u);
 188   static_assert(StatusWithSize::Unavailable(123).size() == 123u);
 189   static_assert(StatusWithSize::DataLoss(123).size() == 123u);
 190 }
 191
 192 TEST(StatusWithSize, IsError) {
 193   static_assert(StatusWithSize::Cancelled().IsCancelled());
 194   static_assert(StatusWithSize::Unknown().IsUnknown());
 195   static_assert(StatusWithSize::InvalidArgument().IsInvalidArgument());
 196   static_assert(StatusWithSize::DeadlineExceeded().IsDeadlineExceeded());
 197   static_assert(StatusWithSize::NotFound().IsNotFound());
 198   static_assert(StatusWithSize::AlreadyExists().IsAlreadyExists());
 199   static_assert(StatusWithSize::PermissionDenied().IsPermissionDenied());
 200   static_assert(StatusWithSize::ResourceExhausted().IsResourceExhausted());
 201   static_assert(StatusWithSize::FailedPrecondition().IsFailedPrecondition());
 202   static_assert(StatusWithSize::Aborted().IsAborted());
 203   static_assert(StatusWithSize::OutOfRange().IsOutOfRange());
 204   static_assert(StatusWithSize::Unimplemented().IsUnimplemented());
 205   static_assert(StatusWithSize::Internal().IsInternal());
 206   static_assert(StatusWithSize::Unavailable().IsUnavailable());
 207   static_assert(StatusWithSize::DataLoss().IsDataLoss());
 208   static_assert(StatusWithSize::Unauthenticated().IsUnauthenticated());
 209 }
 210
 211 TEST(StatusWithSize, IsNotError) {
 212   static_assert(!StatusWithSize(0).IsCancelled());
 213   static_assert(!StatusWithSize(0).IsUnknown());
 214   static_assert(!StatusWithSize(0).IsInvalidArgument());
 215   static_assert(!StatusWithSize(0).IsDeadlineExceeded());
 216   static_assert(!StatusWithSize(0).IsNotFound());
 217   static_assert(!StatusWithSize(0).IsAlreadyExists());
 218   static_assert(!StatusWithSize(0).IsPermissionDenied());
 219   static_assert(!StatusWithSize(0).IsUnauthenticated());
 220   static_assert(!StatusWithSize(0).IsResourceExhausted());
 221   static_assert(!StatusWithSize(0).IsFailedPrecondition());
 222   static_assert(!StatusWithSize(0).IsAborted());
 223   static_assert(!StatusWithSize(0).IsOutOfRange());
 224   static_assert(!StatusWithSize(0).IsUnimplemented());
 225   static_assert(!StatusWithSize(0).IsInternal());
 226   static_assert(!StatusWithSize(0).IsUnavailable());
 227   static_assert(!StatusWithSize(0).IsDataLoss());
 228 }
 229 }  // namespace
 230 }  // namespace pw