blob: b34514670d0647044152f0a64552bf4da475edf2 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <string>
#include "base/bind.h"
#include "base/callback.h"
#include "base/callback_helpers.h"
#include "base/mac/scoped_nsautorelease_pool.h"
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/gtest_mac.h"
#if defined(OS_IOS)
#include "base/ios/weak_nsobject.h"
#endif
namespace {
TEST(BindObjcBlockTest, TestScopedClosureRunnerExitScope) {
int run_count = 0;
int* ptr = &run_count;
{
base::ScopedClosureRunner runner(base::BindOnce(base::RetainBlock(^{
(*ptr)++;
})));
EXPECT_EQ(0, run_count);
}
EXPECT_EQ(1, run_count);
}
TEST(BindObjcBlockTest, TestScopedClosureRunnerRelease) {
int run_count = 0;
int* ptr = &run_count;
base::OnceClosure c;
{
base::ScopedClosureRunner runner(base::BindOnce(base::RetainBlock(^{
(*ptr)++;
})));
c = runner.Release();
EXPECT_EQ(0, run_count);
}
EXPECT_EQ(0, run_count);
std::move(c).Run();
EXPECT_EQ(1, run_count);
}
TEST(BindObjcBlockTest, TestReturnValue) {
const int kReturnValue = 42;
base::OnceCallback<int(void)> c = base::BindOnce(base::RetainBlock(^{
return kReturnValue;
}));
EXPECT_EQ(kReturnValue, std::move(c).Run());
}
TEST(BindObjcBlockTest, TestArgument) {
const int kArgument = 42;
base::OnceCallback<int(int)> c = base::BindOnce(base::RetainBlock(^(int a) {
return a + 1;
}));
EXPECT_EQ(kArgument + 1, std::move(c).Run(kArgument));
}
TEST(BindObjcBlockTest, TestTwoArguments) {
std::string result;
std::string* ptr = &result;
base::OnceCallback<void(const std::string&, const std::string&)> c =
base::BindOnce(
base::RetainBlock(^(const std::string& a, const std::string& b) {
*ptr = a + b;
}));
std::move(c).Run("forty", "two");
EXPECT_EQ(result, "fortytwo");
}
TEST(BindObjcBlockTest, TestThreeArguments) {
std::string result;
std::string* ptr = &result;
base::OnceCallback<void(const std::string&, const std::string&,
const std::string&)>
c = base::BindOnce(base::RetainBlock(
^(const std::string& a, const std::string& b, const std::string& c) {
*ptr = a + b + c;
}));
std::move(c).Run("six", "times", "nine");
EXPECT_EQ(result, "sixtimesnine");
}
TEST(BindObjcBlockTest, TestSixArguments) {
std::string result1;
std::string* ptr = &result1;
int result2;
int* ptr2 = &result2;
base::OnceCallback<void(int, int, const std::string&, const std::string&, int,
const std::string&)>
c = base::BindOnce(base::RetainBlock(^(int a, int b, const std::string& c,
const std::string& d, int e,
const std::string& f) {
*ptr = c + d + f;
*ptr2 = a + b + e;
}));
std::move(c).Run(1, 2, "infinite", "improbability", 3, "drive");
EXPECT_EQ(result1, "infiniteimprobabilitydrive");
EXPECT_EQ(result2, 6);
}
TEST(BindObjcBlockTest, TestBlockMoveable) {
base::OnceClosure c;
__block BOOL invoked_block = NO;
{
base::mac::ScopedNSAutoreleasePool autorelease_pool;
c = base::BindOnce(base::RetainBlock(^(std::unique_ptr<BOOL> v) {
invoked_block = *v;
}),
std::make_unique<BOOL>(YES));
};
std::move(c).Run();
EXPECT_TRUE(invoked_block);
}
// Tests that the bound block is retained until the end of its execution,
// even if the callback itself is destroyed during the invocation. It was
// found that some code depends on this behaviour (see crbug.com/845687).
TEST(BindObjcBlockTest, TestBlockDeallocation) {
base::RepeatingClosure closure;
__block BOOL invoked_block = NO;
closure = base::BindRepeating(
base::RetainBlock(^(base::RepeatingClosure* this_closure) {
*this_closure = base::RepeatingClosure();
invoked_block = YES;
}),
&closure);
closure.Run();
EXPECT_TRUE(invoked_block);
}
#if defined(OS_IOS)
TEST(BindObjcBlockTest, TestBlockReleased) {
base::WeakNSObject<NSObject> weak_nsobject;
{
base::mac::ScopedNSAutoreleasePool autorelease_pool;
NSObject* nsobject = [[[NSObject alloc] init] autorelease];
weak_nsobject.reset(nsobject);
auto callback = base::BindOnce(base::RetainBlock(^{
[nsobject description];
}));
}
EXPECT_NSEQ(nil, weak_nsobject);
}
#endif
} // namespace