| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "out.h" |
| |
| #include <algorithm> |
| #include <gtest/gtest.h> |
| |
| namespace art { |
| |
| struct OutTest : public testing::Test { |
| // Multiplies values less than 10 by two, stores the result and returns 0. |
| // Returns -1 if the original value was not multiplied by two. |
| static int multiply_small_values_by_two(size_t args, out<int> result) { |
| if (args < 10) { |
| *result = args * 2; |
| return 0; |
| } else { |
| return -1; |
| } |
| } |
| }; |
| |
| extern "C" int multiply_small_values_by_two_legacy(size_t args, int* result) { |
| if (args < 10) { |
| *result = args * 2; |
| return 0; |
| } else { |
| return -1; |
| } |
| } |
| |
| TEST_F(OutTest, TraditionalCall) { |
| // For calling traditional C++ functions. |
| int res; |
| EXPECT_EQ(multiply_small_values_by_two(1, outof(res)), 0); |
| EXPECT_EQ(2, res); |
| } |
| |
| TEST_F(OutTest, LegacyCall) { |
| // For calling legacy, e.g. C-style functions. |
| int res2; |
| EXPECT_EQ(0, multiply_small_values_by_two_legacy(1, outof(res2))); |
| EXPECT_EQ(2, res2); |
| } |
| |
| TEST_F(OutTest, CallFromIterator) { |
| // For calling a function with a parameter originating as an iterator. |
| std::vector<int> list = {1, 2, 3}; // NOLINT [whitespace/labels] [4] |
| std::vector<int>::iterator it = list.begin(); |
| |
| EXPECT_EQ(0, multiply_small_values_by_two(2, outof_iterator(it))); |
| EXPECT_EQ(4, list[0]); |
| } |
| |
| TEST_F(OutTest, CallFromPointer) { |
| // For calling a function with a parameter originating as a C-pointer. |
| std::vector<int> list = {1, 2, 3}; // NOLINT [whitespace/labels] [4] |
| |
| int* list_ptr = &list[2]; // 3 |
| |
| EXPECT_EQ(0, multiply_small_values_by_two(2, outof_ptr(list_ptr))); |
| EXPECT_EQ(4, list[2]); |
| } |
| |
| TEST_F(OutTest, OutAsIterator) { |
| // For using the out<T> parameter as an iterator inside of the callee. |
| std::vector<int> list; |
| int x = 100; |
| out<int> out_from_x = outof(x); |
| |
| for (const int& val : out_from_x) { |
| list.push_back(val); |
| } |
| |
| ASSERT_EQ(1u, list.size()); |
| EXPECT_EQ(100, list[0]); |
| |
| // A more typical use-case would be to use std algorithms |
| EXPECT_NE(out_from_x.end(), |
| std::find(out_from_x.begin(), |
| out_from_x.end(), |
| 100)); // Search for '100' in out. |
| } |
| |
| } // namespace art |