status quo coverage

Author: AlexGuteniev

tests/std/test.lst

@@ -270,6 +270,7 @@ tests\GH_005402_string_with_volatile_range
 tests\GH_005421_vector_algorithms_integer_class_type_iterator
 tests\GH_005472_do_not_overlap
 tests\GH_005546_containers_size_type_cast
+tests\GH_005504_avoid_function_call_wrapping
 tests\GH_005553_regex_character_translation
 tests\GH_005768_pow_accuracy
 tests\LWG2381_num_get_floating_point

tests/std/tests/GH_005504_avoid_function_call_wrapping/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_latest_matrix.lst

tests/std/tests/GH_005504_avoid_function_call_wrapping/test.cpp

@@ -0,0 +1,84 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <functional>
+
+#pragma warning(disable : 4324) // 'large_callable': structure was padded due to alignment specifier
+
+using namespace std;
+
+struct copy_counter {
+    copy_counter() = default;
+    copy_counter(const copy_counter& other) : count(other.count + 1) {}
+
+    int count = 0;
+};
+
+using function_type = int(copy_counter);
+
+struct small_callable {
+    int context = 42;
+
+    int operator()(const copy_counter& counter) {
+        assert(context == 42);
+        return counter.count;
+    }
+};
+
+struct alignas(128) large_callable {
+    int context = 1729;
+
+    int operator()(const copy_counter& counter) {
+        assert(context == 1729);
+        return counter.count;
+    }
+};
+
+int main() {
+    // Plain calls
+    {
+        function<function_type> fn{small_callable{}};
+        assert(fn(copy_counter{}) == 0);
+    }
+    {
+        function<function_type> fn{large_callable{}};
+        assert(fn(copy_counter{}) == 0);
+    }
+    {
+        move_only_function<function_type> fn{small_callable{}};
+        assert(fn(copy_counter{}) == 0);
+    }
+    {
+        move_only_function<function_type> fn{large_callable{}};
+        assert(fn(copy_counter{}) == 0);
+    }
+
+    // Moves to the same
+    {
+        function<function_type> fn{function<function_type>{small_callable{}}};
+        assert(fn(copy_counter{}) == 0);
+    }
+    {
+        function<function_type> fn{function<function_type>{large_callable{}}};
+        assert(fn(copy_counter{}) == 0);
+    }
+    {
+        move_only_function<function_type> fn{move_only_function<function_type>{small_callable{}}};
+        assert(fn(copy_counter{}) == 0);
+    }
+    {
+        move_only_function<function_type> fn{move_only_function<function_type>{large_callable{}}};
+        assert(fn(copy_counter{}) == 0);
+    }
+
+    // Moves from function to move_only_function
+    {
+        move_only_function<function_type> fn{function<function_type>{small_callable{}}};
+        assert(fn(copy_counter{}) == 1);
+    }
+    {
+        move_only_function<function_type> fn{function<function_type>{large_callable{}}};
+        assert(fn(copy_counter{}) == 1);
+    }
+}