示例#1
0
// Tests reading and writing of a single long variant from and to binary files
TEST_F(TestVariant, FileIOBinaryIOMultipleTypes) {
    BinaryFileStream stream;

    // Values we'll be testing for
    long value1 = 123;
    std::string value2 = "test";
    auto value3 = nullptr;

    // Initialize variants
    Variant variant1(value1);
    Variant variant2(value2);
    Variant variant3(value3);

    // Open stream for writing
    stream.open(filename, std::ios::out);

    // Write variants
    stream << variant1;
    stream << variant2;
    stream << variant3;

    // Close stream
    stream.close();

    // Open stream for reading
    stream.open(filename, std::ios::in);

    // Initialize a final variant for storage of data read from the stream
    Variant variant("a value that must not conflict with the tests");

    stream >> variant;
    EXPECT_EQ(variant, value1);

    stream >> variant;
    EXPECT_EQ(variant, value2);

    stream >> variant;
    EXPECT_EQ(variant, value3);

    // Lets make sure this was all the data. We need to read again to set the
    // EOF bit
    char tc;
    EXPECT_FALSE(stream.get(tc));

    // Ensure EOF
    EXPECT_TRUE(stream.eof());

    // Close stream
    stream.close();
}
示例#2
0
TEST(TestSortUtils, Sort_SortDescription)
{
  SortItems items;

  CVariant variant1("M Artist");
  SortItem item1;
  item1[FieldArtist] = variant1;
  CVariant variant2("B Artist");
  SortItem item2;
  item2[FieldArtist] = variant2;
  CVariant variant3("R Artist");
  SortItem item3;
  item3[FieldArtist] = variant3;
  CVariant variant4("R Artist");
  SortItem item4;
  item4[FieldArtist] = variant4;
  CVariant variant5("I Artist");
  SortItem item5;
  item5[FieldArtist] = variant5;
  CVariant variant6("A Artist");
  SortItem item6;
  item6[FieldArtist] = variant6;
  CVariant variant7("G Artist");
  SortItem item7;
  item7[FieldArtist] = variant7;

  items.push_back(item1);
  items.push_back(item2);
  items.push_back(item3);
  items.push_back(item4);
  items.push_back(item5);
  items.push_back(item6);
  items.push_back(item7);

  SortDescription desc;
  desc.sortBy = SortByArtist;
  SortUtils::Sort(desc, items);

  EXPECT_STREQ("A Artist", items.at(0)[FieldArtist].asString().c_str());
  EXPECT_STREQ("B Artist", items.at(1)[FieldArtist].asString().c_str());
  EXPECT_STREQ("G Artist", items.at(2)[FieldArtist].asString().c_str());
  EXPECT_STREQ("I Artist", items.at(3)[FieldArtist].asString().c_str());
  EXPECT_STREQ("M Artist", items.at(4)[FieldArtist].asString().c_str());
  EXPECT_STREQ("R Artist", items.at(5)[FieldArtist].asString().c_str());
  EXPECT_STREQ("R Artist", items.at(6)[FieldArtist].asString().c_str());
}
示例#3
0
TEST(TestSortUtils, Sort_SortBy)
{
  SortItems items;

  CVariant variant1("M Artist");
  SortItem item1;
  item1[FieldArtist] = variant1;
  CVariant variant2("B Artist");
  SortItem item2;
  item2[FieldArtist] = variant2;
  CVariant variant3("R Artist");
  SortItem item3;
  item3[FieldArtist] = variant3;
  CVariant variant4("R Artist");
  SortItem item4;
  item4[FieldArtist] = variant4;
  CVariant variant5("I Artist");
  SortItem item5;
  item5[FieldArtist] = variant5;
  CVariant variant6("A Artist");
  SortItem item6;
  item6[FieldArtist] = variant6;
  CVariant variant7("G Artist");
  SortItem item7;
  item7[FieldArtist] = variant7;

  items.push_back(item1);
  items.push_back(item2);
  items.push_back(item3);
  items.push_back(item4);
  items.push_back(item5);
  items.push_back(item6);
  items.push_back(item7);

  SortUtils::Sort(SortByArtist, SortOrderAscending, SortAttributeNone, items);

  EXPECT_STREQ("A Artist", items.at(0)[FieldArtist].asString().c_str());
  EXPECT_STREQ("B Artist", items.at(1)[FieldArtist].asString().c_str());
  EXPECT_STREQ("G Artist", items.at(2)[FieldArtist].asString().c_str());
  EXPECT_STREQ("I Artist", items.at(3)[FieldArtist].asString().c_str());
  EXPECT_STREQ("M Artist", items.at(4)[FieldArtist].asString().c_str());
  EXPECT_STREQ("R Artist", items.at(5)[FieldArtist].asString().c_str());
  EXPECT_STREQ("R Artist", items.at(6)[FieldArtist].asString().c_str());
}
TEST_F(VariantTests, testComparison)
{
  //test comparison between two different types of variant
  OpenAB::Variant variant1("hello");
  OpenAB::Variant variant2(123);
  ASSERT_FALSE(variant1 == variant2);

  //test comparison between char types
  variant1.set('a');
  variant2.set('a');
  ASSERT_TRUE(variant1 == variant2);

  variant2.set('b');
  ASSERT_FALSE(variant1 == variant2);

  //test comparison between bool types
  variant1.set(true);
  variant2.set(true);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set(false);
  ASSERT_FALSE(variant1 == variant2);

  //test comparison between pointer types
  variant1.set((void*)0xBAAD);
  variant2.set((void*)0xBAAD);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set((void*)0xF00D);
  ASSERT_FALSE(variant1 == variant2);

  //test comparison between string types
  variant1.set("hello");
  variant2.set(std::string("hello"));
  ASSERT_TRUE(variant1 == variant2);

  variant2.set(std::string("goodbye"));
  ASSERT_FALSE(variant1 == variant2);


  //test comparison between secure string types
  variant1.set(OpenAB::SecureString("hello"));
  variant2 = variant1;
  ASSERT_TRUE(variant1 == variant2);

  //each secure string will be different even if containing the same string
  variant2.set(OpenAB::SecureString("hello"));
  ASSERT_FALSE(variant1 == variant2);

  //test comparison between float types
  variant1.set(123.45f);
  variant2.set(123.45f);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set(543.21f);
  ASSERT_FALSE(variant1 == variant2);

  //test comparison between double types
  variant1.set(123.45);
  variant2.set(123.45);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set(543.21);
  ASSERT_FALSE(variant1 == variant2);

  //test comparison between int types
  variant1.set((u_int8_t)123);
  variant2.set((u_int8_t)123);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set((u_int8_t)321);
  ASSERT_FALSE(variant1 == variant2);


  variant1.set((u_int16_t)123);
  variant2.set((u_int16_t)123);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set((u_int16_t)321);
  ASSERT_FALSE(variant1 == variant2);


  variant1.set((u_int32_t)123);
  variant2.set((u_int32_t)123);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set((u_int32_t)321);
  ASSERT_FALSE(variant1 == variant2);


  variant1.set((int8_t)123);
  variant2.set((int8_t)123);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set((int8_t)321);
  ASSERT_FALSE(variant1 == variant2);


  variant1.set((int16_t)123);
  variant2.set((int16_t)123);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set((int16_t)321);
  ASSERT_FALSE(variant1 == variant2);


  variant1.set((int32_t)123);
  variant2.set((int32_t)123);
  ASSERT_TRUE(variant1 == variant2);

  variant2.set((int32_t)321);
  ASSERT_FALSE(variant1 == variant2);
}
示例#5
0
TEST(FunctionRef, OverloadedFunctor) {
  struct OverloadedFunctor {
    // variant 1
    int operator()(int x) {
      return 100 + 1 * x;
    }

    // variant 2 (const-overload of v1)
    int operator()(int x) const {
      return 100 + 2 * x;
    }

    // variant 3
    int operator()(int x, int) {
      return 100 + 3 * x;
    }

    // variant 4 (const-overload of v3)
    int operator()(int x, int) const {
      return 100 + 4 * x;
    }

    // variant 5 (non-const, has no const-overload)
    int operator()(int x, char const*) {
      return 100 + 5 * x;
    }

    // variant 6 (const only)
    int operator()(int x, std::vector<int> const&) const {
      return 100 + 6 * x;
    }
  };
  OverloadedFunctor of;
  auto const& cof = of;

  FunctionRef<int(int)> variant1 = of;
  EXPECT_EQ(100 + 1 * 15, variant1(15));
  FunctionRef<int(int)> const cvariant1 = of;
  EXPECT_EQ(100 + 1 * 15, cvariant1(15));

  FunctionRef<int(int)> variant2 = cof;
  EXPECT_EQ(100 + 2 * 16, variant2(16));
  FunctionRef<int(int)> const cvariant2 = cof;
  EXPECT_EQ(100 + 2 * 16, cvariant2(16));

  FunctionRef<int(int, int)> variant3 = of;
  EXPECT_EQ(100 + 3 * 17, variant3(17, 0));
  FunctionRef<int(int, int)> const cvariant3 = of;
  EXPECT_EQ(100 + 3 * 17, cvariant3(17, 0));

  FunctionRef<int(int, int)> variant4 = cof;
  EXPECT_EQ(100 + 4 * 18, variant4(18, 0));
  FunctionRef<int(int, int)> const cvariant4 = cof;
  EXPECT_EQ(100 + 4 * 18, cvariant4(18, 0));

  FunctionRef<int(int, char const*)> variant5 = of;
  EXPECT_EQ(100 + 5 * 19, variant5(19, "foo"));
  FunctionRef<int(int, char const*)> const cvariant5 = of;
  EXPECT_EQ(100 + 5 * 19, cvariant5(19, "foo"));

  FunctionRef<int(int, std::vector<int> const&)> variant6 = of;
  EXPECT_EQ(100 + 6 * 20, variant6(20, {}));
  EXPECT_EQ(100 + 6 * 20, variant6(20, {1, 2, 3}));
  FunctionRef<int(int, std::vector<int> const&)> const cvariant6 = of;
  EXPECT_EQ(100 + 6 * 20, cvariant6(20, {}));
  EXPECT_EQ(100 + 6 * 20, cvariant6(20, {1, 2, 3}));

  FunctionRef<int(int, std::vector<int> const&)> variant6const = cof;
  EXPECT_EQ(100 + 6 * 21, variant6const(21, {}));
  FunctionRef<int(int, std::vector<int> const&)> const cvariant6const = cof;
  EXPECT_EQ(100 + 6 * 21, cvariant6const(21, {}));
}