blob: 156ea5c22dc0d1c1c993fd1966b6000d1777345b [file] [log] [blame]
kwiberg24c7c122016-09-28 18:57:101/*
2 * Copyright 2016 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Jonas Olssona4d87372019-07-05 17:08:3311#include "api/function_view.h"
12
kwiberg24c7c122016-09-28 18:57:1013#include <memory>
14#include <utility>
15
Yves Gerey3e707812018-11-28 15:47:4916#include "test/gtest.h"
kwiberg24c7c122016-09-28 18:57:1017
18namespace rtc {
19
20namespace {
21
22int CallWith33(rtc::FunctionView<int(int)> fv) {
kwiberg607d9d72016-10-03 19:40:3723 return fv ? fv(33) : -1;
24}
25
26int Add33(int x) {
27 return x + 33;
kwiberg24c7c122016-09-28 18:57:1028}
29
30} // namespace
31
kwiberg607d9d72016-10-03 19:40:3732// Test the main use case of FunctionView: implicitly converting a callable
33// argument.
kwiberg24c7c122016-09-28 18:57:1034TEST(FunctionViewTest, ImplicitConversion) {
35 EXPECT_EQ(38, CallWith33([](int x) { return x + 5; }));
kwiberg607d9d72016-10-03 19:40:3736 EXPECT_EQ(66, CallWith33(Add33));
37 EXPECT_EQ(-1, CallWith33(nullptr));
kwiberg24c7c122016-09-28 18:57:1038}
39
40TEST(FunctionViewTest, IntIntLambdaWithoutState) {
41 auto f = [](int x) { return x + 1; };
42 EXPECT_EQ(18, f(17));
43 rtc::FunctionView<int(int)> fv(f);
kwiberg607d9d72016-10-03 19:40:3744 EXPECT_TRUE(fv);
kwiberg24c7c122016-09-28 18:57:1045 EXPECT_EQ(18, fv(17));
46}
47
48TEST(FunctionViewTest, IntVoidLambdaWithState) {
49 int x = 13;
50 auto f = [x]() mutable { return ++x; };
51 rtc::FunctionView<int()> fv(f);
kwiberg607d9d72016-10-03 19:40:3752 EXPECT_TRUE(fv);
kwiberg24c7c122016-09-28 18:57:1053 EXPECT_EQ(14, f());
54 EXPECT_EQ(15, fv());
55 EXPECT_EQ(16, f());
56 EXPECT_EQ(17, fv());
57}
58
kwiberg607d9d72016-10-03 19:40:3759TEST(FunctionViewTest, IntIntFunction) {
60 rtc::FunctionView<int(int)> fv(Add33);
61 EXPECT_TRUE(fv);
62 EXPECT_EQ(50, fv(17));
63}
64
65TEST(FunctionViewTest, IntIntFunctionPointer) {
66 rtc::FunctionView<int(int)> fv(&Add33);
67 EXPECT_TRUE(fv);
68 EXPECT_EQ(50, fv(17));
69}
70
71TEST(FunctionViewTest, Null) {
72 // These two call constructors that statically construct null FunctionViews.
73 EXPECT_FALSE(rtc::FunctionView<int()>());
74 EXPECT_FALSE(rtc::FunctionView<int()>(nullptr));
75
76 // This calls the constructor for function pointers.
Yves Gerey665174f2018-06-19 13:03:0577 EXPECT_FALSE(rtc::FunctionView<int()>(reinterpret_cast<int (*)()>(0)));
kwiberg607d9d72016-10-03 19:40:3778}
79
kwiberg24c7c122016-09-28 18:57:1080// Ensure that FunctionView handles move-only arguments and return values.
81TEST(FunctionViewTest, UniquePtrPassthrough) {
82 auto f = [](std::unique_ptr<int> x) { return x; };
83 rtc::FunctionView<std::unique_ptr<int>(std::unique_ptr<int>)> fv(f);
84 std::unique_ptr<int> x(new int);
85 int* x_addr = x.get();
86 auto y = fv(std::move(x));
87 EXPECT_EQ(x_addr, y.get());
88}
89
90TEST(FunctionViewTest, CopyConstructor) {
91 auto f17 = [] { return 17; };
92 rtc::FunctionView<int()> fv1(f17);
93 rtc::FunctionView<int()> fv2(fv1);
94 EXPECT_EQ(17, fv1());
95 EXPECT_EQ(17, fv2());
96}
97
98TEST(FunctionViewTest, MoveConstructorIsCopy) {
99 auto f17 = [] { return 17; };
100 rtc::FunctionView<int()> fv1(f17);
Artem Titov741daaf2019-03-21 13:37:36101 rtc::FunctionView<int()> fv2(std::move(fv1)); // NOLINT
kwiberg24c7c122016-09-28 18:57:10102 EXPECT_EQ(17, fv1());
103 EXPECT_EQ(17, fv2());
104}
105
106TEST(FunctionViewTest, CopyAssignment) {
107 auto f17 = [] { return 17; };
108 rtc::FunctionView<int()> fv1(f17);
109 auto f23 = [] { return 23; };
110 rtc::FunctionView<int()> fv2(f23);
111 EXPECT_EQ(17, fv1());
112 EXPECT_EQ(23, fv2());
113 fv2 = fv1;
114 EXPECT_EQ(17, fv1());
115 EXPECT_EQ(17, fv2());
116}
117
118TEST(FunctionViewTest, MoveAssignmentIsCopy) {
119 auto f17 = [] { return 17; };
120 rtc::FunctionView<int()> fv1(f17);
121 auto f23 = [] { return 23; };
122 rtc::FunctionView<int()> fv2(f23);
123 EXPECT_EQ(17, fv1());
124 EXPECT_EQ(23, fv2());
Artem Titov741daaf2019-03-21 13:37:36125 fv2 = std::move(fv1); // NOLINT
kwiberg24c7c122016-09-28 18:57:10126 EXPECT_EQ(17, fv1());
127 EXPECT_EQ(17, fv2());
128}
129
130TEST(FunctionViewTest, Swap) {
131 auto f17 = [] { return 17; };
132 rtc::FunctionView<int()> fv1(f17);
133 auto f23 = [] { return 23; };
134 rtc::FunctionView<int()> fv2(f23);
135 EXPECT_EQ(17, fv1());
136 EXPECT_EQ(23, fv2());
137 using std::swap;
138 swap(fv1, fv2);
139 EXPECT_EQ(23, fv1());
140 EXPECT_EQ(17, fv2());
141}
142
143// Ensure that when you copy-construct a FunctionView, the new object points to
kwiberg607d9d72016-10-03 19:40:37144// the same function as the old one (as opposed to the new object pointing to
145// the old one).
kwiberg24c7c122016-09-28 18:57:10146TEST(FunctionViewTest, CopyConstructorChaining) {
147 auto f17 = [] { return 17; };
148 rtc::FunctionView<int()> fv1(f17);
149 rtc::FunctionView<int()> fv2(fv1);
150 EXPECT_EQ(17, fv1());
151 EXPECT_EQ(17, fv2());
152 auto f23 = [] { return 23; };
153 fv1 = f23;
154 EXPECT_EQ(23, fv1());
155 EXPECT_EQ(17, fv2());
156}
157
158// Ensure that when you assign one FunctionView to another, we actually make a
kwiberg607d9d72016-10-03 19:40:37159// copy (as opposed to making the second FunctionView point to the first one).
kwiberg24c7c122016-09-28 18:57:10160TEST(FunctionViewTest, CopyAssignmentChaining) {
161 auto f17 = [] { return 17; };
162 rtc::FunctionView<int()> fv1(f17);
kwiberg607d9d72016-10-03 19:40:37163 rtc::FunctionView<int()> fv2;
164 EXPECT_TRUE(fv1);
kwiberg24c7c122016-09-28 18:57:10165 EXPECT_EQ(17, fv1());
kwiberg607d9d72016-10-03 19:40:37166 EXPECT_FALSE(fv2);
kwiberg24c7c122016-09-28 18:57:10167 fv2 = fv1;
168 EXPECT_EQ(17, fv1());
169 EXPECT_EQ(17, fv2());
170 auto f23 = [] { return 23; };
171 fv1 = f23;
172 EXPECT_EQ(23, fv1());
173 EXPECT_EQ(17, fv2());
174}
175
176} // namespace rtc