json-validator/tests/enum_test.cxx

#include <compare>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include <jvalidate/status.h>
#include <jvalidate/validation_visitor.h>

using testing::Eq;
using testing::Not;

TEST(StatusTest, Spaceship) {
  using jvalidate::Status;
  using enum jvalidate::Status::Enum;
  EXPECT_THAT(Status(Accept) <=> Status(Reject), Not(std::strong_ordering::equal));
}

TEST(StatusTest, Not) {
  using jvalidate::Status;
  using enum jvalidate::Status::Enum;
  EXPECT_THAT(!Status(Accept), Eq(Reject));
  EXPECT_THAT(!Status(Reject), Eq(Accept));
  EXPECT_THAT(!Status(Noop), Eq(Noop));
}

TEST(StatusTest, Or) {
  using jvalidate::Status;
  using enum jvalidate::Status::Enum;
  EXPECT_THAT(Status(Accept) | Status(Accept), Eq(Accept));
  EXPECT_THAT(Status(Accept) | Status(Noop), Eq(Accept));
  EXPECT_THAT(Status(Accept) | Status(Reject), Eq(Accept));
  EXPECT_THAT(Status(Noop) | Status(Accept), Eq(Accept));
  EXPECT_THAT(Status(Noop) | Status(Noop), Eq(Noop));
  EXPECT_THAT(Status(Noop) | Status(Reject), Eq(Noop));
  EXPECT_THAT(Status(Reject) | Status(Accept), Eq(Accept));
  EXPECT_THAT(Status(Reject) | Status(Noop), Eq(Noop));
  EXPECT_THAT(Status(Reject) | Status(Reject), Eq(Reject));
}

TEST(StatusTest, And) {
  using jvalidate::Status;
  using enum jvalidate::Status::Enum;
  EXPECT_THAT(Status(Accept) & Status(Accept), Eq(Accept));
  EXPECT_THAT(Status(Accept) & Status(Noop), Eq(Accept));
  EXPECT_THAT(Status(Accept) & Status(Reject), Eq(Reject));
  EXPECT_THAT(Status(Noop) & Status(Accept), Eq(Accept));
  EXPECT_THAT(Status(Noop) & Status(Noop), Eq(Noop));
  EXPECT_THAT(Status(Noop) & Status(Reject), Eq(Reject));
  EXPECT_THAT(Status(Reject) & Status(Accept), Eq(Reject));
  EXPECT_THAT(Status(Reject) & Status(Noop), Eq(Reject));
  EXPECT_THAT(Status(Reject) & Status(Reject), Eq(Reject));
}

TEST(StoreResultsTest, Spaceship) {
  using jvalidate::StoreResults;
  using enum jvalidate::StoreResults::Enum;
  EXPECT_THAT(StoreResults(ForValid) <=> StoreResults(ForInvalid),
              Not(std::strong_ordering::equal));
}

TEST(StoreResultsTest, Not) {
  using jvalidate::StoreResults;
  using enum jvalidate::StoreResults::Enum;
  EXPECT_THAT(!StoreResults(ForValid), Eq(ForInvalid));
  EXPECT_THAT(!StoreResults(ForInvalid), Eq(ForValid));
  EXPECT_THAT(!StoreResults(ForAnything), Eq(ForAnything));
}

TEST(StoreResultsTest, Or) {
  using jvalidate::StoreResults;
  using enum jvalidate::StoreResults::Enum;
  EXPECT_THAT(StoreResults(ForValid) | StoreResults(ForValid), Eq(ForValid));
  EXPECT_THAT(StoreResults(ForValid) | StoreResults(ForAnything), Eq(ForValid));
  EXPECT_THAT(StoreResults(ForValid) | StoreResults(ForInvalid), Eq(ForValid));
  EXPECT_THAT(StoreResults(ForAnything) | StoreResults(ForValid), Eq(ForValid));
  EXPECT_THAT(StoreResults(ForAnything) | StoreResults(ForAnything), Eq(ForAnything));
  EXPECT_THAT(StoreResults(ForAnything) | StoreResults(ForInvalid), Eq(ForAnything));
  EXPECT_THAT(StoreResults(ForInvalid) | StoreResults(ForValid), Eq(ForValid));
  EXPECT_THAT(StoreResults(ForInvalid) | StoreResults(ForAnything), Eq(ForAnything));
  EXPECT_THAT(StoreResults(ForInvalid) | StoreResults(ForInvalid), Eq(ForInvalid));
}

TEST(StoreResultsTest, And) {
  using jvalidate::StoreResults;
  using enum jvalidate::StoreResults::Enum;
  EXPECT_THAT(StoreResults(ForValid) & StoreResults(ForValid), Eq(ForValid));
  EXPECT_THAT(StoreResults(ForValid) & StoreResults(ForAnything), Eq(ForValid));
  EXPECT_THAT(StoreResults(ForValid) & StoreResults(ForInvalid), Eq(ForInvalid));
  EXPECT_THAT(StoreResults(ForAnything) & StoreResults(ForValid), Eq(ForValid));
  EXPECT_THAT(StoreResults(ForAnything) & StoreResults(ForAnything), Eq(ForAnything));
  EXPECT_THAT(StoreResults(ForAnything) & StoreResults(ForInvalid), Eq(ForInvalid));
  EXPECT_THAT(StoreResults(ForInvalid) & StoreResults(ForValid), Eq(ForInvalid));
  EXPECT_THAT(StoreResults(ForInvalid) & StoreResults(ForAnything), Eq(ForInvalid));
  EXPECT_THAT(StoreResults(ForInvalid) & StoreResults(ForInvalid), Eq(ForInvalid));
}

#if !defined(JVALIDATE_MONOTEST)
int main(int argc, char ** argv) {
  testing::InitGoogleMock(&argc, argv);
  return RUN_ALL_TESTS();
}
#endif