Esempio n. 1
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());
}
Esempio n. 2
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());
}
Esempio n. 3
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, {}));
}