1//===----------- VariadicFunctionTest.cpp - VariadicFunction unit tests ---===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "gtest/gtest.h" 11#include "llvm/ADT/ArrayRef.h" 12#include "llvm/ADT/VariadicFunction.h" 13 14using namespace llvm; 15namespace { 16 17// Defines a variadic function StringCat() to join strings. 18// StringCat()'s arguments and return value have class types. 19std::string StringCatImpl(ArrayRef<const std::string *> Args) { 20 std::string S; 21 for (unsigned i = 0, e = Args.size(); i < e; ++i) 22 S += *Args[i]; 23 return S; 24} 25const VariadicFunction<std::string, std::string, StringCatImpl> StringCat = {}; 26 27TEST(VariadicFunctionTest, WorksForClassTypes) { 28 EXPECT_EQ("", StringCat()); 29 EXPECT_EQ("a", StringCat("a")); 30 EXPECT_EQ("abc", StringCat("a", "bc")); 31 EXPECT_EQ("0123456789abcdefghijklmnopqrstuv", 32 StringCat("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 33 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", 34 "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", 35 "u", "v")); 36} 37 38// Defines a variadic function Sum(), whose arguments and return value 39// have primitive types. 40// The return type of SumImp() is deliberately different from its 41// argument type, as we want to test that this works. 42long SumImpl(ArrayRef<const int *> Args) { 43 long Result = 0; 44 for (unsigned i = 0, e = Args.size(); i < e; ++i) 45 Result += *Args[i]; 46 return Result; 47} 48const VariadicFunction<long, int, SumImpl> Sum = {}; 49 50TEST(VariadicFunctionTest, WorksForPrimitiveTypes) { 51 EXPECT_EQ(0, Sum()); 52 EXPECT_EQ(1, Sum(1)); 53 EXPECT_EQ(12, Sum(10, 2)); 54 EXPECT_EQ(1234567, Sum(1000000, 200000, 30000, 4000, 500, 60, 7)); 55} 56 57// Appends an array of strings to dest and returns the number of 58// characters appended. 59int StringAppendImpl(std::string *Dest, ArrayRef<const std::string *> Args) { 60 int Chars = 0; 61 for (unsigned i = 0, e = Args.size(); i < e; ++i) { 62 Chars += Args[i]->size(); 63 *Dest += *Args[i]; 64 } 65 return Chars; 66} 67const VariadicFunction1<int, std::string *, std::string, 68 StringAppendImpl> StringAppend = {}; 69 70TEST(VariadicFunction1Test, Works) { 71 std::string S0("hi"); 72 EXPECT_EQ(0, StringAppend(&S0)); 73 EXPECT_EQ("hi", S0); 74 75 std::string S1("bin"); 76 EXPECT_EQ(2, StringAppend(&S1, "go")); 77 EXPECT_EQ("bingo", S1); 78 79 std::string S4("Fab4"); 80 EXPECT_EQ(4 + 4 + 6 + 5, 81 StringAppend(&S4, "John", "Paul", "George", "Ringo")); 82 EXPECT_EQ("Fab4JohnPaulGeorgeRingo", S4); 83} 84 85// Counts how many optional arguments fall in the given range. 86// Returns the result in *num_in_range. We make the return type void 87// as we want to test that VariadicFunction* can handle it. 88void CountInRangeImpl(int *NumInRange, int Low, int High, 89 ArrayRef<const int *> Args) { 90 *NumInRange = 0; 91 for (unsigned i = 0, e = Args.size(); i < e; ++i) 92 if (Low <= *Args[i] && *Args[i] <= High) 93 ++(*NumInRange); 94} 95const VariadicFunction3<void, int *, int, int, int, 96 CountInRangeImpl> CountInRange = {}; 97 98TEST(VariadicFunction3Test, Works) { 99 int N = -1; 100 CountInRange(&N, -100, 100); 101 EXPECT_EQ(0, N); 102 103 CountInRange(&N, -100, 100, 42); 104 EXPECT_EQ(1, N); 105 106 CountInRange(&N, -100, 100, 1, 999, -200, 42); 107 EXPECT_EQ(2, N); 108} 109 110} // namespace 111