Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(67)

Side by Side Diff: base/mac/bind_objc_block_unittest_arc.mm

Issue 2522943003: [iOS/ARC] Fix a violation of ODR in base::BindBlock under ARC. (Closed)
Patch Set: Use EXPECT_NSEQ instead of EXPECT_EQ/EXPECT_TRUE. Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « base/mac/bind_objc_block_unittest.mm ('k') | base/mac/scoped_nsobject_unittest.mm » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #import "base/mac/bind_objc_block.h" 5 #import "base/mac/bind_objc_block.h"
6 6
7 #include <string> 7 #include <string>
8 8
9 #include "base/bind.h" 9 #include "base/bind.h"
10 #include "base/callback.h" 10 #include "base/callback.h"
11 #include "base/callback_helpers.h" 11 #include "base/callback_helpers.h"
12 #include "build/build_config.h"
12 #include "testing/gtest/include/gtest/gtest.h" 13 #include "testing/gtest/include/gtest/gtest.h"
14 #include "testing/gtest_mac.h"
13 15
14 #if !defined(__has_feature) || !__has_feature(objc_arc) 16 #if !defined(__has_feature) || !__has_feature(objc_arc)
15 #error "This file requires ARC support." 17 #error "This file requires ARC support."
16 #endif 18 #endif
17 19
18 // This free-function is there to ensure that the object file in not discarded
19 // at link time when building with gyp (it is required because targets is built
20 // as a static library with gyp and not source set which cause the object file
21 // to be discarded if no symbol is used). Remove once gyp support is dropped.
22 void BindObjcBlockUnittestArcLinkerWorkaround() {}
23
24 namespace { 20 namespace {
25 21
26 TEST(BindObjcBlockTestARC, TestScopedClosureRunnerExitScope) { 22 TEST(BindObjcBlockTestARC, TestScopedClosureRunnerExitScope) {
27 int run_count = 0; 23 int run_count = 0;
28 int* ptr = &run_count; 24 int* ptr = &run_count;
29 { 25 {
30 base::ScopedClosureRunner runner(base::BindBlock(^{ 26 base::ScopedClosureRunner runner(base::BindBlockArc(^{
31 (*ptr)++; 27 (*ptr)++;
32 })); 28 }));
33 EXPECT_EQ(0, run_count); 29 EXPECT_EQ(0, run_count);
34 } 30 }
35 EXPECT_EQ(1, run_count); 31 EXPECT_EQ(1, run_count);
36 } 32 }
37 33
38 TEST(BindObjcBlockTestARC, TestScopedClosureRunnerRelease) { 34 TEST(BindObjcBlockTestARC, TestScopedClosureRunnerRelease) {
39 int run_count = 0; 35 int run_count = 0;
40 int* ptr = &run_count; 36 int* ptr = &run_count;
41 base::Closure c; 37 base::Closure c;
42 { 38 {
43 base::ScopedClosureRunner runner(base::BindBlock(^{ 39 base::ScopedClosureRunner runner(base::BindBlockArc(^{
44 (*ptr)++; 40 (*ptr)++;
45 })); 41 }));
46 c = runner.Release(); 42 c = runner.Release();
47 EXPECT_EQ(0, run_count); 43 EXPECT_EQ(0, run_count);
48 } 44 }
49 EXPECT_EQ(0, run_count); 45 EXPECT_EQ(0, run_count);
50 c.Run(); 46 c.Run();
51 EXPECT_EQ(1, run_count); 47 EXPECT_EQ(1, run_count);
52 } 48 }
53 49
54 TEST(BindObjcBlockTestARC, TestReturnValue) { 50 TEST(BindObjcBlockTestARC, TestReturnValue) {
55 const int kReturnValue = 42; 51 const int kReturnValue = 42;
56 base::Callback<int(void)> c = base::BindBlock(^{return kReturnValue;}); 52 base::Callback<int(void)> c = base::BindBlockArc(^{
53 return kReturnValue;
54 });
57 EXPECT_EQ(kReturnValue, c.Run()); 55 EXPECT_EQ(kReturnValue, c.Run());
58 } 56 }
59 57
60 TEST(BindObjcBlockTestARC, TestArgument) { 58 TEST(BindObjcBlockTestARC, TestArgument) {
61 const int kArgument = 42; 59 const int kArgument = 42;
62 base::Callback<int(int)> c = base::BindBlock(^(int a){return a + 1;}); 60 base::Callback<int(int)> c = base::BindBlockArc(^(int a) {
61 return a + 1;
62 });
63 EXPECT_EQ(kArgument + 1, c.Run(kArgument)); 63 EXPECT_EQ(kArgument + 1, c.Run(kArgument));
64 } 64 }
65 65
66 TEST(BindObjcBlockTestARC, TestTwoArguments) { 66 TEST(BindObjcBlockTestARC, TestTwoArguments) {
67 std::string result; 67 std::string result;
68 std::string* ptr = &result; 68 std::string* ptr = &result;
69 base::Callback<void(const std::string&, const std::string&)> c = 69 base::Callback<void(const std::string&, const std::string&)> c =
70 base::BindBlock(^(const std::string& a, const std::string& b) { 70 base::BindBlockArc(^(const std::string& a, const std::string& b) {
71 *ptr = a + b; 71 *ptr = a + b;
72 }); 72 });
73 c.Run("forty", "two"); 73 c.Run("forty", "two");
74 EXPECT_EQ(result, "fortytwo"); 74 EXPECT_EQ(result, "fortytwo");
75 } 75 }
76 76
77 TEST(BindObjcBlockTestARC, TestThreeArguments) { 77 TEST(BindObjcBlockTestARC, TestThreeArguments) {
78 std::string result; 78 std::string result;
79 std::string* ptr = &result; 79 std::string* ptr = &result;
80 base::Callback<void(const std::string&, 80 base::Callback<void(const std::string&, const std::string&,
81 const std::string&, 81 const std::string&)>
82 const std::string&)> c = 82 c = base::BindBlockArc(
83 base::BindBlock(^(const std::string& a, 83 ^(const std::string& a, const std::string& b, const std::string& c) {
84 const std::string& b, 84 *ptr = a + b + c;
85 const std::string& c) { 85 });
86 *ptr = a + b + c;
87 });
88 c.Run("six", "times", "nine"); 86 c.Run("six", "times", "nine");
89 EXPECT_EQ(result, "sixtimesnine"); 87 EXPECT_EQ(result, "sixtimesnine");
90 } 88 }
91 89
92 TEST(BindObjcBlockTestARC, TestSixArguments) { 90 TEST(BindObjcBlockTestARC, TestSixArguments) {
93 std::string result1; 91 std::string result1;
94 std::string* ptr = &result1; 92 std::string* ptr = &result1;
95 int result2; 93 int result2;
96 int* ptr2 = &result2; 94 int* ptr2 = &result2;
97 base::Callback<void(int, int, const std::string&, const std::string&, 95 base::Callback<void(int, int, const std::string&, const std::string&, int,
98 int, const std::string&)> c = 96 const std::string&)>
99 base::BindBlock(^(int a, int b, const std::string& c, 97 c = base::BindBlockArc(^(int a, int b, const std::string& c,
100 const std::string& d, int e, const std::string& f) { 98 const std::string& d, int e,
101 *ptr = c + d + f; 99 const std::string& f) {
102 *ptr2 = a + b + e; 100 *ptr = c + d + f;
101 *ptr2 = a + b + e;
103 }); 102 });
104 c.Run(1, 2, "infinite", "improbability", 3, "drive"); 103 c.Run(1, 2, "infinite", "improbability", 3, "drive");
105 EXPECT_EQ(result1, "infiniteimprobabilitydrive"); 104 EXPECT_EQ(result1, "infiniteimprobabilitydrive");
106 EXPECT_EQ(result2, 6); 105 EXPECT_EQ(result2, 6);
107 } 106 }
108 107
108 #if defined(OS_IOS)
109
110 TEST(BindObjcBlockTestARC, TestBlockReleased) {
111 __weak NSObject* weak_nsobject;
112 @autoreleasepool {
113 NSObject* nsobject = [[NSObject alloc] init];
114 weak_nsobject = nsobject;
115
116 auto callback = base::BindBlockArc(^{
117 [nsobject description];
118 });
119 }
120 EXPECT_NSEQ(nil, weak_nsobject);
121 }
122
123 #endif
124
109 } // namespace 125 } // namespace
OLDNEW
« no previous file with comments | « base/mac/bind_objc_block_unittest.mm ('k') | base/mac/scoped_nsobject_unittest.mm » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698