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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: base/mac/foundation_util_unittest.mm

Issue 12294008: Fix more remaining FilePath -> base::FilePath. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 7 years, 10 months 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 side-by-side diff with in-line comments
Download patch
« no previous file with comments | « base/i18n/icu_util.cc ('k') | base/win/event_trace_consumer_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: base/mac/foundation_util_unittest.mm
diff --git a/base/mac/foundation_util_unittest.mm b/base/mac/foundation_util_unittest.mm
index e5577ec7887f8430d431437d90b8a6f2cd35ca65..6fb85d8143fc557a5d92428d3650160bf49ef1ae 100644
--- a/base/mac/foundation_util_unittest.mm
+++ b/base/mac/foundation_util_unittest.mm
@@ -11,45 +11,46 @@
#include "testing/gtest/include/gtest/gtest.h"
#import "testing/gtest_mac.h"
+namespace base {
+namespace mac {
+
TEST(FoundationUtilTest, CFCast) {
// Build out the CF types to be tested as empty containers.
- base::mac::ScopedCFTypeRef<CFTypeRef> test_array(
+ ScopedCFTypeRef<CFTypeRef> test_array(
CFArrayCreate(NULL, NULL, 0, &kCFTypeArrayCallBacks));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_array_mutable(
+ ScopedCFTypeRef<CFTypeRef> test_array_mutable(
CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_bag(
+ ScopedCFTypeRef<CFTypeRef> test_bag(
CFBagCreate(NULL, NULL, 0, &kCFTypeBagCallBacks));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_bag_mutable(
+ ScopedCFTypeRef<CFTypeRef> test_bag_mutable(
CFBagCreateMutable(NULL, 0, &kCFTypeBagCallBacks));
CFTypeRef test_bool = kCFBooleanTrue;
- base::mac::ScopedCFTypeRef<CFTypeRef> test_data(
+ ScopedCFTypeRef<CFTypeRef> test_data(
CFDataCreate(NULL, NULL, 0));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_data_mutable(
+ ScopedCFTypeRef<CFTypeRef> test_data_mutable(
CFDataCreateMutable(NULL, 0));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_date(
+ ScopedCFTypeRef<CFTypeRef> test_date(
CFDateCreate(NULL, 0));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_dict(
+ ScopedCFTypeRef<CFTypeRef> test_dict(
CFDictionaryCreate(NULL, NULL, NULL, 0,
&kCFCopyStringDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_dict_mutable(
+ ScopedCFTypeRef<CFTypeRef> test_dict_mutable(
CFDictionaryCreateMutable(NULL, 0,
&kCFCopyStringDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks));
int int_val = 256;
- base::mac::ScopedCFTypeRef<CFTypeRef> test_number(
+ ScopedCFTypeRef<CFTypeRef> test_number(
CFNumberCreate(NULL, kCFNumberIntType, &int_val));
CFTypeRef test_null = kCFNull;
- base::mac::ScopedCFTypeRef<CFTypeRef> test_set(
+ ScopedCFTypeRef<CFTypeRef> test_set(
CFSetCreate(NULL, NULL, 0, &kCFTypeSetCallBacks));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_set_mutable(
+ ScopedCFTypeRef<CFTypeRef> test_set_mutable(
CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks));
- base::mac::ScopedCFTypeRef<CFTypeRef> test_str(
- CFStringCreateWithBytes(NULL, NULL, 0, kCFStringEncodingASCII,
- false));
+ ScopedCFTypeRef<CFTypeRef> test_str(
+ CFStringCreateWithBytes(NULL, NULL, 0, kCFStringEncodingASCII, false));
CFTypeRef test_str_const = CFSTR("hello");
- base::mac::ScopedCFTypeRef<CFTypeRef> test_str_mutable(
- CFStringCreateMutable(NULL, 0));
+ ScopedCFTypeRef<CFTypeRef> test_str_mutable(CFStringCreateMutable(NULL, 0));
// Make sure the allocations of CF types are good.
EXPECT_TRUE(test_array);
@@ -71,101 +72,90 @@ TEST(FoundationUtilTest, CFCast) {
EXPECT_TRUE(test_str_mutable);
// Casting the CFTypeRef objects correctly provides the same pointer.
- EXPECT_EQ(test_array, base::mac::CFCast<CFArrayRef>(test_array));
- EXPECT_EQ(test_array_mutable,
- base::mac::CFCast<CFArrayRef>(test_array_mutable));
- EXPECT_EQ(test_bag, base::mac::CFCast<CFBagRef>(test_bag));
- EXPECT_EQ(test_bag_mutable,
- base::mac::CFCast<CFBagRef>(test_bag_mutable));
- EXPECT_EQ(test_bool, base::mac::CFCast<CFBooleanRef>(test_bool));
- EXPECT_EQ(test_data, base::mac::CFCast<CFDataRef>(test_data));
- EXPECT_EQ(test_data_mutable,
- base::mac::CFCast<CFDataRef>(test_data_mutable));
- EXPECT_EQ(test_date, base::mac::CFCast<CFDateRef>(test_date));
- EXPECT_EQ(test_dict, base::mac::CFCast<CFDictionaryRef>(test_dict));
- EXPECT_EQ(test_dict_mutable,
- base::mac::CFCast<CFDictionaryRef>(test_dict_mutable));
- EXPECT_EQ(test_number, base::mac::CFCast<CFNumberRef>(test_number));
- EXPECT_EQ(test_null, base::mac::CFCast<CFNullRef>(test_null));
- EXPECT_EQ(test_set, base::mac::CFCast<CFSetRef>(test_set));
- EXPECT_EQ(test_set_mutable, base::mac::CFCast<CFSetRef>(test_set_mutable));
- EXPECT_EQ(test_str, base::mac::CFCast<CFStringRef>(test_str));
- EXPECT_EQ(test_str_const, base::mac::CFCast<CFStringRef>(test_str_const));
- EXPECT_EQ(test_str_mutable,
- base::mac::CFCast<CFStringRef>(test_str_mutable));
+ EXPECT_EQ(test_array, CFCast<CFArrayRef>(test_array));
+ EXPECT_EQ(test_array_mutable, CFCast<CFArrayRef>(test_array_mutable));
+ EXPECT_EQ(test_bag, CFCast<CFBagRef>(test_bag));
+ EXPECT_EQ(test_bag_mutable, CFCast<CFBagRef>(test_bag_mutable));
+ EXPECT_EQ(test_bool, CFCast<CFBooleanRef>(test_bool));
+ EXPECT_EQ(test_data, CFCast<CFDataRef>(test_data));
+ EXPECT_EQ(test_data_mutable, CFCast<CFDataRef>(test_data_mutable));
+ EXPECT_EQ(test_date, CFCast<CFDateRef>(test_date));
+ EXPECT_EQ(test_dict, CFCast<CFDictionaryRef>(test_dict));
+ EXPECT_EQ(test_dict_mutable, CFCast<CFDictionaryRef>(test_dict_mutable));
+ EXPECT_EQ(test_number, CFCast<CFNumberRef>(test_number));
+ EXPECT_EQ(test_null, CFCast<CFNullRef>(test_null));
+ EXPECT_EQ(test_set, CFCast<CFSetRef>(test_set));
+ EXPECT_EQ(test_set_mutable, CFCast<CFSetRef>(test_set_mutable));
+ EXPECT_EQ(test_str, CFCast<CFStringRef>(test_str));
+ EXPECT_EQ(test_str_const, CFCast<CFStringRef>(test_str_const));
+ EXPECT_EQ(test_str_mutable, CFCast<CFStringRef>(test_str_mutable));
// When given an incorrect CF cast, provide NULL.
- EXPECT_FALSE(base::mac::CFCast<CFStringRef>(test_array));
- EXPECT_FALSE(base::mac::CFCast<CFStringRef>(test_array_mutable));
- EXPECT_FALSE(base::mac::CFCast<CFStringRef>(test_bag));
- EXPECT_FALSE(base::mac::CFCast<CFSetRef>(test_bag_mutable));
- EXPECT_FALSE(base::mac::CFCast<CFSetRef>(test_bool));
- EXPECT_FALSE(base::mac::CFCast<CFNullRef>(test_data));
- EXPECT_FALSE(base::mac::CFCast<CFDictionaryRef>(test_data_mutable));
- EXPECT_FALSE(base::mac::CFCast<CFDictionaryRef>(test_date));
- EXPECT_FALSE(base::mac::CFCast<CFNumberRef>(test_dict));
- EXPECT_FALSE(base::mac::CFCast<CFDateRef>(test_dict_mutable));
- EXPECT_FALSE(base::mac::CFCast<CFDataRef>(test_number));
- EXPECT_FALSE(base::mac::CFCast<CFDataRef>(test_null));
- EXPECT_FALSE(base::mac::CFCast<CFBooleanRef>(test_set));
- EXPECT_FALSE(base::mac::CFCast<CFBagRef>(test_set_mutable));
- EXPECT_FALSE(base::mac::CFCast<CFBagRef>(test_str));
- EXPECT_FALSE(base::mac::CFCast<CFArrayRef>(test_str_const));
- EXPECT_FALSE(base::mac::CFCast<CFArrayRef>(test_str_mutable));
+ EXPECT_FALSE(CFCast<CFStringRef>(test_array));
+ EXPECT_FALSE(CFCast<CFStringRef>(test_array_mutable));
+ EXPECT_FALSE(CFCast<CFStringRef>(test_bag));
+ EXPECT_FALSE(CFCast<CFSetRef>(test_bag_mutable));
+ EXPECT_FALSE(CFCast<CFSetRef>(test_bool));
+ EXPECT_FALSE(CFCast<CFNullRef>(test_data));
+ EXPECT_FALSE(CFCast<CFDictionaryRef>(test_data_mutable));
+ EXPECT_FALSE(CFCast<CFDictionaryRef>(test_date));
+ EXPECT_FALSE(CFCast<CFNumberRef>(test_dict));
+ EXPECT_FALSE(CFCast<CFDateRef>(test_dict_mutable));
+ EXPECT_FALSE(CFCast<CFDataRef>(test_number));
+ EXPECT_FALSE(CFCast<CFDataRef>(test_null));
+ EXPECT_FALSE(CFCast<CFBooleanRef>(test_set));
+ EXPECT_FALSE(CFCast<CFBagRef>(test_set_mutable));
+ EXPECT_FALSE(CFCast<CFBagRef>(test_str));
+ EXPECT_FALSE(CFCast<CFArrayRef>(test_str_const));
+ EXPECT_FALSE(CFCast<CFArrayRef>(test_str_mutable));
// Giving a NULL provides a NULL.
- EXPECT_FALSE(base::mac::CFCast<CFArrayRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFBagRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFBooleanRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFDataRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFDateRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFDictionaryRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFNullRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFNumberRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFSetRef>(NULL));
- EXPECT_FALSE(base::mac::CFCast<CFStringRef>(NULL));
+ EXPECT_FALSE(CFCast<CFArrayRef>(NULL));
+ EXPECT_FALSE(CFCast<CFBagRef>(NULL));
+ EXPECT_FALSE(CFCast<CFBooleanRef>(NULL));
+ EXPECT_FALSE(CFCast<CFDataRef>(NULL));
+ EXPECT_FALSE(CFCast<CFDateRef>(NULL));
+ EXPECT_FALSE(CFCast<CFDictionaryRef>(NULL));
+ EXPECT_FALSE(CFCast<CFNullRef>(NULL));
+ EXPECT_FALSE(CFCast<CFNumberRef>(NULL));
+ EXPECT_FALSE(CFCast<CFSetRef>(NULL));
+ EXPECT_FALSE(CFCast<CFStringRef>(NULL));
// CFCastStrict: correct cast results in correct pointer being returned.
- EXPECT_EQ(test_array, base::mac::CFCastStrict<CFArrayRef>(test_array));
- EXPECT_EQ(test_array_mutable,
- base::mac::CFCastStrict<CFArrayRef>(test_array_mutable));
- EXPECT_EQ(test_bag, base::mac::CFCastStrict<CFBagRef>(test_bag));
- EXPECT_EQ(test_bag_mutable,
- base::mac::CFCastStrict<CFBagRef>(test_bag_mutable));
- EXPECT_EQ(test_bool, base::mac::CFCastStrict<CFBooleanRef>(test_bool));
- EXPECT_EQ(test_data, base::mac::CFCastStrict<CFDataRef>(test_data));
- EXPECT_EQ(test_data_mutable,
- base::mac::CFCastStrict<CFDataRef>(test_data_mutable));
- EXPECT_EQ(test_date, base::mac::CFCastStrict<CFDateRef>(test_date));
- EXPECT_EQ(test_dict, base::mac::CFCastStrict<CFDictionaryRef>(test_dict));
+ EXPECT_EQ(test_array, CFCastStrict<CFArrayRef>(test_array));
+ EXPECT_EQ(test_array_mutable, CFCastStrict<CFArrayRef>(test_array_mutable));
+ EXPECT_EQ(test_bag, CFCastStrict<CFBagRef>(test_bag));
+ EXPECT_EQ(test_bag_mutable, CFCastStrict<CFBagRef>(test_bag_mutable));
+ EXPECT_EQ(test_bool, CFCastStrict<CFBooleanRef>(test_bool));
+ EXPECT_EQ(test_data, CFCastStrict<CFDataRef>(test_data));
+ EXPECT_EQ(test_data_mutable, CFCastStrict<CFDataRef>(test_data_mutable));
+ EXPECT_EQ(test_date, CFCastStrict<CFDateRef>(test_date));
+ EXPECT_EQ(test_dict, CFCastStrict<CFDictionaryRef>(test_dict));
EXPECT_EQ(test_dict_mutable,
- base::mac::CFCastStrict<CFDictionaryRef>(test_dict_mutable));
- EXPECT_EQ(test_number, base::mac::CFCastStrict<CFNumberRef>(test_number));
- EXPECT_EQ(test_null, base::mac::CFCastStrict<CFNullRef>(test_null));
- EXPECT_EQ(test_set, base::mac::CFCastStrict<CFSetRef>(test_set));
- EXPECT_EQ(test_set_mutable,
- base::mac::CFCastStrict<CFSetRef>(test_set_mutable));
- EXPECT_EQ(test_str, base::mac::CFCastStrict<CFStringRef>(test_str));
- EXPECT_EQ(test_str_const,
- base::mac::CFCastStrict<CFStringRef>(test_str_const));
- EXPECT_EQ(test_str_mutable,
- base::mac::CFCastStrict<CFStringRef>(test_str_mutable));
+ CFCastStrict<CFDictionaryRef>(test_dict_mutable));
+ EXPECT_EQ(test_number, CFCastStrict<CFNumberRef>(test_number));
+ EXPECT_EQ(test_null, CFCastStrict<CFNullRef>(test_null));
+ EXPECT_EQ(test_set, CFCastStrict<CFSetRef>(test_set));
+ EXPECT_EQ(test_set_mutable, CFCastStrict<CFSetRef>(test_set_mutable));
+ EXPECT_EQ(test_str, CFCastStrict<CFStringRef>(test_str));
+ EXPECT_EQ(test_str_const, CFCastStrict<CFStringRef>(test_str_const));
+ EXPECT_EQ(test_str_mutable, CFCastStrict<CFStringRef>(test_str_mutable));
// CFCastStrict: Giving a NULL provides a NULL.
- EXPECT_FALSE(base::mac::CFCastStrict<CFArrayRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFBagRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFBooleanRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFDataRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFDateRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFDictionaryRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFNullRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFNumberRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFSetRef>(NULL));
- EXPECT_FALSE(base::mac::CFCastStrict<CFStringRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFArrayRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFBagRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFBooleanRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFDataRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFDateRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFDictionaryRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFNullRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFNumberRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFSetRef>(NULL));
+ EXPECT_FALSE(CFCastStrict<CFStringRef>(NULL));
}
TEST(FoundationUtilTest, ObjCCast) {
- base::mac::ScopedNSAutoreleasePool pool;
+ ScopedNSAutoreleasePool pool;
id test_array = [NSArray array];
id test_array_mutable = [NSMutableArray array];
@@ -201,92 +191,88 @@ TEST(FoundationUtilTest, ObjCCast) {
EXPECT_TRUE(test_str_mutable);
// Casting the id correctly provides the same pointer.
- EXPECT_EQ(test_array, base::mac::ObjCCast<NSArray>(test_array));
- EXPECT_EQ(test_array_mutable,
- base::mac::ObjCCast<NSArray>(test_array_mutable));
- EXPECT_EQ(test_data, base::mac::ObjCCast<NSData>(test_data));
- EXPECT_EQ(test_data_mutable,
- base::mac::ObjCCast<NSData>(test_data_mutable));
- EXPECT_EQ(test_date, base::mac::ObjCCast<NSDate>(test_date));
- EXPECT_EQ(test_dict, base::mac::ObjCCast<NSDictionary>(test_dict));
- EXPECT_EQ(test_dict_mutable,
- base::mac::ObjCCast<NSDictionary>(test_dict_mutable));
- EXPECT_EQ(test_number, base::mac::ObjCCast<NSNumber>(test_number));
- EXPECT_EQ(test_null, base::mac::ObjCCast<NSNull>(test_null));
- EXPECT_EQ(test_set, base::mac::ObjCCast<NSSet>(test_set));
- EXPECT_EQ(test_set_mutable, base::mac::ObjCCast<NSSet>(test_set_mutable));
- EXPECT_EQ(test_str, base::mac::ObjCCast<NSString>(test_str));
- EXPECT_EQ(test_str_const, base::mac::ObjCCast<NSString>(test_str_const));
- EXPECT_EQ(test_str_mutable,
- base::mac::ObjCCast<NSString>(test_str_mutable));
+ EXPECT_EQ(test_array, ObjCCast<NSArray>(test_array));
+ EXPECT_EQ(test_array_mutable, ObjCCast<NSArray>(test_array_mutable));
+ EXPECT_EQ(test_data, ObjCCast<NSData>(test_data));
+ EXPECT_EQ(test_data_mutable, ObjCCast<NSData>(test_data_mutable));
+ EXPECT_EQ(test_date, ObjCCast<NSDate>(test_date));
+ EXPECT_EQ(test_dict, ObjCCast<NSDictionary>(test_dict));
+ EXPECT_EQ(test_dict_mutable, ObjCCast<NSDictionary>(test_dict_mutable));
+ EXPECT_EQ(test_number, ObjCCast<NSNumber>(test_number));
+ EXPECT_EQ(test_null, ObjCCast<NSNull>(test_null));
+ EXPECT_EQ(test_set, ObjCCast<NSSet>(test_set));
+ EXPECT_EQ(test_set_mutable, ObjCCast<NSSet>(test_set_mutable));
+ EXPECT_EQ(test_str, ObjCCast<NSString>(test_str));
+ EXPECT_EQ(test_str_const, ObjCCast<NSString>(test_str_const));
+ EXPECT_EQ(test_str_mutable, ObjCCast<NSString>(test_str_mutable));
// When given an incorrect ObjC cast, provide nil.
- EXPECT_FALSE(base::mac::ObjCCast<NSString>(test_array));
- EXPECT_FALSE(base::mac::ObjCCast<NSString>(test_array_mutable));
- EXPECT_FALSE(base::mac::ObjCCast<NSString>(test_data));
- EXPECT_FALSE(base::mac::ObjCCast<NSString>(test_data_mutable));
- EXPECT_FALSE(base::mac::ObjCCast<NSSet>(test_date));
- EXPECT_FALSE(base::mac::ObjCCast<NSSet>(test_dict));
- EXPECT_FALSE(base::mac::ObjCCast<NSNumber>(test_dict_mutable));
- EXPECT_FALSE(base::mac::ObjCCast<NSNull>(test_number));
- EXPECT_FALSE(base::mac::ObjCCast<NSDictionary>(test_null));
- EXPECT_FALSE(base::mac::ObjCCast<NSDictionary>(test_set));
- EXPECT_FALSE(base::mac::ObjCCast<NSDate>(test_set_mutable));
- EXPECT_FALSE(base::mac::ObjCCast<NSData>(test_str));
- EXPECT_FALSE(base::mac::ObjCCast<NSData>(test_str_const));
- EXPECT_FALSE(base::mac::ObjCCast<NSArray>(test_str_mutable));
+ EXPECT_FALSE(ObjCCast<NSString>(test_array));
+ EXPECT_FALSE(ObjCCast<NSString>(test_array_mutable));
+ EXPECT_FALSE(ObjCCast<NSString>(test_data));
+ EXPECT_FALSE(ObjCCast<NSString>(test_data_mutable));
+ EXPECT_FALSE(ObjCCast<NSSet>(test_date));
+ EXPECT_FALSE(ObjCCast<NSSet>(test_dict));
+ EXPECT_FALSE(ObjCCast<NSNumber>(test_dict_mutable));
+ EXPECT_FALSE(ObjCCast<NSNull>(test_number));
+ EXPECT_FALSE(ObjCCast<NSDictionary>(test_null));
+ EXPECT_FALSE(ObjCCast<NSDictionary>(test_set));
+ EXPECT_FALSE(ObjCCast<NSDate>(test_set_mutable));
+ EXPECT_FALSE(ObjCCast<NSData>(test_str));
+ EXPECT_FALSE(ObjCCast<NSData>(test_str_const));
+ EXPECT_FALSE(ObjCCast<NSArray>(test_str_mutable));
// Giving a nil provides a nil.
- EXPECT_FALSE(base::mac::ObjCCast<NSArray>(nil));
- EXPECT_FALSE(base::mac::ObjCCast<NSData>(nil));
- EXPECT_FALSE(base::mac::ObjCCast<NSDate>(nil));
- EXPECT_FALSE(base::mac::ObjCCast<NSDictionary>(nil));
- EXPECT_FALSE(base::mac::ObjCCast<NSNull>(nil));
- EXPECT_FALSE(base::mac::ObjCCast<NSNumber>(nil));
- EXPECT_FALSE(base::mac::ObjCCast<NSSet>(nil));
- EXPECT_FALSE(base::mac::ObjCCast<NSString>(nil));
+ EXPECT_FALSE(ObjCCast<NSArray>(nil));
+ EXPECT_FALSE(ObjCCast<NSData>(nil));
+ EXPECT_FALSE(ObjCCast<NSDate>(nil));
+ EXPECT_FALSE(ObjCCast<NSDictionary>(nil));
+ EXPECT_FALSE(ObjCCast<NSNull>(nil));
+ EXPECT_FALSE(ObjCCast<NSNumber>(nil));
+ EXPECT_FALSE(ObjCCast<NSSet>(nil));
+ EXPECT_FALSE(ObjCCast<NSString>(nil));
// ObjCCastStrict: correct cast results in correct pointer being returned.
- EXPECT_EQ(test_array, base::mac::ObjCCastStrict<NSArray>(test_array));
+ EXPECT_EQ(test_array, ObjCCastStrict<NSArray>(test_array));
EXPECT_EQ(test_array_mutable,
- base::mac::ObjCCastStrict<NSArray>(test_array_mutable));
- EXPECT_EQ(test_data, base::mac::ObjCCastStrict<NSData>(test_data));
+ ObjCCastStrict<NSArray>(test_array_mutable));
+ EXPECT_EQ(test_data, ObjCCastStrict<NSData>(test_data));
EXPECT_EQ(test_data_mutable,
- base::mac::ObjCCastStrict<NSData>(test_data_mutable));
- EXPECT_EQ(test_date, base::mac::ObjCCastStrict<NSDate>(test_date));
- EXPECT_EQ(test_dict, base::mac::ObjCCastStrict<NSDictionary>(test_dict));
+ ObjCCastStrict<NSData>(test_data_mutable));
+ EXPECT_EQ(test_date, ObjCCastStrict<NSDate>(test_date));
+ EXPECT_EQ(test_dict, ObjCCastStrict<NSDictionary>(test_dict));
EXPECT_EQ(test_dict_mutable,
- base::mac::ObjCCastStrict<NSDictionary>(test_dict_mutable));
- EXPECT_EQ(test_number, base::mac::ObjCCastStrict<NSNumber>(test_number));
- EXPECT_EQ(test_null, base::mac::ObjCCastStrict<NSNull>(test_null));
- EXPECT_EQ(test_set, base::mac::ObjCCastStrict<NSSet>(test_set));
+ ObjCCastStrict<NSDictionary>(test_dict_mutable));
+ EXPECT_EQ(test_number, ObjCCastStrict<NSNumber>(test_number));
+ EXPECT_EQ(test_null, ObjCCastStrict<NSNull>(test_null));
+ EXPECT_EQ(test_set, ObjCCastStrict<NSSet>(test_set));
EXPECT_EQ(test_set_mutable,
- base::mac::ObjCCastStrict<NSSet>(test_set_mutable));
- EXPECT_EQ(test_str, base::mac::ObjCCastStrict<NSString>(test_str));
+ ObjCCastStrict<NSSet>(test_set_mutable));
+ EXPECT_EQ(test_str, ObjCCastStrict<NSString>(test_str));
EXPECT_EQ(test_str_const,
- base::mac::ObjCCastStrict<NSString>(test_str_const));
+ ObjCCastStrict<NSString>(test_str_const));
EXPECT_EQ(test_str_mutable,
- base::mac::ObjCCastStrict<NSString>(test_str_mutable));
+ ObjCCastStrict<NSString>(test_str_mutable));
// ObjCCastStrict: Giving a nil provides a nil.
- EXPECT_FALSE(base::mac::ObjCCastStrict<NSArray>(nil));
- EXPECT_FALSE(base::mac::ObjCCastStrict<NSData>(nil));
- EXPECT_FALSE(base::mac::ObjCCastStrict<NSDate>(nil));
- EXPECT_FALSE(base::mac::ObjCCastStrict<NSDictionary>(nil));
- EXPECT_FALSE(base::mac::ObjCCastStrict<NSNull>(nil));
- EXPECT_FALSE(base::mac::ObjCCastStrict<NSNumber>(nil));
- EXPECT_FALSE(base::mac::ObjCCastStrict<NSSet>(nil));
- EXPECT_FALSE(base::mac::ObjCCastStrict<NSString>(nil));
+ EXPECT_FALSE(ObjCCastStrict<NSArray>(nil));
+ EXPECT_FALSE(ObjCCastStrict<NSData>(nil));
+ EXPECT_FALSE(ObjCCastStrict<NSDate>(nil));
+ EXPECT_FALSE(ObjCCastStrict<NSDictionary>(nil));
+ EXPECT_FALSE(ObjCCastStrict<NSNull>(nil));
+ EXPECT_FALSE(ObjCCastStrict<NSNumber>(nil));
+ EXPECT_FALSE(ObjCCastStrict<NSSet>(nil));
+ EXPECT_FALSE(ObjCCastStrict<NSString>(nil));
}
TEST(FoundationUtilTest, GetValueFromDictionary) {
int one = 1, two = 2, three = 3;
- base::mac::ScopedCFTypeRef<CFNumberRef> cf_one(
+ ScopedCFTypeRef<CFNumberRef> cf_one(
CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &one));
- base::mac::ScopedCFTypeRef<CFNumberRef> cf_two(
+ ScopedCFTypeRef<CFNumberRef> cf_two(
CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &two));
- base::mac::ScopedCFTypeRef<CFNumberRef> cf_three(
+ ScopedCFTypeRef<CFNumberRef> cf_three(
CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &three));
CFStringRef keys[] = { CFSTR("one"), CFSTR("two"), CFSTR("three") };
@@ -295,7 +281,7 @@ TEST(FoundationUtilTest, GetValueFromDictionary) {
COMPILE_ASSERT(arraysize(keys) == arraysize(values),
keys_and_values_arraysizes_are_different);
- base::mac::ScopedCFTypeRef<CFDictionaryRef> test_dict(
+ ScopedCFTypeRef<CFDictionaryRef> test_dict(
CFDictionaryCreate(kCFAllocatorDefault,
reinterpret_cast<const void**>(keys),
reinterpret_cast<const void**>(values),
@@ -303,33 +289,31 @@ TEST(FoundationUtilTest, GetValueFromDictionary) {
&kCFCopyStringDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks));
- // base::mac::GetValueFromDictionary<>(_, _) should produce the correct
+ // GetValueFromDictionary<>(_, _) should produce the correct
// expected output.
EXPECT_EQ(values[0],
- base::mac::GetValueFromDictionary<CFNumberRef>(test_dict,
- CFSTR("one")));
+ GetValueFromDictionary<CFNumberRef>(test_dict, CFSTR("one")));
EXPECT_EQ(values[1],
- base::mac::GetValueFromDictionary<CFNumberRef>(test_dict,
- CFSTR("two")));
+ GetValueFromDictionary<CFNumberRef>(test_dict, CFSTR("two")));
EXPECT_EQ(values[2],
- base::mac::GetValueFromDictionary<CFNumberRef>(test_dict,
- CFSTR("three")));
+ GetValueFromDictionary<CFNumberRef>(test_dict, CFSTR("three")));
// Bad input should produce bad output.
- EXPECT_FALSE(base::mac::GetValueFromDictionary<CFNumberRef>(test_dict,
- CFSTR("four")));
- EXPECT_FALSE(base::mac::GetValueFromDictionary<CFStringRef>(test_dict,
- CFSTR("one")));
+ EXPECT_FALSE(GetValueFromDictionary<CFNumberRef>(test_dict, CFSTR("four")));
+ EXPECT_FALSE(GetValueFromDictionary<CFStringRef>(test_dict, CFSTR("one")));
}
TEST(FoundationUtilTest, FilePathToNSString) {
- EXPECT_NSEQ(nil, base::mac::FilePathToNSString(FilePath()));
- EXPECT_NSEQ(@"/a/b", base::mac::FilePathToNSString(FilePath("/a/b")));
+ EXPECT_NSEQ(nil, FilePathToNSString(FilePath()));
+ EXPECT_NSEQ(@"/a/b", FilePathToNSString(FilePath("/a/b")));
}
// http://crbug.com/173983 Fails consistently under Mac ASAN.
TEST(FoundationUtilTest, DISABLED_NSStringToFilePath) {
- EXPECT_EQ(FilePath(), base::mac::NSStringToFilePath(nil));
- EXPECT_EQ(FilePath(), base::mac::NSStringToFilePath(@""));
- EXPECT_EQ(FilePath("/a/b"), base::mac::NSStringToFilePath(@"/a/b"));
+ EXPECT_EQ(FilePath(), NSStringToFilePath(nil));
+ EXPECT_EQ(FilePath(), NSStringToFilePath(@""));
+ EXPECT_EQ(FilePath("/a/b"), NSStringToFilePath(@"/a/b"));
}
+
+} // namespace mac
+} // namespace base
« no previous file with comments | « base/i18n/icu_util.cc ('k') | base/win/event_trace_consumer_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698