kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 1 | /* |
| 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 Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 11 | #include "api/function_view.h" |
| 12 | |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 13 | #include <memory> |
| 14 | #include <utility> |
| 15 | |
Yves Gerey | 3e70781 | 2018-11-28 15:47:49 | [diff] [blame] | 16 | #include "test/gtest.h" |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 17 | |
| 18 | namespace rtc { |
| 19 | |
| 20 | namespace { |
| 21 | |
| 22 | int CallWith33(rtc::FunctionView<int(int)> fv) { |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 23 | return fv ? fv(33) : -1; |
| 24 | } |
| 25 | |
| 26 | int Add33(int x) { |
| 27 | return x + 33; |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 28 | } |
| 29 | |
| 30 | } // namespace |
| 31 | |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 32 | // Test the main use case of FunctionView: implicitly converting a callable |
| 33 | // argument. |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 34 | TEST(FunctionViewTest, ImplicitConversion) { |
| 35 | EXPECT_EQ(38, CallWith33([](int x) { return x + 5; })); |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 36 | EXPECT_EQ(66, CallWith33(Add33)); |
| 37 | EXPECT_EQ(-1, CallWith33(nullptr)); |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 38 | } |
| 39 | |
| 40 | TEST(FunctionViewTest, IntIntLambdaWithoutState) { |
| 41 | auto f = [](int x) { return x + 1; }; |
| 42 | EXPECT_EQ(18, f(17)); |
| 43 | rtc::FunctionView<int(int)> fv(f); |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 44 | EXPECT_TRUE(fv); |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 45 | EXPECT_EQ(18, fv(17)); |
| 46 | } |
| 47 | |
| 48 | TEST(FunctionViewTest, IntVoidLambdaWithState) { |
| 49 | int x = 13; |
| 50 | auto f = [x]() mutable { return ++x; }; |
| 51 | rtc::FunctionView<int()> fv(f); |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 52 | EXPECT_TRUE(fv); |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 53 | EXPECT_EQ(14, f()); |
| 54 | EXPECT_EQ(15, fv()); |
| 55 | EXPECT_EQ(16, f()); |
| 56 | EXPECT_EQ(17, fv()); |
| 57 | } |
| 58 | |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 59 | TEST(FunctionViewTest, IntIntFunction) { |
| 60 | rtc::FunctionView<int(int)> fv(Add33); |
| 61 | EXPECT_TRUE(fv); |
| 62 | EXPECT_EQ(50, fv(17)); |
| 63 | } |
| 64 | |
| 65 | TEST(FunctionViewTest, IntIntFunctionPointer) { |
| 66 | rtc::FunctionView<int(int)> fv(&Add33); |
| 67 | EXPECT_TRUE(fv); |
| 68 | EXPECT_EQ(50, fv(17)); |
| 69 | } |
| 70 | |
| 71 | TEST(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 Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 77 | EXPECT_FALSE(rtc::FunctionView<int()>(reinterpret_cast<int (*)()>(0))); |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 78 | } |
| 79 | |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 80 | // Ensure that FunctionView handles move-only arguments and return values. |
| 81 | TEST(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 | |
| 90 | TEST(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 | |
| 98 | TEST(FunctionViewTest, MoveConstructorIsCopy) { |
| 99 | auto f17 = [] { return 17; }; |
| 100 | rtc::FunctionView<int()> fv1(f17); |
Artem Titov | 741daaf | 2019-03-21 13:37:36 | [diff] [blame] | 101 | rtc::FunctionView<int()> fv2(std::move(fv1)); // NOLINT |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 102 | EXPECT_EQ(17, fv1()); |
| 103 | EXPECT_EQ(17, fv2()); |
| 104 | } |
| 105 | |
| 106 | TEST(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 | |
| 118 | TEST(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 Titov | 741daaf | 2019-03-21 13:37:36 | [diff] [blame] | 125 | fv2 = std::move(fv1); // NOLINT |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 126 | EXPECT_EQ(17, fv1()); |
| 127 | EXPECT_EQ(17, fv2()); |
| 128 | } |
| 129 | |
| 130 | TEST(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 |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 144 | // the same function as the old one (as opposed to the new object pointing to |
| 145 | // the old one). |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 146 | TEST(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 |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 159 | // copy (as opposed to making the second FunctionView point to the first one). |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 160 | TEST(FunctionViewTest, CopyAssignmentChaining) { |
| 161 | auto f17 = [] { return 17; }; |
| 162 | rtc::FunctionView<int()> fv1(f17); |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 163 | rtc::FunctionView<int()> fv2; |
| 164 | EXPECT_TRUE(fv1); |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 165 | EXPECT_EQ(17, fv1()); |
kwiberg | 607d9d7 | 2016-10-03 19:40:37 | [diff] [blame] | 166 | EXPECT_FALSE(fv2); |
kwiberg | 24c7c12 | 2016-09-28 18:57:10 | [diff] [blame] | 167 | 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 |