60d68cd
From fe1f7ba4e76f156a160a6d3bbf28c3e224b3f43f Mon Sep 17 00:00:00 2001
60d68cd
From: Sandro Mani <manisandro@gmail.com>
60d68cd
Date: Fri, 8 Apr 2016 23:21:00 +0200
60d68cd
Subject: [PATCH 1/4] Fix build failure due to failure to convert pointer to
60d68cd
 bool
60d68cd
60d68cd
---
60d68cd
 tests/kml/base/net_cache_test.cc                   |  22 +--
60d68cd
 tests/kml/base/zip_file_test.cc                    |  26 +--
60d68cd
 tests/kml/convenience/csv_file_test.cc             |   2 +-
60d68cd
 tests/kml/convenience/csv_parser_test.cc           |  12 +-
60d68cd
 tests/kml/convenience/element_counter_test.cc      |  10 +-
60d68cd
 tests/kml/convenience/feature_list_test.cc         |   2 +-
60d68cd
 tests/kml/convenience/google_maps_data_test.cc     |   2 +-
60d68cd
 tests/kml/convenience/google_spreadsheets_test.cc  |   2 +-
60d68cd
 .../kml/convenience/kml_feature_list_saver_test.cc |   2 +-
60d68cd
 tests/kml/convenience/kmz_check_links_test.cc      |   8 +-
60d68cd
 tests/kml/dom/abstractview_test.cc                 |   8 +-
60d68cd
 tests/kml/dom/atom_test.cc                         |  20 +-
60d68cd
 tests/kml/dom/document_test.cc                     |   4 +-
60d68cd
 tests/kml/dom/extendeddata_test.cc                 |  16 +-
60d68cd
 tests/kml/dom/folder_test.cc                       |   4 +-
60d68cd
 tests/kml/dom/geometry_test.cc                     |  24 +--
60d68cd
 tests/kml/dom/gx_tour_test.cc                      |  72 +++----
60d68cd
 tests/kml/dom/hotspot_test.cc                      |   2 +-
60d68cd
 tests/kml/dom/iconstyle_test.cc                    |   2 +-
60d68cd
 tests/kml/dom/kml22_test.cc                        |   2 +-
60d68cd
 tests/kml/dom/kml_cast_test.cc                     | 206 ++++++++++-----------
60d68cd
 tests/kml/dom/kml_factory_test.cc                  |   6 +-
60d68cd
 tests/kml/dom/kml_handler_ns_test.cc               |   2 +-
60d68cd
 tests/kml/dom/kml_handler_test.cc                  |  56 +++---
60d68cd
 tests/kml/dom/link_test.cc                         |  10 +-
60d68cd
 tests/kml/dom/networklink_test.cc                  |   2 +-
60d68cd
 tests/kml/dom/object_test.cc                       |   4 +-
60d68cd
 tests/kml/dom/overlay_test.cc                      |  16 +-
60d68cd
 tests/kml/dom/parser_test.cc                       |  12 +-
60d68cd
 tests/kml/dom/placemark_test.cc                    |   4 +-
60d68cd
 tests/kml/dom/region_test.cc                       |  20 +-
60d68cd
 tests/kml/dom/serializer_test.cc                   |   2 +-
60d68cd
 tests/kml/dom/snippet_test.cc                      |  14 +-
60d68cd
 tests/kml/dom/unknown_test.cc                      |   8 +-
60d68cd
 tests/kml/dom/xal_test.cc                          |  18 +-
60d68cd
 tests/kml/dom/xml_serializer_test.cc               |   2 +-
60d68cd
 tests/kml/engine/clone_test.cc                     |  16 +-
60d68cd
 tests/kml/engine/entity_mapper_test.cc             |  10 +-
60d68cd
 tests/kml/engine/feature_balloon_test.cc           |   2 +-
60d68cd
 tests/kml/engine/feature_view_test.cc              |  10 +-
60d68cd
 tests/kml/engine/find_test.cc                      |   4 +-
60d68cd
 tests/kml/engine/id_mapper_test.cc                 |   8 +-
60d68cd
 tests/kml/engine/kml_cache_test.cc                 |  10 +-
60d68cd
 tests/kml/engine/kml_file_test.cc                  |  62 +++----
60d68cd
 tests/kml/engine/kml_stream_test.cc                |  22 +--
60d68cd
 tests/kml/engine/kmz_cache_test.cc                 |   8 +-
60d68cd
 tests/kml/engine/kmz_file_test.cc                  |  44 ++---
60d68cd
 tests/kml/engine/link_util_test.cc                 |   8 +-
60d68cd
 tests/kml/engine/location_util_test.cc             |   6 +-
60d68cd
 tests/kml/engine/merge_test.cc                     |   2 +-
60d68cd
 tests/kml/engine/parse_old_schema_test.cc          |   2 +-
60d68cd
 tests/kml/engine/style_inliner_test.cc             |   4 +-
60d68cd
 tests/kml/engine/style_merger_test.cc              |  10 +-
60d68cd
 tests/kml/engine/style_resolver_test.cc            |  34 ++--
60d68cd
 tests/kml/engine/style_splitter_test.cc            |  28 +--
60d68cd
 tests/kml/engine/update_processor_test.cc          |   4 +-
60d68cd
 tests/kml/engine/update_test.cc                    |  40 ++--
60d68cd
 tests/kml/regionator/regionator_test.cc            |  10 +-
60d68cd
 tests/kml/xsd/xsd_complex_type_test.cc             |   6 +-
60d68cd
 tests/kml/xsd/xsd_file_test.cc                     |  22 +--
60d68cd
 tests/kml/xsd/xsd_handler_test.cc                  |   6 +-
60d68cd
 tests/kml/xsd/xsd_schema_test.cc                   |   2 +-
60d68cd
 tests/kml/xsd/xsd_simple_type_test.cc              |   8 +-
60d68cd
 tests/kml/xsd/xsd_util_test.cc                     |   6 +-
60d68cd
 64 files changed, 509 insertions(+), 509 deletions(-)
60d68cd
60d68cd
diff --git a/tests/kml/base/net_cache_test.cc b/tests/kml/base/net_cache_test.cc
60d68cd
index f9afa05..d28470c 100644
60d68cd
--- a/tests/kml/base/net_cache_test.cc
60d68cd
+++ b/tests/kml/base/net_cache_test.cc
60d68cd
@@ -134,7 +134,7 @@ TEST_F(NetCacheTest, TestBasicFetch) {
60d68cd
   ASSERT_FALSE(null_net_cache_->Fetch(kUrl));
60d68cd
   ASSERT_EQ(kSize0, null_net_cache_->Size());
60d68cd
   // Fetch of a valid testdata path succeeds.
60d68cd
-  ASSERT_TRUE(testdata_net_cache_->Fetch(kUrl));
60d68cd
+  ASSERT_TRUE(testdata_net_cache_->Fetch(kUrl) != 0);
60d68cd
   // TODO read the test file directly and compare content
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), testdata_net_cache_->Size());
60d68cd
   // Fetch on UrlDataNetCache returns URL.
60d68cd
@@ -150,11 +150,11 @@ TEST_F(NetCacheTest, TestBasicLookUp) {
60d68cd
   ASSERT_FALSE(testdata_net_cache_->LookUp(kUrl));
60d68cd
   ASSERT_FALSE(url_data_net_cache_->LookUp(kUrl));
60d68cd
   // Fetch this URL into the cache in those caches that save content.
60d68cd
-  ASSERT_TRUE(testdata_net_cache_->Fetch(kUrl));
60d68cd
-  ASSERT_TRUE(url_data_net_cache_->Fetch(kUrl));
60d68cd
+  ASSERT_TRUE(testdata_net_cache_->Fetch(kUrl) != 0);
60d68cd
+  ASSERT_TRUE(url_data_net_cache_->Fetch(kUrl) != 0);
60d68cd
   // Verify that these caches return true now on LookUp.
60d68cd
-  ASSERT_TRUE(testdata_net_cache_->LookUp(kUrl));
60d68cd
-  ASSERT_TRUE(url_data_net_cache_->LookUp(kUrl));
60d68cd
+  ASSERT_TRUE(testdata_net_cache_->LookUp(kUrl) != 0);
60d68cd
+  ASSERT_TRUE(url_data_net_cache_->LookUp(kUrl) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 // Verify basic usage of the Save() method.
60d68cd
@@ -164,7 +164,7 @@ TEST_F(NetCacheTest, TestBasicSave) {
60d68cd
   MemoryFilePtr test_data_item = MemoryFile::CreateFromString(kContent);
60d68cd
   ASSERT_TRUE(url_data_net_cache_->Save(kUrl, test_data_item));
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), url_data_net_cache_->Size());
60d68cd
-  ASSERT_TRUE(url_data_net_cache_->LookUp(kUrl));
60d68cd
+  ASSERT_TRUE(url_data_net_cache_->LookUp(kUrl) != 0);
60d68cd
   ASSERT_EQ(kContent,
60d68cd
                        url_data_net_cache_->Fetch(kUrl)->get_content());
60d68cd
 }
60d68cd
@@ -172,7 +172,7 @@ TEST_F(NetCacheTest, TestBasicSave) {
60d68cd
 // Verify basic usage of the Delete() method.
60d68cd
 TEST_F(NetCacheTest, TestBasicDelete) {
60d68cd
   const string kUrl("http://host.com/style/simple.kml");
60d68cd
-  ASSERT_TRUE(url_data_net_cache_->Fetch(kUrl));
60d68cd
+  ASSERT_TRUE(url_data_net_cache_->Fetch(kUrl) != 0);
60d68cd
   ASSERT_TRUE(url_data_net_cache_->Delete(kUrl));
60d68cd
   ASSERT_EQ(kSize0, url_data_net_cache_->Size());
60d68cd
   ASSERT_FALSE(url_data_net_cache_->LookUp(kUrl));
60d68cd
@@ -181,7 +181,7 @@ TEST_F(NetCacheTest, TestBasicDelete) {
60d68cd
 // Verify basic usage of the RemoveOldest method.
60d68cd
 TEST_F(NetCacheTest, TestBasicRemoveOldest) {
60d68cd
   const string kUrl("http://host.com/style/simple.kml");
60d68cd
-  ASSERT_TRUE(url_data_net_cache_->Fetch(kUrl));
60d68cd
+  ASSERT_TRUE(url_data_net_cache_->Fetch(kUrl) != 0);
60d68cd
   ASSERT_TRUE(url_data_net_cache_->RemoveOldest());
60d68cd
   ASSERT_EQ(kSize0, url_data_net_cache_->Size());
60d68cd
   ASSERT_FALSE(url_data_net_cache_->LookUp(kUrl));
60d68cd
@@ -202,11 +202,11 @@ TEST_F(NetCacheTest, TestOverflow) {
60d68cd
   for (size_t i = 0; i < kUrlDataNetCacheSize*2; ++i) {
60d68cd
     const string kUrl("http://host.com/" + ToString(i));
60d68cd
     MemoryFilePtr url_data = url_data_net_cache_->Fetch(kUrl);
60d68cd
-    ASSERT_TRUE(url_data);  // UrlDataNetFetcher never fails.
60d68cd
+    ASSERT_TRUE(url_data != 0);  // UrlDataNetFetcher never fails.
60d68cd
     // UrlDataNetFetcher simply uses the url as the content.
60d68cd
     ASSERT_EQ(kUrl, url_data->get_content());
60d68cd
     // The most recently Fetch()'ed url is guaranteed to bein the cache.
60d68cd
-    ASSERT_TRUE(url_data_net_cache_->LookUp(kUrl));
60d68cd
+    ASSERT_TRUE(url_data_net_cache_->LookUp(kUrl) != 0);
60d68cd
     const size_t want_size =
60d68cd
         i < kUrlDataNetCacheSize ? i + 1 : kUrlDataNetCacheSize;
60d68cd
     ASSERT_EQ(want_size, url_data_net_cache_->Size());
60d68cd
@@ -215,7 +215,7 @@ TEST_F(NetCacheTest, TestOverflow) {
60d68cd
   // the test range.
60d68cd
   for (size_t i = kUrlDataNetCacheSize; i < kUrlDataNetCacheSize*2; ++i) {
60d68cd
     const string kUrl("http://host.com/" + ToString(i));
60d68cd
-    ASSERT_TRUE(url_data_net_cache_->LookUp(kUrl));
60d68cd
+    ASSERT_TRUE(url_data_net_cache_->LookUp(kUrl) != 0);
60d68cd
   }
60d68cd
   // RemoveOldest() removes items one at a time.
60d68cd
   for (size_t i = 0; i < kUrlDataNetCacheSize; ++i) {
60d68cd
diff --git a/tests/kml/base/zip_file_test.cc b/tests/kml/base/zip_file_test.cc
60d68cd
index 6f48699..4ce8fc0 100644
60d68cd
--- a/tests/kml/base/zip_file_test.cc
60d68cd
+++ b/tests/kml/base/zip_file_test.cc
60d68cd
@@ -55,7 +55,7 @@ TEST_F(ZipFileTest, TestOpenFromString) {
60d68cd
   ASSERT_TRUE(File::ReadFileToString(kGoodKmz, &zip_file_data));
60d68cd
   ASSERT_FALSE(zip_file_data.empty());
60d68cd
   zip_file_.reset(ZipFile::OpenFromString(zip_file_data));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   string kml_data;
60d68cd
   // doc.kml can be read.
60d68cd
   ASSERT_TRUE(zip_file_->FindFirstOf(".kml", &kml_data));
60d68cd
@@ -66,7 +66,7 @@ TEST_F(ZipFileTest, TestOpenFromString) {
60d68cd
   ASSERT_TRUE(File::ReadFileToString(kBadKmz, &zip_file_data));
60d68cd
   ASSERT_FALSE(zip_file_data.empty());
60d68cd
   zip_file_.reset(ZipFile::OpenFromString(zip_file_data));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   kml_data.clear();
60d68cd
   // There is no KML file to read.
60d68cd
   ASSERT_FALSE(zip_file_->FindFirstOf(".kml", &kml_data));
60d68cd
@@ -77,7 +77,7 @@ TEST_F(ZipFileTest, TestOpenFromFile) {
60d68cd
   // doc.kmz contains doc.kml and is a valid zip archive.
60d68cd
   const string kGoodKmz = string(DATADIR) + "/kmz/doc.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kGoodKmz.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   string kml_data;
60d68cd
   // doc.kml can be read.
60d68cd
   ASSERT_TRUE(zip_file_->FindFirstOf(".kml", &kml_data));
60d68cd
@@ -85,7 +85,7 @@ TEST_F(ZipFileTest, TestOpenFromFile) {
60d68cd
   // nokml.kmz is a valid zip archive, but does not contain any KML files
60d68cd
   const string kBadKmz = string(DATADIR) + "/kmz/nokml.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kBadKmz.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   kml_data.clear();
60d68cd
   // There is no KML file to read.
60d68cd
   ASSERT_FALSE(zip_file_->FindFirstOf(".kml", &kml_data));
60d68cd
@@ -139,7 +139,7 @@ TEST_F(ZipFileTest, TestIsZipData) {
60d68cd
 TEST_F(ZipFileTest, TestFindFirstOf) {
60d68cd
   const string kGoodKmz = string(DATADIR) + "/kmz/doc.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kGoodKmz.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   string kml_data;
60d68cd
   ASSERT_FALSE(zip_file_->FindFirstOf(".bad", &kml_data));
60d68cd
   ASSERT_TRUE(kml_data.empty());
60d68cd
@@ -153,7 +153,7 @@ TEST_F(ZipFileTest, TestGetToc) {
60d68cd
   // - a/a.kml
60d68cd
   const string kMulti1 = string(DATADIR) + "/kmz/multikml-nodoc.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kMulti1.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   StringVector list;
60d68cd
   zip_file_->GetToc(&list);
60d68cd
   // 3 files were read into the vector.
60d68cd
@@ -167,7 +167,7 @@ TEST_F(ZipFileTest, TestGetToc) {
60d68cd
 TEST_F(ZipFileTest, TestIsInToc) {
60d68cd
   const string kGoodKmz = string(DATADIR) + "/kmz/doc.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kGoodKmz.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   ASSERT_TRUE(zip_file_->IsInToc("doc.kml"));
60d68cd
   ASSERT_FALSE(zip_file_->IsInToc("docx.kml"));
60d68cd
 }
60d68cd
@@ -176,7 +176,7 @@ TEST_F(ZipFileTest, TestGetEntry) {
60d68cd
   // nokml.kmz has a file called foo.txt in a folder called foo.
60d68cd
   const string kNokml = string(DATADIR) + "/kmz/nokml.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kNokml.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   string file_data;
60d68cd
   ASSERT_TRUE(zip_file_->GetEntry("foo/foo.txt", &file_data));
60d68cd
   ASSERT_FALSE(file_data.empty());
60d68cd
@@ -195,7 +195,7 @@ TEST_F(ZipFileTest, TestGetKmzData) {
60d68cd
   string kmz_data;
60d68cd
   File::ReadFileToString(kGoodKmz, &kmz_data);
60d68cd
   zip_file_.reset(ZipFile::OpenFromString(kmz_data));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   ASSERT_EQ(kmz_data, zip_file_->get_data());
60d68cd
 }
60d68cd
 
60d68cd
@@ -331,25 +331,25 @@ TEST_F(ZipFileTest, TestMinizipOverflow) {
60d68cd
   const string kOverflowBadOffset = string(DATADIR) +
60d68cd
     "/kmz/overflow_bad_offset.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kOverflowBadOffset.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   ASSERT_FALSE(zip_file_->GetEntry(kDefaultKml, NULL));
60d68cd
 
60d68cd
   const string kOverflowStack = string(DATADIR) +
60d68cd
     "/kmz/overflow_corrupted_stack.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kOverflowStack.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   ASSERT_FALSE(zip_file_->GetEntry(kDefaultKml, NULL));
60d68cd
 
60d68cd
   const string kOverflowOpen = string(DATADIR) +
60d68cd
     "/kmz/overflow_unzOpenCurrentFile.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kOverflowOpen.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   ASSERT_FALSE(zip_file_->GetEntry(kDefaultKml, NULL));
60d68cd
 
60d68cd
   const string kOverflowRead = string(DATADIR) +
60d68cd
     "/kmz/overflow_unzReadCurrentFile.kmz";
60d68cd
   zip_file_.reset(ZipFile::OpenFromFile(kOverflowRead.c_str()));
60d68cd
-  ASSERT_TRUE(zip_file_);
60d68cd
+  ASSERT_TRUE(zip_file_ != 0);
60d68cd
   ASSERT_TRUE(zip_file_->GetEntry(kDefaultKml, NULL));
60d68cd
 }
60d68cd
 
60d68cd
diff --git a/tests/kml/convenience/csv_file_test.cc b/tests/kml/convenience/csv_file_test.cc
60d68cd
index 7d9b85e..988dcac 100644
60d68cd
--- a/tests/kml/convenience/csv_file_test.cc
60d68cd
+++ b/tests/kml/convenience/csv_file_test.cc
60d68cd
@@ -128,7 +128,7 @@ TEST_F(CsvFileTest, TestParseCsvLine) {
60d68cd
   for (size_t i = 0; i < kLineCount; ++i) {
60d68cd
     PlacemarkPtr placemark = kmldom::AsPlacemark(
60d68cd
         folder->get_feature_array_at(i));
60d68cd
-    ASSERT_TRUE(placemark);
60d68cd
+    ASSERT_TRUE(placemark != 0);
60d68cd
     ComparePlacemark(placemark, i);
60d68cd
   }
60d68cd
 }
60d68cd
diff --git a/tests/kml/convenience/csv_parser_test.cc b/tests/kml/convenience/csv_parser_test.cc
60d68cd
index 62ed9e4..aec12d1 100644
60d68cd
--- a/tests/kml/convenience/csv_parser_test.cc
60d68cd
+++ b/tests/kml/convenience/csv_parser_test.cc
60d68cd
@@ -226,7 +226,7 @@ TEST(CsvParserTest, TestCsvLineToPlacemarkWithNameAndDescription) {
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), folder->get_feature_array_size());
60d68cd
   kmldom::PlacemarkPtr placemark =
60d68cd
       kmldom::AsPlacemark(folder->get_feature_array_at(0));
60d68cd
-  ASSERT_TRUE(placemark);
60d68cd
+  ASSERT_TRUE(placemark != 0);
60d68cd
   ASSERT_TRUE(CheckPointLatLon(placemark, kLat, kLon));
60d68cd
   ASSERT_TRUE(placemark->has_name());
60d68cd
   ASSERT_EQ(kName, placemark->get_name());
60d68cd
@@ -297,7 +297,7 @@ TEST(CsvParserTest, TestLincolnParkGc) {
60d68cd
   for (size_t i = 0; i < 18; ++i) {
60d68cd
     const kmldom::PlacemarkPtr& p =
60d68cd
         kmldom::AsPlacemark(folder->get_feature_array_at(i));
60d68cd
-    ASSERT_TRUE(p);
60d68cd
+    ASSERT_TRUE(p != 0);
60d68cd
     ASSERT_EQ(kmlbase::ToString(i+1), p->get_name());
60d68cd
     ASSERT_TRUE(p->has_extendeddata());
60d68cd
     const kmldom::ExtendedDataPtr ed = p->get_extendeddata();
60d68cd
@@ -426,7 +426,7 @@ TEST(CsvParserTest, TestFeatureId) {
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), folder->get_feature_array_size());
60d68cd
   const kmldom::PlacemarkPtr p =
60d68cd
       kmldom::AsPlacemark(folder->get_feature_array_at(0));
60d68cd
-  ASSERT_TRUE(p);
60d68cd
+  ASSERT_TRUE(p != 0);
60d68cd
   ASSERT_TRUE(p->has_id());
60d68cd
   ASSERT_EQ(string("feature-abc"), p->get_id());
60d68cd
   ASSERT_TRUE(CheckPointLatLon(p, 1.1, -2.2));
60d68cd
@@ -441,14 +441,14 @@ TEST(CsvParserTest, TestStyleId) {
60d68cd
   ASSERT_TRUE(CsvParser::ParseCsv(&csv_splitter, &container_saver));
60d68cd
   ASSERT_EQ(static_cast<size_t>(2), folder->get_feature_array_size());
60d68cd
   kmldom::PlacemarkPtr p = kmldom::AsPlacemark(folder->get_feature_array_at(0));
60d68cd
-  ASSERT_TRUE(p);
60d68cd
+  ASSERT_TRUE(p != 0);
60d68cd
   ASSERT_TRUE(p->has_id());
60d68cd
   ASSERT_EQ(string("feature-abc"), p->get_id());
60d68cd
   ASSERT_TRUE(p->has_styleurl());
60d68cd
   ASSERT_EQ(string("style.kml#style-big"), p->get_styleurl());
60d68cd
   ASSERT_TRUE(CheckPointLatLon(p, 1.1, -2.2));
60d68cd
   p = kmldom::AsPlacemark(folder->get_feature_array_at(1));
60d68cd
-  ASSERT_TRUE(p);
60d68cd
+  ASSERT_TRUE(p != 0);
60d68cd
   ASSERT_TRUE(p->has_id());
60d68cd
   ASSERT_EQ(string("feature-xyz"), p->get_id());
60d68cd
   ASSERT_TRUE(p->has_styleurl());
60d68cd
@@ -474,7 +474,7 @@ TEST(CsvParserTest, TestGnisAk101) {
60d68cd
   for (size_t i = 0; i < 101; ++i) {
60d68cd
     const kmldom::PlacemarkPtr& p =
60d68cd
         kmldom::AsPlacemark(folder->get_feature_array_at(i));
60d68cd
-    ASSERT_TRUE(p);
60d68cd
+    ASSERT_TRUE(p != 0);
60d68cd
     ASSERT_TRUE(p->has_extendeddata());
60d68cd
     const kmldom::ExtendedDataPtr ed = p->get_extendeddata();
60d68cd
     ASSERT_EQ(static_cast<size_t>(14), ed->get_data_array_size());
60d68cd
diff --git a/tests/kml/convenience/element_counter_test.cc b/tests/kml/convenience/element_counter_test.cc
60d68cd
index f7f548a..c19926b 100644
60d68cd
--- a/tests/kml/convenience/element_counter_test.cc
60d68cd
+++ b/tests/kml/convenience/element_counter_test.cc
60d68cd
@@ -67,7 +67,7 @@ TEST_F(ElementCounterTest, TestEmpty) {
60d68cd
 
60d68cd
 TEST_F(ElementCounterTest, TestBasicParse) {
60d68cd
   ElementPtr root = parser_->Parse("<Placemark/>", NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), element_count_map_.size());
60d68cd
   ASSERT_EQ(1, element_count_map_[kmldom::Type_Placemark]);
60d68cd
 }
60d68cd
@@ -75,7 +75,7 @@ TEST_F(ElementCounterTest, TestBasicParse) {
60d68cd
 TEST_F(ElementCounterTest, TestMultipleElements) {
60d68cd
   const string kKml("<Folder><Placemark/><Placemark/></Folder>");
60d68cd
   ElementPtr root = parser_->Parse(kKml, NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(2), element_count_map_.size());
60d68cd
   ASSERT_EQ(1, element_count_map_[kmldom::Type_Folder]);
60d68cd
   ASSERT_EQ(2, element_count_map_[kmldom::Type_Placemark]);
60d68cd
@@ -84,11 +84,11 @@ TEST_F(ElementCounterTest, TestMultipleElements) {
60d68cd
 TEST_F(ElementCounterTest, TestRepeatedParse) {
60d68cd
   const string kXml("<Placemark/>");
60d68cd
   ElementPtr root = parser_->Parse(kXml, NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), element_count_map_.size());
60d68cd
   ASSERT_EQ(1, element_count_map_[kmldom::Type_Placemark]);
60d68cd
   root = parser_->Parse(kXml, NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), element_count_map_.size());
60d68cd
   ASSERT_EQ(2, element_count_map_[kmldom::Type_Placemark]);
60d68cd
 }
60d68cd
@@ -104,7 +104,7 @@ TEST_F(ElementCounterTest, TestEachComplex) {
60d68cd
     }
60d68cd
     const string kXml(string("<") + xsd_->ElementName(i) + "/>");
60d68cd
     ElementPtr root = parser_->Parse(kXml, NULL);
60d68cd
-    ASSERT_TRUE(root);
60d68cd
+    ASSERT_TRUE(root != 0);
60d68cd
     ASSERT_EQ(type_id, root->Type());
60d68cd
     ASSERT_EQ(1, element_count_map_[type_id]);
60d68cd
   }
60d68cd
diff --git a/tests/kml/convenience/feature_list_test.cc b/tests/kml/convenience/feature_list_test.cc
60d68cd
index d91f081..82498cb 100644
60d68cd
--- a/tests/kml/convenience/feature_list_test.cc
60d68cd
+++ b/tests/kml/convenience/feature_list_test.cc
60d68cd
@@ -138,7 +138,7 @@ TEST_F(FeatureListTest, TestSave) {
60d68cd
     // Verify that these are all Placemarks
60d68cd
     PlacemarkPtr placemark =
60d68cd
         kmldom::AsPlacemark(folder->get_feature_array_at(i));
60d68cd
-    ASSERT_TRUE(placemark);
60d68cd
+    ASSERT_TRUE(placemark != 0);
60d68cd
 
60d68cd
     // Verify that each is a proper Point Placemark with lat and lon.
60d68cd
     double lat, lon;
60d68cd
diff --git a/tests/kml/convenience/google_maps_data_test.cc b/tests/kml/convenience/google_maps_data_test.cc
60d68cd
index 4ff31c1..24b8a98 100644
60d68cd
--- a/tests/kml/convenience/google_maps_data_test.cc
60d68cd
+++ b/tests/kml/convenience/google_maps_data_test.cc
60d68cd
@@ -553,7 +553,7 @@ TEST_F(GoogleMapsDataTest, TestGetKmlUri) {
60d68cd
       string(DATADIR) + "/gmaps/metafeed.xml", &maps_feed_xml));
60d68cd
   const kmldom::AtomFeedPtr feed =
60d68cd
       kmldom::AsAtomFeed(kmldom::ParseAtom(maps_feed_xml, NULL));
60d68cd
-  ASSERT_TRUE(feed);
60d68cd
+  ASSERT_TRUE(feed != 0);
60d68cd
 
60d68cd
   const string want("http://maps.google.com/maps/ms?msa=0&msid="
60d68cd
                     "201514259179526663268.0004687a1a3e44d72b6b4&output=kml");
60d68cd
diff --git a/tests/kml/convenience/google_spreadsheets_test.cc b/tests/kml/convenience/google_spreadsheets_test.cc
60d68cd
index 835177b..ad1724d 100644
60d68cd
--- a/tests/kml/convenience/google_spreadsheets_test.cc
60d68cd
+++ b/tests/kml/convenience/google_spreadsheets_test.cc
60d68cd
@@ -116,7 +116,7 @@ TEST_F(GoogleSpreadsheetsTest, TestDownloadSpreadsheet) {
60d68cd
   kmldom::AtomFeedPtr feed = AtomUtil::GetAndParseFeed(
60d68cd
       "http://example.com/gdata/doclist-metafeed.xml",
60d68cd
       test_data_http_client);
60d68cd
-  ASSERT_TRUE(feed);
60d68cd
+  ASSERT_TRUE(feed != 0);
60d68cd
 
60d68cd
   HttpRequestVector request_log;
60d68cd
   google_spreadsheets_.reset(
60d68cd
diff --git a/tests/kml/convenience/kml_feature_list_saver_test.cc b/tests/kml/convenience/kml_feature_list_saver_test.cc
60d68cd
index 9e69083..4d89fd1 100644
60d68cd
--- a/tests/kml/convenience/kml_feature_list_saver_test.cc
60d68cd
+++ b/tests/kml/convenience/kml_feature_list_saver_test.cc
60d68cd
@@ -53,7 +53,7 @@ TEST_F(KmlFeatureListSaverTest, TestBasicSaveToFeatureList) {
60d68cd
   // Verify that this is our Placemark.
60d68cd
   kmldom::PlacemarkPtr got_placemark =
60d68cd
       kmldom::AsPlacemark(folder->get_feature_array_at(0));
60d68cd
-  ASSERT_TRUE(placemark);
60d68cd
+  ASSERT_TRUE(placemark != 0);
60d68cd
   ASSERT_EQ(id, placemark->get_id());
60d68cd
 }
60d68cd
 
60d68cd
diff --git a/tests/kml/convenience/kmz_check_links_test.cc b/tests/kml/convenience/kmz_check_links_test.cc
60d68cd
index cf82255..2553449 100644
60d68cd
--- a/tests/kml/convenience/kmz_check_links_test.cc
60d68cd
+++ b/tests/kml/convenience/kmz_check_links_test.cc
60d68cd
@@ -55,7 +55,7 @@ TEST_F(KmzCheckLinksTest, TestNoLinks) {
60d68cd
   // doc.kmz has no links.
60d68cd
   const string kNoLinks = string(DATADIR) + "/kmz/doc.kmz";
60d68cd
   kmz_file_.reset(KmzFile::OpenFromFile(kNoLinks.c_str()));
60d68cd
-  ASSERT_TRUE(kmz_file_);
60d68cd
+  ASSERT_TRUE(kmz_file_ != 0);
60d68cd
   ASSERT_TRUE(KmzCheckLinks(*kmz_file_, NULL));
60d68cd
 }
60d68cd
 
60d68cd
@@ -66,7 +66,7 @@ TEST_F(KmzCheckLinksTest, TestOverlay) {
60d68cd
                                  "/kmz/zermatt-photo.kmz";
60d68cd
   kmz_file_.reset(KmzFile::OpenFromFile(kPhotoLink.c_str()));
60d68cd
   // The KML parses fine.
60d68cd
-  ASSERT_TRUE(kmz_file_);
60d68cd
+  ASSERT_TRUE(kmz_file_ != 0);
60d68cd
   // And all expected files are within the KMZ.
60d68cd
   vector<string> missing_links;
60d68cd
   ASSERT_TRUE(KmzCheckLinks(*kmz_file_, &missing_links));
60d68cd
@@ -80,7 +80,7 @@ TEST_F(KmzCheckLinksTest, TestBadOverlay) {
60d68cd
                                    "/kmz/zermatt-photo-bad.kmz";
60d68cd
   kmz_file_.reset(KmzFile::OpenFromFile(kNoPhotoLink.c_str()));
60d68cd
   // The KML parses file.
60d68cd
-  ASSERT_TRUE(kmz_file_);
60d68cd
+  ASSERT_TRUE(kmz_file_ != 0);
60d68cd
   // But there's a dangling link.
60d68cd
   vector<string> missing_links;
60d68cd
   ASSERT_FALSE(KmzCheckLinks(*kmz_file_, &missing_links));
60d68cd
@@ -93,7 +93,7 @@ TEST_F(KmzCheckLinksTest, TestNull) {
60d68cd
   // There is no KML file in this KMZ file.
60d68cd
   const string kNoKml = string(DATADIR) + "/kmz/nokml.kmz";
60d68cd
   kmz_file_.reset(KmzFile::OpenFromFile(kNoKml.c_str()));
60d68cd
-  ASSERT_TRUE(kmz_file_);
60d68cd
+  ASSERT_TRUE(kmz_file_ != 0);
60d68cd
   ASSERT_FALSE(KmzCheckLinks(*kmz_file_, NULL));
60d68cd
 }
60d68cd
 
60d68cd
diff --git a/tests/kml/dom/abstractview_test.cc b/tests/kml/dom/abstractview_test.cc
60d68cd
index f2e61d9..bc9776b 100644
60d68cd
--- a/tests/kml/dom/abstractview_test.cc
60d68cd
+++ b/tests/kml/dom/abstractview_test.cc
60d68cd
@@ -308,7 +308,7 @@ TEST_F(CameraTest, TestSetGetHasClear) {
60d68cd
 TEST(AbstractViewTest, TestParseSerializeGxAltitudeMode) {
60d68cd
   KmlFactory* factory = KmlFactory::GetFactory();
60d68cd
   CameraPtr camera = factory->CreateCamera();
60d68cd
-  ASSERT_TRUE(camera);
60d68cd
+  ASSERT_TRUE(camera != 0);
60d68cd
   camera->set_latitude(37.0);
60d68cd
   camera->set_longitude(-122.0);
60d68cd
   camera->set_gx_altitudemode(GX_ALTITUDEMODE_RELATIVETOSEAFLOOR);
60d68cd
@@ -322,7 +322,7 @@ TEST(AbstractViewTest, TestParseSerializeGxAltitudeMode) {
60d68cd
   ASSERT_EQ(kCameraExpected, SerializeRaw(Parse(kCameraExpected, NULL)));
60d68cd
 
60d68cd
   LookAtPtr lookat = factory->CreateLookAt();
60d68cd
-  ASSERT_TRUE(lookat);
60d68cd
+  ASSERT_TRUE(lookat != 0);
60d68cd
   lookat->set_latitude(37.0);
60d68cd
   lookat->set_longitude(-122.0);
60d68cd
   lookat->set_gx_altitudemode(GX_ALTITUDEMODE_CLAMPTOSEAFLOOR);
60d68cd
@@ -340,7 +340,7 @@ TEST(AbstractViewTest, TestGxTimePrimitives) {
60d68cd
   KmlFactory* factory = KmlFactory::GetFactory();
60d68cd
 
60d68cd
   CameraPtr camera = factory->CreateCamera();
60d68cd
-  ASSERT_TRUE(camera);
60d68cd
+  ASSERT_TRUE(camera != 0);
60d68cd
   camera->set_latitude(37.0);
60d68cd
   camera->set_longitude(-122.0);
60d68cd
   GxTimeSpanPtr gx_timespan = factory->CreateGxTimeSpan();
60d68cd
@@ -355,7 +355,7 @@ TEST(AbstractViewTest, TestGxTimePrimitives) {
60d68cd
   ASSERT_EQ(kCameraExpected, SerializeRaw(Parse(kCameraExpected, NULL)));
60d68cd
 
60d68cd
   LookAtPtr lookat = factory->CreateLookAt();
60d68cd
-  ASSERT_TRUE(lookat);
60d68cd
+  ASSERT_TRUE(lookat != 0);
60d68cd
   lookat->set_latitude(37.0);
60d68cd
   lookat->set_longitude(-122.0);
60d68cd
   GxTimeStampPtr gx_timestamp = factory->CreateGxTimeStamp();
60d68cd
diff --git a/tests/kml/dom/atom_test.cc b/tests/kml/dom/atom_test.cc
60d68cd
index a9a8ffa..da73cf0 100644
60d68cd
--- a/tests/kml/dom/atom_test.cc
60d68cd
+++ b/tests/kml/dom/atom_test.cc
60d68cd
@@ -75,7 +75,7 @@ TEST_F(AtomCategoryTest, TestParseScheme) {
60d68cd
   // ParseKml calls AddElement.
60d68cd
   atomcategory_ = AsAtomCategory(
60d68cd
       ParseKml(string("<atom:category scheme='") + kScheme + "'/>"));
60d68cd
-  ASSERT_TRUE(atomcategory_);
60d68cd
+  ASSERT_TRUE(atomcategory_ != 0);
60d68cd
   ASSERT_TRUE(atomcategory_->has_scheme());
60d68cd
   ASSERT_EQ(kScheme, atomcategory_->get_scheme());
60d68cd
 }
60d68cd
@@ -85,7 +85,7 @@ TEST_F(AtomCategoryTest, TestParseLabel) {
60d68cd
   // ParseKml calls AddElement.
60d68cd
   atomcategory_ = AsAtomCategory(
60d68cd
       ParseKml(string("<atom:category label='") + kLabel + "'/>"));
60d68cd
-  ASSERT_TRUE(atomcategory_);
60d68cd
+  ASSERT_TRUE(atomcategory_ != 0);
60d68cd
   ASSERT_TRUE(atomcategory_->has_label());
60d68cd
   ASSERT_EQ(kLabel, atomcategory_->get_label());
60d68cd
 }
60d68cd
@@ -95,7 +95,7 @@ TEST_F(AtomCategoryTest, TestParseTerm) {
60d68cd
   // ParseKml calls AddElement.
60d68cd
   atomcategory_ = AsAtomCategory(
60d68cd
       ParseKml(string("<atom:category term='") + kTerm + "'/>"));
60d68cd
-  ASSERT_TRUE(atomcategory_);
60d68cd
+  ASSERT_TRUE(atomcategory_ != 0);
60d68cd
   ASSERT_TRUE(atomcategory_->has_term());
60d68cd
   ASSERT_EQ(kTerm, atomcategory_->get_term());
60d68cd
 }
60d68cd
@@ -124,7 +124,7 @@ TEST_F(AtomContentTest, TestParseSrc) {
60d68cd
   // ParseKml calls AddElement.
60d68cd
   atomcontent_ = AsAtomContent(
60d68cd
       ParseKml(string("<atom:content src='") + kSrc + "'/>"));
60d68cd
-  ASSERT_TRUE(atomcontent_);
60d68cd
+  ASSERT_TRUE(atomcontent_ != 0);
60d68cd
   ASSERT_TRUE(atomcontent_->has_src());
60d68cd
   ASSERT_EQ(kSrc, atomcontent_->get_src());
60d68cd
 }
60d68cd
@@ -134,7 +134,7 @@ TEST_F(AtomContentTest, TestParseType) {
60d68cd
   // ParseKml calls AddElement.
60d68cd
   atomcontent_ = AsAtomContent(
60d68cd
       ParseKml(string("<atom:content type='") + kType + "'/>"));
60d68cd
-  ASSERT_TRUE(atomcontent_);
60d68cd
+  ASSERT_TRUE(atomcontent_ != 0);
60d68cd
   ASSERT_TRUE(atomcontent_->has_type());
60d68cd
   ASSERT_EQ(kType, atomcontent_->get_type());
60d68cd
 }
60d68cd
@@ -143,7 +143,7 @@ TEST_F(AtomContentTest, TestParseUnknownContent) {
60d68cd
   const string kContent("<goo:bar>baz<goo:a>foo</goo:a></goo:bar>\n");
60d68cd
   atomcontent_ = AsAtomContent(
60d68cd
       ParseKml(string("<atom:content>") + kContent + "</atom:content>"));
60d68cd
-  ASSERT_TRUE(atomcontent_);
60d68cd
+  ASSERT_TRUE(atomcontent_ != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1),
60d68cd
             atomcontent_->get_unknown_elements_array_size());
60d68cd
   ASSERT_EQ(kContent, atomcontent_->get_unknown_elements_array_at(0));
60d68cd
@@ -162,7 +162,7 @@ TEST_F(AtomContentTest, TestParseUnknownContentWithUnknownAttributes) {
60d68cd
      string("
60d68cd
                     " xml:base='http://diveintomark.org/'>" + kContent +
60d68cd
                  "</atom:content>"));
60d68cd
-  ASSERT_TRUE(atomcontent_);
60d68cd
+  ASSERT_TRUE(atomcontent_ != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1),
60d68cd
             atomcontent_->get_unknown_elements_array_size());
60d68cd
   ASSERT_EQ(kContent, atomcontent_->get_unknown_elements_array_at(0));
60d68cd
@@ -186,14 +186,14 @@ TEST_F(AtomContentTest, TestParseMisplacedContent) {
60d68cd
                                "</name></Placemark>");
60d68cd
   atomcontent_ = AsAtomContent(
60d68cd
       ParseKml(string("<atom:content>") + kPlacemark + "</atom:content>"));
60d68cd
-  ASSERT_TRUE(atomcontent_);
60d68cd
+  ASSERT_TRUE(atomcontent_ != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(0),
60d68cd
             atomcontent_->get_unknown_elements_array_size());
60d68cd
   ASSERT_EQ(static_cast<size_t>(1),
60d68cd
             atomcontent_->get_misplaced_elements_array_size());
60d68cd
   PlacemarkPtr placemark = AsPlacemark(
60d68cd
       atomcontent_->get_misplaced_elements_array_at(0));
60d68cd
-  ASSERT_TRUE(placemark);
60d68cd
+  ASSERT_TRUE(placemark != 0);
60d68cd
   ASSERT_EQ(kName, placemark->get_name());
60d68cd
 }
60d68cd
 
60d68cd
@@ -402,7 +402,7 @@ TEST_F(AtomEntryTest, TestSetSummary) {
60d68cd
 TEST_F(AtomEntryTest, TestSetContent) {
60d68cd
   atomentry_->set_content(KmlFactory::GetFactory()->CreateAtomContent());
60d68cd
   ASSERT_TRUE(atomentry_->has_content());
60d68cd
-  ASSERT_TRUE(atomentry_->get_content());
60d68cd
+  ASSERT_TRUE(atomentry_->get_content() != 0);
60d68cd
 }
60d68cd
 
60d68cd
 TEST_F(AtomEntryTest, TestParseSummary) {
60d68cd
diff --git a/tests/kml/dom/document_test.cc b/tests/kml/dom/document_test.cc
60d68cd
index 1bb72da..6dad687 100644
60d68cd
--- a/tests/kml/dom/document_test.cc
60d68cd
+++ b/tests/kml/dom/document_test.cc
60d68cd
@@ -110,7 +110,7 @@ TEST_F(DocumentTest, TestDeleteSchemaAndStyleSelectorAt) {
60d68cd
   orig_style->set_id("style0");
60d68cd
   document_->add_styleselector(orig_style);
60d68cd
   StyleSelectorPtr got_style = document_->DeleteStyleSelectorAt(0);
60d68cd
-  ASSERT_TRUE(got_style);
60d68cd
+  ASSERT_TRUE(got_style != 0);
60d68cd
   ASSERT_EQ(orig_style->get_id(), got_style->get_id());
60d68cd
   ASSERT_FALSE(document_->DeleteStyleSelectorAt(0));
60d68cd
 
60d68cd
@@ -118,7 +118,7 @@ TEST_F(DocumentTest, TestDeleteSchemaAndStyleSelectorAt) {
60d68cd
   orig_schema->set_name("schema0");
60d68cd
   document_->add_schema(orig_schema);
60d68cd
   SchemaPtr got_schema = document_->DeleteSchemaAt(0);
60d68cd
-  ASSERT_TRUE(got_schema);
60d68cd
+  ASSERT_TRUE(got_schema != 0);
60d68cd
   ASSERT_EQ(orig_schema->get_name(), got_schema->get_name());
60d68cd
   ASSERT_FALSE(document_->DeleteSchemaAt(0));
60d68cd
 }
60d68cd
diff --git a/tests/kml/dom/extendeddata_test.cc b/tests/kml/dom/extendeddata_test.cc
60d68cd
index 09e5e5e..61ccc4e 100644
60d68cd
--- a/tests/kml/dom/extendeddata_test.cc
60d68cd
+++ b/tests/kml/dom/extendeddata_test.cc
60d68cd
@@ -259,16 +259,16 @@ TEST_F(ExtendedDataTest, TestParse) {
60d68cd
     "</ExtendedData>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kml, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const ExtendedDataPtr extendeddata = AsExtendedData(root);
60d68cd
-  ASSERT_TRUE(extendeddata);
60d68cd
+  ASSERT_TRUE(extendeddata != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1),
60d68cd
                        extendeddata->get_data_array_size());
60d68cd
   ASSERT_EQ(static_cast<size_t>(1),
60d68cd
                        extendeddata->get_schemadata_array_size());
60d68cd
   const DataPtr data = AsData(extendeddata->get_data_array_at(0));
60d68cd
-  ASSERT_TRUE(data);
60d68cd
+  ASSERT_TRUE(data != 0);
60d68cd
   ASSERT_TRUE(data->has_name());
60d68cd
   ASSERT_EQ(d_name, data->get_name());
60d68cd
   ASSERT_TRUE(data->has_displayname());
60d68cd
@@ -277,13 +277,13 @@ TEST_F(ExtendedDataTest, TestParse) {
60d68cd
   ASSERT_EQ(value, data->get_value());
60d68cd
   const SchemaDataPtr schemadata = AsSchemaData(
60d68cd
       extendeddata->get_schemadata_array_at(0));
60d68cd
-  ASSERT_TRUE(schemadata);
60d68cd
+  ASSERT_TRUE(schemadata != 0);
60d68cd
   ASSERT_TRUE(schemadata->has_schemaurl());
60d68cd
   ASSERT_EQ(schemaurl, schemadata->get_schemaurl());
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), schemadata->get_simpledata_array_size());
60d68cd
   const SimpleDataPtr simpledata = AsSimpleData(
60d68cd
       schemadata->get_simpledata_array_at(0));
60d68cd
-  ASSERT_TRUE(simpledata);
60d68cd
+  ASSERT_TRUE(simpledata != 0);
60d68cd
   ASSERT_TRUE(simpledata->has_name());
60d68cd
   ASSERT_TRUE(simpledata->has_text());
60d68cd
   ASSERT_EQ(sd_name, simpledata->get_name());
60d68cd
@@ -312,7 +312,7 @@ TEST_F(MetadataTest, TestParseSerialize) {
60d68cd
     "</Metadata>");
60d68cd
 
60d68cd
   metadata_ = AsMetadata(Parse(kMetadata, NULL));
60d68cd
-  ASSERT_TRUE(metadata_);
60d68cd
+  ASSERT_TRUE(metadata_ != 0);
60d68cd
   ASSERT_EQ(kMetadata, SerializeRaw(metadata_));
60d68cd
 }
60d68cd
 
60d68cd
@@ -358,9 +358,9 @@ TEST_F(GxSimpleArrayDataTest, TestParseSerialize) {
60d68cd
       "<gx:value>v3</gx:value>"
60d68cd
       "</gx:SimpleArrayData>");
60d68cd
   ElementPtr root = Parse(kKml, NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   const GxSimpleArrayDataPtr gx_simplearraydata = AsGxSimpleArrayData(root);
60d68cd
-  ASSERT_TRUE(gx_simplearraydata);
60d68cd
+  ASSERT_TRUE(gx_simplearraydata != 0);
60d68cd
   ASSERT_TRUE(gx_simplearraydata->has_name());
60d68cd
   ASSERT_EQ("myname", gx_simplearraydata->get_name());
60d68cd
   ASSERT_EQ(static_cast<size_t>(3),
60d68cd
diff --git a/tests/kml/dom/folder_test.cc b/tests/kml/dom/folder_test.cc
60d68cd
index 544d3a9..a19980b 100644
60d68cd
--- a/tests/kml/dom/folder_test.cc
60d68cd
+++ b/tests/kml/dom/folder_test.cc
60d68cd
@@ -66,10 +66,10 @@ TEST_F(FolderTest, TestParse) {
60d68cd
     "</Folder>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kFolder, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const FolderPtr folder = AsFolder(root);
60d68cd
-  ASSERT_TRUE(folder);
60d68cd
+  ASSERT_TRUE(folder != 0);
60d68cd
   // Verify the Object-ness of Folder.
60d68cd
   ASSERT_EQ(string("folder123"), folder->get_id());
60d68cd
   ASSERT_FALSE(folder->has_targetid());
60d68cd
diff --git a/tests/kml/dom/geometry_test.cc b/tests/kml/dom/geometry_test.cc
60d68cd
index 9b38aa1..319c362 100644
60d68cd
--- a/tests/kml/dom/geometry_test.cc
60d68cd
+++ b/tests/kml/dom/geometry_test.cc
60d68cd
@@ -520,10 +520,10 @@ TEST_F(PointTest, TestSerializeParseAll) {
60d68cd
   ASSERT_EQ(expected, SerializeRaw(point_));
60d68cd
   string errors;
60d68cd
   ElementPtr element = Parse(expected, &errors);
60d68cd
-  ASSERT_TRUE(element);
60d68cd
+  ASSERT_TRUE(element != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   PointPtr point = AsPoint(element);
60d68cd
-  ASSERT_TRUE(point);
60d68cd
+  ASSERT_TRUE(point != 0);
60d68cd
   ASSERT_TRUE(point->has_id());
60d68cd
   ASSERT_EQ(string("point-id"), point->get_id());
60d68cd
   ASSERT_TRUE(point->has_extrude());
60d68cd
@@ -646,10 +646,10 @@ TEST_F(LineStringTest, TestSerializeParseAll) {
60d68cd
   ASSERT_EQ(expected, SerializeRaw(linestring_));
60d68cd
   string errors;
60d68cd
   ElementPtr element = Parse(expected, &errors);
60d68cd
-  ASSERT_TRUE(element);
60d68cd
+  ASSERT_TRUE(element != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   LineStringPtr linestring = AsLineString(element);
60d68cd
-  ASSERT_TRUE(linestring);
60d68cd
+  ASSERT_TRUE(linestring != 0);
60d68cd
   ASSERT_TRUE(linestring->has_id());
60d68cd
   ASSERT_EQ(string("linestring-id"), linestring->get_id());
60d68cd
   ASSERT_TRUE(linestring->has_extrude());
60d68cd
@@ -775,10 +775,10 @@ TEST_F(LinearRingTest, TestSerializeParseAll) {
60d68cd
   ASSERT_EQ(expected, SerializeRaw(linearring_));
60d68cd
   string errors;
60d68cd
   ElementPtr element = Parse(expected, &errors);
60d68cd
-  ASSERT_TRUE(element);
60d68cd
+  ASSERT_TRUE(element != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   LinearRingPtr linearring = AsLinearRing(element);
60d68cd
-  ASSERT_TRUE(linearring);
60d68cd
+  ASSERT_TRUE(linearring != 0);
60d68cd
   ASSERT_TRUE(linearring->has_id());
60d68cd
   ASSERT_EQ(string("linearring-id"), linearring->get_id());
60d68cd
   ASSERT_TRUE(linearring->has_extrude());
60d68cd
@@ -816,7 +816,7 @@ TEST_F(OuterBoundaryIsTest, TestSetGetHasClear) {
60d68cd
   outerboundaryis_->set_linearring(
60d68cd
       KmlFactory::GetFactory()->CreateLinearRing());
60d68cd
   ASSERT_TRUE(outerboundaryis_->has_linearring());
60d68cd
-  ASSERT_TRUE(outerboundaryis_->get_linearring());
60d68cd
+  ASSERT_TRUE(outerboundaryis_->get_linearring() != 0);
60d68cd
   // Clear it and verify we're back to the default state.
60d68cd
   outerboundaryis_->clear_linearring();
60d68cd
 }
60d68cd
@@ -846,7 +846,7 @@ TEST_F(InnerBoundaryIsTest, TestSetGetHasClear) {
60d68cd
   innerboundaryis_->set_linearring(
60d68cd
       KmlFactory::GetFactory()->CreateLinearRing());
60d68cd
   ASSERT_TRUE(innerboundaryis_->has_linearring());
60d68cd
-  ASSERT_TRUE(innerboundaryis_->get_linearring());
60d68cd
+  ASSERT_TRUE(innerboundaryis_->get_linearring() != 0);
60d68cd
   // Clear it and verify we're back to the default state.
60d68cd
   innerboundaryis_->clear_linearring();
60d68cd
 }
60d68cd
@@ -968,10 +968,10 @@ TEST_F(PolygonTest, TestSerializeParseAll) {
60d68cd
   ASSERT_EQ(expected, SerializeRaw(polygon_));
60d68cd
   string errors;
60d68cd
   ElementPtr element = Parse(expected, &errors);
60d68cd
-  ASSERT_TRUE(element);
60d68cd
+  ASSERT_TRUE(element != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   PolygonPtr polygon = AsPolygon(element);
60d68cd
-  ASSERT_TRUE(polygon);
60d68cd
+  ASSERT_TRUE(polygon != 0);
60d68cd
   ASSERT_TRUE(polygon->has_id());
60d68cd
   ASSERT_EQ(string("polygon-id"), polygon->get_id());
60d68cd
   ASSERT_TRUE(polygon->has_extrude());
60d68cd
@@ -1129,10 +1129,10 @@ TEST_F(GxTrackTest, TestParse) {
60d68cd
   );
60d68cd
   string errors;
60d68cd
   ElementPtr element = Parse(kGxTrackKml, &errors);
60d68cd
-  ASSERT_TRUE(element);
60d68cd
+  ASSERT_TRUE(element != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const GxTrackPtr gx_track = AsGxTrack(element);
60d68cd
-  ASSERT_TRUE(gx_track);
60d68cd
+  ASSERT_TRUE(gx_track != 0);
60d68cd
   ASSERT_TRUE(gx_track->has_altitudemode());
60d68cd
   ASSERT_EQ(ALTITUDEMODE_RELATIVETOGROUND, gx_track->get_altitudemode());
60d68cd
   ASSERT_EQ(static_cast<size_t>(2), gx_track->get_when_array_size());
60d68cd
diff --git a/tests/kml/dom/gx_tour_test.cc b/tests/kml/dom/gx_tour_test.cc
60d68cd
index c9a779e..c41142a 100644
60d68cd
--- a/tests/kml/dom/gx_tour_test.cc
60d68cd
+++ b/tests/kml/dom/gx_tour_test.cc
60d68cd
@@ -49,9 +49,9 @@ TEST_F(GxTourTest, TestType) {
60d68cd
   ASSERT_FALSE(gx_tour_->IsA(Type_Container));
60d68cd
   ASSERT_FALSE(gx_tour_->IsA(Type_Geometry));
60d68cd
   ASSERT_TRUE(gx_tour_->IsA(Type_Object));
60d68cd
-  ASSERT_TRUE(AsGxTour(gx_tour_));
60d68cd
-  ASSERT_TRUE(AsFeature(gx_tour_));
60d68cd
-  ASSERT_TRUE(AsObject(gx_tour_));
60d68cd
+  ASSERT_TRUE(AsGxTour(gx_tour_) != 0);
60d68cd
+  ASSERT_TRUE(AsFeature(gx_tour_) != 0);
60d68cd
+  ASSERT_TRUE(AsObject(gx_tour_) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 // Verify proper defaults:
60d68cd
@@ -90,10 +90,10 @@ TEST_F(GxTourTest, TestParse) {
60d68cd
     "</gx:Tour>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kGxTour, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const GxTourPtr tour = AsGxTour(root);
60d68cd
-  ASSERT_TRUE(tour);
60d68cd
+  ASSERT_TRUE(tour != 0);
60d68cd
   ASSERT_FALSE(tour->has_id());
60d68cd
   ASSERT_FALSE(tour->has_targetid());
60d68cd
   ASSERT_TRUE(tour->has_name());
60d68cd
@@ -151,9 +151,9 @@ TEST_F(GxPlaylistTest, TestType) {
60d68cd
   ASSERT_FALSE(gx_playlist_->IsA(Type_Feature));
60d68cd
   ASSERT_FALSE(gx_playlist_->IsA(Type_Geometry));
60d68cd
   ASSERT_TRUE(gx_playlist_->IsA(Type_Object));
60d68cd
-  ASSERT_TRUE(AsGxPlaylist(gx_playlist_));
60d68cd
+  ASSERT_TRUE(AsGxPlaylist(gx_playlist_) != 0);
60d68cd
   ASSERT_FALSE(AsFeature(gx_playlist_));
60d68cd
-  ASSERT_TRUE(AsObject(gx_playlist_));
60d68cd
+  ASSERT_TRUE(AsObject(gx_playlist_) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 // Verify proper defaults:
60d68cd
@@ -182,19 +182,19 @@ TEST_F(GxPlaylistTest, TestParse) {
60d68cd
     "</gx:Playlist>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kGxPlaylist, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const GxPlaylistPtr gx_playlist = AsGxPlaylist(root);
60d68cd
-  ASSERT_TRUE(gx_playlist);
60d68cd
+  ASSERT_TRUE(gx_playlist != 0);
60d68cd
   ASSERT_TRUE(gx_playlist->has_id());
60d68cd
   ASSERT_EQ(string("gx_playlist123"), gx_playlist->get_id());
60d68cd
   ASSERT_FALSE(gx_playlist->has_targetid());
60d68cd
   ASSERT_EQ(static_cast<size_t>(3),
60d68cd
       gx_playlist->get_gx_tourprimitive_array_size());
60d68cd
   ASSERT_TRUE(AsGxAnimatedUpdate(
60d68cd
-        gx_playlist->get_gx_tourprimitive_array_at(0)));
60d68cd
-  ASSERT_TRUE(AsGxFlyTo(gx_playlist->get_gx_tourprimitive_array_at(1)));
60d68cd
-  ASSERT_TRUE(AsGxWait(gx_playlist->get_gx_tourprimitive_array_at(2)));
60d68cd
+        gx_playlist->get_gx_tourprimitive_array_at(0)) != 0);
60d68cd
+  ASSERT_TRUE(AsGxFlyTo(gx_playlist->get_gx_tourprimitive_array_at(1)) != 0);
60d68cd
+  ASSERT_TRUE(AsGxWait(gx_playlist->get_gx_tourprimitive_array_at(2)) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 TEST_F(GxPlaylistTest, TestSerialize) {
60d68cd
@@ -215,9 +215,9 @@ TEST_F(GxAnimatedUpdateTest, TestType) {
60d68cd
   ASSERT_TRUE(gx_animatedupdate_->IsA(Type_GxAnimatedUpdate));
60d68cd
   ASSERT_TRUE(gx_animatedupdate_->IsA(Type_GxTourPrimitive));
60d68cd
   ASSERT_TRUE(gx_animatedupdate_->IsA(Type_Object));
60d68cd
-  ASSERT_TRUE(AsGxAnimatedUpdate(gx_animatedupdate_));
60d68cd
-  ASSERT_TRUE(AsGxTourPrimitive(gx_animatedupdate_));
60d68cd
-  ASSERT_TRUE(AsObject(gx_animatedupdate_));
60d68cd
+  ASSERT_TRUE(AsGxAnimatedUpdate(gx_animatedupdate_) != 0);
60d68cd
+  ASSERT_TRUE(AsGxTourPrimitive(gx_animatedupdate_) != 0);
60d68cd
+  ASSERT_TRUE(AsObject(gx_animatedupdate_) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 // Verify proper defaults:
60d68cd
@@ -256,12 +256,12 @@ TEST_F(GxAnimatedUpdateTest, TestParse) {
60d68cd
     "</gx:AnimatedUpdate>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kGxAnimatedUpdate, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const GxAnimatedUpdatePtr animatedupdate = AsGxAnimatedUpdate(root);
60d68cd
   ASSERT_TRUE(animatedupdate->has_gx_duration());
60d68cd
   ASSERT_DOUBLE_EQ(1.1, animatedupdate->get_gx_duration());
60d68cd
-  ASSERT_TRUE(animatedupdate);
60d68cd
+  ASSERT_TRUE(animatedupdate != 0);
60d68cd
   ASSERT_TRUE(animatedupdate->has_update());
60d68cd
   ASSERT_EQ(kGxAnimatedUpdate, SerializeRaw(Parse(kGxAnimatedUpdate, NULL)));
60d68cd
 }
60d68cd
@@ -293,9 +293,9 @@ TEST_F(GxFlyToTest, TestType) {
60d68cd
   ASSERT_TRUE(gx_flyto_->IsA(Type_GxFlyTo));
60d68cd
   ASSERT_TRUE(gx_flyto_->IsA(Type_GxTourPrimitive));
60d68cd
   ASSERT_TRUE(gx_flyto_->IsA(Type_Object));
60d68cd
-  ASSERT_TRUE(AsGxFlyTo(gx_flyto_));
60d68cd
-  ASSERT_TRUE(AsGxTourPrimitive(gx_flyto_));
60d68cd
-  ASSERT_TRUE(AsObject(gx_flyto_));
60d68cd
+  ASSERT_TRUE(AsGxFlyTo(gx_flyto_) != 0);
60d68cd
+  ASSERT_TRUE(AsGxTourPrimitive(gx_flyto_) != 0);
60d68cd
+  ASSERT_TRUE(AsObject(gx_flyto_) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 TEST_F(GxFlyToTest, TestDefaults) {
60d68cd
@@ -358,16 +358,16 @@ TEST_F(GxFlyToTest, TestParse) {
60d68cd
     "</gx:FlyTo>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kGxFlyTo, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const GxFlyToPtr flyto = AsGxFlyTo(root);
60d68cd
-  ASSERT_TRUE(flyto);
60d68cd
+  ASSERT_TRUE(flyto != 0);
60d68cd
   ASSERT_TRUE(flyto->has_gx_duration());
60d68cd
   ASSERT_DOUBLE_EQ(10.0, flyto->get_gx_duration());
60d68cd
   ASSERT_TRUE(flyto->has_gx_flytomode());
60d68cd
   ASSERT_TRUE(GX_FLYTOMODE_SMOOTH == flyto->get_gx_flytomode());
60d68cd
   ASSERT_TRUE(flyto->has_abstractview());
60d68cd
-  ASSERT_TRUE(AsCamera(flyto->get_abstractview()));
60d68cd
+  ASSERT_TRUE(AsCamera(flyto->get_abstractview()) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 TEST_F(GxFlyToTest, TestSerialize) {
60d68cd
@@ -397,9 +397,9 @@ TEST_F(GxSoundCueTest, TestType) {
60d68cd
   ASSERT_TRUE(gx_soundcue_->IsA(Type_GxSoundCue));
60d68cd
   ASSERT_TRUE(gx_soundcue_->IsA(Type_GxTourPrimitive));
60d68cd
   ASSERT_TRUE(gx_soundcue_->IsA(Type_Object));
60d68cd
-  ASSERT_TRUE(AsGxSoundCue(gx_soundcue_));
60d68cd
-  ASSERT_TRUE(AsGxTourPrimitive(gx_soundcue_));
60d68cd
-  ASSERT_TRUE(AsObject(gx_soundcue_));
60d68cd
+  ASSERT_TRUE(AsGxSoundCue(gx_soundcue_) != 0);
60d68cd
+  ASSERT_TRUE(AsGxTourPrimitive(gx_soundcue_) != 0);
60d68cd
+  ASSERT_TRUE(AsObject(gx_soundcue_) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 TEST_F(GxSoundCueTest, TestDefaults) {
60d68cd
@@ -438,10 +438,10 @@ TEST_F(GxSoundCueTest, TestParse) {
60d68cd
     "</gx:SoundCue>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kGxSoundCue, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const GxSoundCuePtr soundcue = AsGxSoundCue(root);
60d68cd
-  ASSERT_TRUE(soundcue);
60d68cd
+  ASSERT_TRUE(soundcue != 0);
60d68cd
   ASSERT_TRUE(soundcue->has_href());
60d68cd
   ASSERT_EQ("some/cool/file.mp3", soundcue->get_href());
60d68cd
 }
60d68cd
@@ -469,9 +469,9 @@ TEST_F(GxTourControlTest, TestType) {
60d68cd
   ASSERT_TRUE(gx_tourcontrol_->IsA(Type_GxTourControl));
60d68cd
   ASSERT_TRUE(gx_tourcontrol_->IsA(Type_GxTourPrimitive));
60d68cd
   ASSERT_TRUE(gx_tourcontrol_->IsA(Type_Object));
60d68cd
-  ASSERT_TRUE(AsGxTourControl(gx_tourcontrol_));
60d68cd
-  ASSERT_TRUE(AsGxTourPrimitive(gx_tourcontrol_));
60d68cd
-  ASSERT_TRUE(AsObject(gx_tourcontrol_));
60d68cd
+  ASSERT_TRUE(AsGxTourControl(gx_tourcontrol_) != 0);
60d68cd
+  ASSERT_TRUE(AsGxTourPrimitive(gx_tourcontrol_) != 0);
60d68cd
+  ASSERT_TRUE(AsObject(gx_tourcontrol_) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 TEST_F(GxTourControlTest, TestDefaults) {
60d68cd
@@ -510,10 +510,10 @@ TEST_F(GxTourControlTest, TestParse) {
60d68cd
     "</gx:TourControl>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kGxTourControl, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const GxTourControlPtr tourcontrol = AsGxTourControl(root);
60d68cd
-  ASSERT_TRUE(tourcontrol);
60d68cd
+  ASSERT_TRUE(tourcontrol != 0);
60d68cd
   ASSERT_TRUE(tourcontrol->has_gx_playmode());
60d68cd
   ASSERT_TRUE(GX_PLAYMODE_PAUSE == tourcontrol->get_gx_playmode());
60d68cd
 }
60d68cd
@@ -541,9 +541,9 @@ TEST_F(GxWaitTest, TestType) {
60d68cd
   ASSERT_TRUE(gx_wait_->IsA(Type_GxWait));
60d68cd
   ASSERT_TRUE(gx_wait_->IsA(Type_GxTourPrimitive));
60d68cd
   ASSERT_TRUE(gx_wait_->IsA(Type_Object));
60d68cd
-  ASSERT_TRUE(AsGxWait(gx_wait_));
60d68cd
-  ASSERT_TRUE(AsGxTourPrimitive(gx_wait_));
60d68cd
-  ASSERT_TRUE(AsObject(gx_wait_));
60d68cd
+  ASSERT_TRUE(AsGxWait(gx_wait_) != 0);
60d68cd
+  ASSERT_TRUE(AsGxTourPrimitive(gx_wait_) != 0);
60d68cd
+  ASSERT_TRUE(AsObject(gx_wait_) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 }  // end namespace kmldom
60d68cd
diff --git a/tests/kml/dom/hotspot_test.cc b/tests/kml/dom/hotspot_test.cc
60d68cd
index 599a177..4519af9 100644
60d68cd
--- a/tests/kml/dom/hotspot_test.cc
60d68cd
+++ b/tests/kml/dom/hotspot_test.cc
60d68cd
@@ -54,7 +54,7 @@ TEST_F(HotSpotTest, TestParse) {
60d68cd
   ElementPtr root = Parse(
60d68cd
     "<hotSpot x=\"32\" y=\"1\" xunits=\"pixels\" yunits=\"pixels\"/>",
60d68cd
     &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
 #if 0
60d68cd
   const HotSpot* hotspot = AsHotSpot(root);
60d68cd
diff --git a/tests/kml/dom/iconstyle_test.cc b/tests/kml/dom/iconstyle_test.cc
60d68cd
index 3f47dbc..612dd42 100644
60d68cd
--- a/tests/kml/dom/iconstyle_test.cc
60d68cd
+++ b/tests/kml/dom/iconstyle_test.cc
60d68cd
@@ -118,7 +118,7 @@ TEST_F(IconStyleTest, TestParse) {
60d68cd
     "</IconStyle>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kIconStyleIcon, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const IconStylePtr iconstyle = AsIconStyle(root);
60d68cd
   ASSERT_TRUE(iconstyle->has_icon());
60d68cd
diff --git a/tests/kml/dom/kml22_test.cc b/tests/kml/dom/kml22_test.cc
60d68cd
index 3d91113..a51d80c 100644
60d68cd
--- a/tests/kml/dom/kml22_test.cc
60d68cd
+++ b/tests/kml/dom/kml22_test.cc
60d68cd
@@ -187,7 +187,7 @@ void Kml22Test::AssertXmlNamespaceForRange(KmlDomType begin_dom_type,
60d68cd
   for (; element_type_id != end_id; ++element_type_id) {
60d68cd
     ElementPtr element = kml_factory->CreateElementById(
60d68cd
         static_cast<KmlDomType>(element_type_id));
60d68cd
-    ASSERT_TRUE(element);
60d68cd
+    ASSERT_TRUE(element != 0);
60d68cd
     ASSERT_EQ(xmlns_id, element->get_xmlns())
60d68cd
         << xsd_->ElementName(element_type_id);
60d68cd
   }
60d68cd
diff --git a/tests/kml/dom/kml_cast_test.cc b/tests/kml/dom/kml_cast_test.cc
60d68cd
index 12f679e..c6c87d4 100644
60d68cd
--- a/tests/kml/dom/kml_cast_test.cc
60d68cd
+++ b/tests/kml/dom/kml_cast_test.cc
60d68cd
@@ -38,139 +38,139 @@ TEST_F(KmlCastTest, TestCasts) {
60d68cd
 
60d68cd
   // The temporary ElementPtr holds a reference to the created Element
60d68cd
   // which is released when the As*() goes out of scope.
60d68cd
-  ASSERT_TRUE(AsAbstractLatLonBox(factory->CreateElementById(Type_LatLonBox)));
60d68cd
+  ASSERT_TRUE(AsAbstractLatLonBox(factory->CreateElementById(Type_LatLonBox)) != 0);
60d68cd
   ASSERT_TRUE(AsAbstractLatLonBox(
60d68cd
-      factory->CreateElementById(Type_LatLonAltBox)));
60d68cd
-  ASSERT_TRUE(AsAbstractView(factory->CreateElementById(Type_LookAt)));
60d68cd
-  ASSERT_TRUE(AsColorStyle(factory->CreateElementById(Type_IconStyle)));
60d68cd
-  ASSERT_TRUE(AsContainer(factory->CreateElementById(Type_Folder)));
60d68cd
-  ASSERT_TRUE(AsFeature(factory->CreateElementById(Type_Placemark)));
60d68cd
-  ASSERT_TRUE(AsGeometry(factory->CreateElementById(Type_Point)));
60d68cd
-  ASSERT_TRUE(AsObject(factory->CreateElementById(Type_Placemark)));
60d68cd
-  ASSERT_TRUE(AsOverlay(factory->CreateElementById(Type_GroundOverlay)));
60d68cd
-  ASSERT_TRUE(AsStyleSelector(factory->CreateElementById(Type_Style)));
60d68cd
-  ASSERT_TRUE(AsSubStyle(factory->CreateElementById(Type_BalloonStyle)));
60d68cd
-  ASSERT_TRUE(AsTimePrimitive(factory->CreateElementById(Type_TimeSpan)));
60d68cd
-  ASSERT_TRUE(AsAlias(factory->CreateElementById(Type_Alias)));
60d68cd
-  ASSERT_TRUE(AsAtomAuthor(factory->CreateElementById(Type_AtomAuthor)));
60d68cd
-  ASSERT_TRUE(AsAtomContent(factory->CreateElementById(Type_AtomContent)));
60d68cd
-  ASSERT_TRUE(AsAtomEntry(factory->CreateElementById(Type_AtomEntry)));
60d68cd
-  ASSERT_TRUE(AsAtomFeed(factory->CreateElementById(Type_AtomFeed)));
60d68cd
-  ASSERT_TRUE(AsAtomLink(factory->CreateElementById(Type_AtomLink)));
60d68cd
-  ASSERT_TRUE(AsBalloonStyle(factory->CreateElementById(Type_BalloonStyle)));
60d68cd
-  ASSERT_TRUE(AsCamera(factory->CreateElementById(Type_Camera)));
60d68cd
-  ASSERT_TRUE(AsChange(factory->CreateElementById(Type_Change)));
60d68cd
-  ASSERT_TRUE(AsCoordinates(factory->CreateElementById(Type_coordinates)));
60d68cd
-  ASSERT_TRUE(AsCreate(factory->CreateElementById(Type_Create)));
60d68cd
-  ASSERT_TRUE(AsData(factory->CreateElementById(Type_Data)));
60d68cd
-  ASSERT_TRUE(AsDelete(factory->CreateElementById(Type_Delete)));
60d68cd
-  ASSERT_TRUE(AsDocument(factory->CreateElementById(Type_Document)));
60d68cd
-  ASSERT_TRUE(AsExtendedData(factory->CreateElementById(Type_ExtendedData)));
60d68cd
-  ASSERT_TRUE(AsFolder(factory->CreateElementById(Type_Folder)));
60d68cd
+      factory->CreateElementById(Type_LatLonAltBox)) != 0);
60d68cd
+  ASSERT_TRUE(AsAbstractView(factory->CreateElementById(Type_LookAt)) != 0);
60d68cd
+  ASSERT_TRUE(AsColorStyle(factory->CreateElementById(Type_IconStyle)) != 0);
60d68cd
+  ASSERT_TRUE(AsContainer(factory->CreateElementById(Type_Folder)) != 0);
60d68cd
+  ASSERT_TRUE(AsFeature(factory->CreateElementById(Type_Placemark)) != 0);
60d68cd
+  ASSERT_TRUE(AsGeometry(factory->CreateElementById(Type_Point)) != 0);
60d68cd
+  ASSERT_TRUE(AsObject(factory->CreateElementById(Type_Placemark)) != 0);
60d68cd
+  ASSERT_TRUE(AsOverlay(factory->CreateElementById(Type_GroundOverlay)) != 0);
60d68cd
+  ASSERT_TRUE(AsStyleSelector(factory->CreateElementById(Type_Style)) != 0);
60d68cd
+  ASSERT_TRUE(AsSubStyle(factory->CreateElementById(Type_BalloonStyle)) != 0);
60d68cd
+  ASSERT_TRUE(AsTimePrimitive(factory->CreateElementById(Type_TimeSpan)) != 0);
60d68cd
+  ASSERT_TRUE(AsAlias(factory->CreateElementById(Type_Alias)) != 0);
60d68cd
+  ASSERT_TRUE(AsAtomAuthor(factory->CreateElementById(Type_AtomAuthor)) != 0);
60d68cd
+  ASSERT_TRUE(AsAtomContent(factory->CreateElementById(Type_AtomContent)) != 0);
60d68cd
+  ASSERT_TRUE(AsAtomEntry(factory->CreateElementById(Type_AtomEntry)) != 0);
60d68cd
+  ASSERT_TRUE(AsAtomFeed(factory->CreateElementById(Type_AtomFeed)) != 0);
60d68cd
+  ASSERT_TRUE(AsAtomLink(factory->CreateElementById(Type_AtomLink)) != 0);
60d68cd
+  ASSERT_TRUE(AsBalloonStyle(factory->CreateElementById(Type_BalloonStyle)) != 0);
60d68cd
+  ASSERT_TRUE(AsCamera(factory->CreateElementById(Type_Camera)) != 0);
60d68cd
+  ASSERT_TRUE(AsChange(factory->CreateElementById(Type_Change)) != 0);
60d68cd
+  ASSERT_TRUE(AsCoordinates(factory->CreateElementById(Type_coordinates)) != 0);
60d68cd
+  ASSERT_TRUE(AsCreate(factory->CreateElementById(Type_Create)) != 0);
60d68cd
+  ASSERT_TRUE(AsData(factory->CreateElementById(Type_Data)) != 0);
60d68cd
+  ASSERT_TRUE(AsDelete(factory->CreateElementById(Type_Delete)) != 0);
60d68cd
+  ASSERT_TRUE(AsDocument(factory->CreateElementById(Type_Document)) != 0);
60d68cd
+  ASSERT_TRUE(AsExtendedData(factory->CreateElementById(Type_ExtendedData)) != 0);
60d68cd
+  ASSERT_TRUE(AsFolder(factory->CreateElementById(Type_Folder)) != 0);
60d68cd
   ASSERT_TRUE(AsGroundOverlay(
60d68cd
-      factory->CreateElementById(Type_GroundOverlay)));
60d68cd
-  ASSERT_TRUE(AsHotSpot(factory->CreateElementById(Type_hotSpot)));
60d68cd
-  ASSERT_TRUE(AsIcon(factory->CreateElementById(Type_Icon)));
60d68cd
-  ASSERT_TRUE(AsIconStyle(factory->CreateElementById(Type_IconStyle)));
60d68cd
-  ASSERT_TRUE(AsImagePyramid(factory->CreateElementById(Type_ImagePyramid)));
60d68cd
+      factory->CreateElementById(Type_GroundOverlay)) != 0);
60d68cd
+  ASSERT_TRUE(AsHotSpot(factory->CreateElementById(Type_hotSpot)) != 0);
60d68cd
+  ASSERT_TRUE(AsIcon(factory->CreateElementById(Type_Icon)) != 0);
60d68cd
+  ASSERT_TRUE(AsIconStyle(factory->CreateElementById(Type_IconStyle)) != 0);
60d68cd
+  ASSERT_TRUE(AsImagePyramid(factory->CreateElementById(Type_ImagePyramid)) != 0);
60d68cd
   ASSERT_TRUE(AsInnerBoundaryIs(
60d68cd
-      factory->CreateElementById(Type_innerBoundaryIs)));
60d68cd
-  ASSERT_TRUE(AsItemIcon(factory->CreateElementById(Type_ItemIcon)));
60d68cd
-  ASSERT_TRUE(AsLabelStyle(factory->CreateElementById(Type_LabelStyle)));
60d68cd
-  ASSERT_TRUE(AsLatLonAltBox(factory->CreateElementById(Type_LatLonAltBox)));
60d68cd
-  ASSERT_TRUE(AsLatLonBox(factory->CreateElementById(Type_LatLonBox)));
60d68cd
-  ASSERT_TRUE(AsLineString(factory->CreateElementById(Type_LineString)));
60d68cd
-  ASSERT_TRUE(AsLineStyle(factory->CreateElementById(Type_LineStyle)));
60d68cd
-  ASSERT_TRUE(AsLinearRing(factory->CreateElementById(Type_LinearRing)));
60d68cd
-  ASSERT_TRUE(AsLink(factory->CreateElementById(Type_Link)));
60d68cd
-  ASSERT_TRUE(AsLinkSnippet(factory->CreateElementById(Type_linkSnippet)));
60d68cd
-  ASSERT_TRUE(AsListStyle(factory->CreateElementById(Type_ListStyle)));
60d68cd
-  ASSERT_TRUE(AsLocation(factory->CreateElementById(Type_Location)));
60d68cd
-  ASSERT_TRUE(AsLod(factory->CreateElementById(Type_Lod)));
60d68cd
-  ASSERT_TRUE(AsLookAt(factory->CreateElementById(Type_LookAt)));
60d68cd
-  ASSERT_TRUE(AsKml(factory->CreateElementById(Type_kml)));
60d68cd
-  ASSERT_TRUE(AsModel(factory->CreateElementById(Type_Model)));
60d68cd
+      factory->CreateElementById(Type_innerBoundaryIs)) != 0);
60d68cd
+  ASSERT_TRUE(AsItemIcon(factory->CreateElementById(Type_ItemIcon)) != 0);
60d68cd
+  ASSERT_TRUE(AsLabelStyle(factory->CreateElementById(Type_LabelStyle)) != 0);
60d68cd
+  ASSERT_TRUE(AsLatLonAltBox(factory->CreateElementById(Type_LatLonAltBox)) != 0);
60d68cd
+  ASSERT_TRUE(AsLatLonBox(factory->CreateElementById(Type_LatLonBox)) != 0);
60d68cd
+  ASSERT_TRUE(AsLineString(factory->CreateElementById(Type_LineString)) != 0);
60d68cd
+  ASSERT_TRUE(AsLineStyle(factory->CreateElementById(Type_LineStyle)) != 0);
60d68cd
+  ASSERT_TRUE(AsLinearRing(factory->CreateElementById(Type_LinearRing)) != 0);
60d68cd
+  ASSERT_TRUE(AsLink(factory->CreateElementById(Type_Link)) != 0);
60d68cd
+  ASSERT_TRUE(AsLinkSnippet(factory->CreateElementById(Type_linkSnippet)) != 0);
60d68cd
+  ASSERT_TRUE(AsListStyle(factory->CreateElementById(Type_ListStyle)) != 0);
60d68cd
+  ASSERT_TRUE(AsLocation(factory->CreateElementById(Type_Location)) != 0);
60d68cd
+  ASSERT_TRUE(AsLod(factory->CreateElementById(Type_Lod)) != 0);
60d68cd
+  ASSERT_TRUE(AsLookAt(factory->CreateElementById(Type_LookAt)) != 0);
60d68cd
+  ASSERT_TRUE(AsKml(factory->CreateElementById(Type_kml)) != 0);
60d68cd
+  ASSERT_TRUE(AsModel(factory->CreateElementById(Type_Model)) != 0);
60d68cd
   ASSERT_TRUE(AsMultiGeometry(
60d68cd
-      factory->CreateElementById(Type_MultiGeometry)));
60d68cd
-  ASSERT_TRUE(AsNetworkLink(factory->CreateElementById(Type_NetworkLink)));
60d68cd
+      factory->CreateElementById(Type_MultiGeometry)) != 0);
60d68cd
+  ASSERT_TRUE(AsNetworkLink(factory->CreateElementById(Type_NetworkLink)) != 0);
60d68cd
   ASSERT_TRUE(AsNetworkLinkControl(
60d68cd
-      factory->CreateElementById(Type_NetworkLinkControl)));
60d68cd
-  ASSERT_TRUE(AsOrientation(factory->CreateElementById(Type_Orientation)));
60d68cd
+      factory->CreateElementById(Type_NetworkLinkControl)) != 0);
60d68cd
+  ASSERT_TRUE(AsOrientation(factory->CreateElementById(Type_Orientation)) != 0);
60d68cd
   ASSERT_TRUE(AsOuterBoundaryIs(
60d68cd
-      factory->CreateElementById(Type_outerBoundaryIs)));
60d68cd
-  ASSERT_TRUE(AsOverlayXY(factory->CreateElementById(Type_overlayXY)));
60d68cd
-  ASSERT_TRUE(AsPair(factory->CreateElementById(Type_Pair)));
60d68cd
-  ASSERT_TRUE(AsPhotoOverlay(factory->CreateElementById(Type_PhotoOverlay)));
60d68cd
-  ASSERT_TRUE(AsPlacemark(factory->CreateElementById(Type_Placemark)));
60d68cd
-  ASSERT_TRUE(AsPoint(factory->CreateElementById(Type_Point)));
60d68cd
-  ASSERT_TRUE(AsPolyStyle(factory->CreateElementById(Type_PolyStyle)));
60d68cd
-  ASSERT_TRUE(AsPolygon(factory->CreateElementById(Type_Polygon)));
60d68cd
-  ASSERT_TRUE(AsRegion(factory->CreateElementById(Type_Region)));
60d68cd
-  ASSERT_TRUE(AsResourceMap(factory->CreateElementById(Type_ResourceMap)));
60d68cd
-  ASSERT_TRUE(AsRotationXY(factory->CreateElementById(Type_rotationXY)));
60d68cd
-  ASSERT_TRUE(AsScale(factory->CreateElementById(Type_Scale)));
60d68cd
-  ASSERT_TRUE(AsSchema(factory->CreateElementById(Type_Schema)));
60d68cd
-  ASSERT_TRUE(AsSchemaData(factory->CreateElementById(Type_SchemaData)));
60d68cd
+      factory->CreateElementById(Type_outerBoundaryIs)) != 0);
60d68cd
+  ASSERT_TRUE(AsOverlayXY(factory->CreateElementById(Type_overlayXY)) != 0);
60d68cd
+  ASSERT_TRUE(AsPair(factory->CreateElementById(Type_Pair)) != 0);
60d68cd
+  ASSERT_TRUE(AsPhotoOverlay(factory->CreateElementById(Type_PhotoOverlay)) != 0);
60d68cd
+  ASSERT_TRUE(AsPlacemark(factory->CreateElementById(Type_Placemark)) != 0);
60d68cd
+  ASSERT_TRUE(AsPoint(factory->CreateElementById(Type_Point)) != 0);
60d68cd
+  ASSERT_TRUE(AsPolyStyle(factory->CreateElementById(Type_PolyStyle)) != 0);
60d68cd
+  ASSERT_TRUE(AsPolygon(factory->CreateElementById(Type_Polygon)) != 0);
60d68cd
+  ASSERT_TRUE(AsRegion(factory->CreateElementById(Type_Region)) != 0);
60d68cd
+  ASSERT_TRUE(AsResourceMap(factory->CreateElementById(Type_ResourceMap)) != 0);
60d68cd
+  ASSERT_TRUE(AsRotationXY(factory->CreateElementById(Type_rotationXY)) != 0);
60d68cd
+  ASSERT_TRUE(AsScale(factory->CreateElementById(Type_Scale)) != 0);
60d68cd
+  ASSERT_TRUE(AsSchema(factory->CreateElementById(Type_Schema)) != 0);
60d68cd
+  ASSERT_TRUE(AsSchemaData(factory->CreateElementById(Type_SchemaData)) != 0);
60d68cd
   ASSERT_TRUE(AsScreenOverlay(
60d68cd
-      factory->CreateElementById(Type_ScreenOverlay)));
60d68cd
-  ASSERT_TRUE(AsScreenXY(factory->CreateElementById(Type_screenXY)));
60d68cd
-  ASSERT_TRUE(AsSimpleData(factory->CreateElementById(Type_SimpleData)));
60d68cd
-  ASSERT_TRUE(AsSimpleField(factory->CreateElementById(Type_SimpleField)));
60d68cd
-  ASSERT_TRUE(AsSize(factory->CreateElementById(Type_size)));
60d68cd
-  ASSERT_TRUE(AsSnippet(factory->CreateElementById(Type_Snippet)));
60d68cd
-  ASSERT_TRUE(AsStyle(factory->CreateElementById(Type_Style)));
60d68cd
-  ASSERT_TRUE(AsStyleMap(factory->CreateElementById(Type_StyleMap)));
60d68cd
-  ASSERT_TRUE(AsTimeSpan(factory->CreateElementById(Type_TimeSpan)));
60d68cd
-  ASSERT_TRUE(AsTimeStamp(factory->CreateElementById(Type_TimeStamp)));
60d68cd
-  ASSERT_TRUE(AsUpdate(factory->CreateElementById(Type_Update)));
60d68cd
-  ASSERT_TRUE(AsViewVolume(factory->CreateElementById(Type_ViewVolume)));
60d68cd
+      factory->CreateElementById(Type_ScreenOverlay)) != 0);
60d68cd
+  ASSERT_TRUE(AsScreenXY(factory->CreateElementById(Type_screenXY)) != 0);
60d68cd
+  ASSERT_TRUE(AsSimpleData(factory->CreateElementById(Type_SimpleData)) != 0);
60d68cd
+  ASSERT_TRUE(AsSimpleField(factory->CreateElementById(Type_SimpleField)) != 0);
60d68cd
+  ASSERT_TRUE(AsSize(factory->CreateElementById(Type_size)) != 0);
60d68cd
+  ASSERT_TRUE(AsSnippet(factory->CreateElementById(Type_Snippet)) != 0);
60d68cd
+  ASSERT_TRUE(AsStyle(factory->CreateElementById(Type_Style)) != 0);
60d68cd
+  ASSERT_TRUE(AsStyleMap(factory->CreateElementById(Type_StyleMap)) != 0);
60d68cd
+  ASSERT_TRUE(AsTimeSpan(factory->CreateElementById(Type_TimeSpan)) != 0);
60d68cd
+  ASSERT_TRUE(AsTimeStamp(factory->CreateElementById(Type_TimeStamp)) != 0);
60d68cd
+  ASSERT_TRUE(AsUpdate(factory->CreateElementById(Type_Update)) != 0);
60d68cd
+  ASSERT_TRUE(AsViewVolume(factory->CreateElementById(Type_ViewVolume)) != 0);
60d68cd
 
60d68cd
   ASSERT_TRUE(AsXalAddressDetails(
60d68cd
-      factory->CreateElementById(Type_XalAddressDetails)));
60d68cd
+      factory->CreateElementById(Type_XalAddressDetails)) != 0);
60d68cd
   ASSERT_TRUE(AsXalAdministrativeArea(
60d68cd
-      factory->CreateElementById(Type_XalAdministrativeArea)));
60d68cd
-  ASSERT_TRUE(AsXalCountry(factory->CreateElementById(Type_XalCountry)));
60d68cd
-  ASSERT_TRUE(AsXalLocality(factory->CreateElementById(Type_XalLocality)));
60d68cd
-  ASSERT_TRUE(AsXalPostalCode(factory->CreateElementById(Type_XalPostalCode)));
60d68cd
+      factory->CreateElementById(Type_XalAdministrativeArea)) != 0);
60d68cd
+  ASSERT_TRUE(AsXalCountry(factory->CreateElementById(Type_XalCountry)) != 0);
60d68cd
+  ASSERT_TRUE(AsXalLocality(factory->CreateElementById(Type_XalLocality)) != 0);
60d68cd
+  ASSERT_TRUE(AsXalPostalCode(factory->CreateElementById(Type_XalPostalCode)) != 0);
60d68cd
   ASSERT_TRUE(AsXalSubAdministrativeArea(
60d68cd
-      factory->CreateElementById(Type_XalSubAdministrativeArea)));
60d68cd
+      factory->CreateElementById(Type_XalSubAdministrativeArea)) != 0);
60d68cd
   ASSERT_TRUE(AsXalThoroughfare(
60d68cd
-      factory->CreateElementById(Type_XalThoroughfare)));
60d68cd
+      factory->CreateElementById(Type_XalThoroughfare)) != 0);
60d68cd
 
60d68cd
   ASSERT_TRUE(AsGxAnimatedUpdate(
60d68cd
-      factory->CreateElementById(Type_GxAnimatedUpdate)));
60d68cd
+      factory->CreateElementById(Type_GxAnimatedUpdate)) != 0);
60d68cd
   ASSERT_TRUE(AsGxFlyTo(
60d68cd
-      factory->CreateElementById(Type_GxFlyTo)));
60d68cd
+      factory->CreateElementById(Type_GxFlyTo)) != 0);
60d68cd
   ASSERT_TRUE(AsGxLatLonQuad(
60d68cd
-      factory->CreateElementById(Type_GxLatLonQuad)));
60d68cd
+      factory->CreateElementById(Type_GxLatLonQuad)) != 0);
60d68cd
   ASSERT_TRUE(AsGxMultiTrack(
60d68cd
-      factory->CreateElementById(Type_GxMultiTrack)));
60d68cd
+      factory->CreateElementById(Type_GxMultiTrack)) != 0);
60d68cd
   ASSERT_TRUE(AsGxPlaylist(
60d68cd
-      factory->CreateElementById(Type_GxPlaylist)));
60d68cd
+      factory->CreateElementById(Type_GxPlaylist)) != 0);
60d68cd
   ASSERT_TRUE(AsGxSimpleArrayField(
60d68cd
-      factory->CreateElementById(Type_GxSimpleArrayField)));
60d68cd
+      factory->CreateElementById(Type_GxSimpleArrayField)) != 0);
60d68cd
   ASSERT_TRUE(AsGxSimpleArrayData(
60d68cd
-      factory->CreateElementById(Type_GxSimpleArrayData)));
60d68cd
+      factory->CreateElementById(Type_GxSimpleArrayData)) != 0);
60d68cd
   ASSERT_TRUE(AsGxSoundCue(
60d68cd
-      factory->CreateElementById(Type_GxSoundCue)));
60d68cd
+      factory->CreateElementById(Type_GxSoundCue)) != 0);
60d68cd
   ASSERT_TRUE(AsGxTimeSpan(
60d68cd
-      factory->CreateElementById(Type_GxTimeSpan)));
60d68cd
+      factory->CreateElementById(Type_GxTimeSpan)) != 0);
60d68cd
   ASSERT_TRUE(AsGxTimeStamp(
60d68cd
-      factory->CreateElementById(Type_GxTimeStamp)));
60d68cd
+      factory->CreateElementById(Type_GxTimeStamp)) != 0);
60d68cd
   ASSERT_TRUE(AsTimePrimitive(
60d68cd
-      factory->CreateElementById(Type_GxTimeSpan)));
60d68cd
+      factory->CreateElementById(Type_GxTimeSpan)) != 0);
60d68cd
   ASSERT_TRUE(AsTimePrimitive(
60d68cd
-      factory->CreateElementById(Type_GxTimeStamp)));
60d68cd
+      factory->CreateElementById(Type_GxTimeStamp)) != 0);
60d68cd
   ASSERT_TRUE(AsGxTour(
60d68cd
-      factory->CreateElementById(Type_GxTour)));
60d68cd
+      factory->CreateElementById(Type_GxTour)) != 0);
60d68cd
   ASSERT_TRUE(AsGxTourControl(
60d68cd
-      factory->CreateElementById(Type_GxTourControl)));
60d68cd
+      factory->CreateElementById(Type_GxTourControl)) != 0);
60d68cd
   ASSERT_TRUE(AsGxTourPrimitive(
60d68cd
-      factory->CreateElementById(Type_GxFlyTo)));
60d68cd
+      factory->CreateElementById(Type_GxFlyTo)) != 0);
60d68cd
   ASSERT_TRUE(AsGxTrack(
60d68cd
-      factory->CreateElementById(Type_GxTrack)));
60d68cd
+      factory->CreateElementById(Type_GxTrack)) != 0);
60d68cd
   ASSERT_TRUE(AsGxWait(
60d68cd
-      factory->CreateElementById(Type_GxWait)));
60d68cd
+      factory->CreateElementById(Type_GxWait)) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 }  // end namespace kmldom
60d68cd
diff --git a/tests/kml/dom/kml_factory_test.cc b/tests/kml/dom/kml_factory_test.cc
60d68cd
index a70049e..9fd6d2f 100644
60d68cd
--- a/tests/kml/dom/kml_factory_test.cc
60d68cd
+++ b/tests/kml/dom/kml_factory_test.cc
60d68cd
@@ -321,9 +321,9 @@ TEST(KmlFactoryTest, TestCreateElementFromName) {
60d68cd
   ASSERT_FALSE(kf->CreateElementFromName("complete junk"));
60d68cd
   ASSERT_FALSE(kf->CreateElementFromName("
60d68cd
 
60d68cd
-  ASSERT_TRUE(kmldom::AsPlacemark(kf->CreateElementFromName("Placemark")));
60d68cd
-  ASSERT_TRUE(kmldom::AsAtomAuthor(kf->CreateElementFromName("atom:author")));
60d68cd
-  ASSERT_TRUE(kmldom::AsGxTour(kf->CreateElementFromName("gx:Tour")));
60d68cd
+  ASSERT_TRUE(kmldom::AsPlacemark(kf->CreateElementFromName("Placemark")) != 0);
60d68cd
+  ASSERT_TRUE(kmldom::AsAtomAuthor(kf->CreateElementFromName("atom:author")) != 0);
60d68cd
+  ASSERT_TRUE(kmldom::AsGxTour(kf->CreateElementFromName("gx:Tour")) != 0);
60d68cd
 }
60d68cd
 
60d68cd
 }  // end namespace kmldom
60d68cd
diff --git a/tests/kml/dom/kml_handler_ns_test.cc b/tests/kml/dom/kml_handler_ns_test.cc
60d68cd
index edac146..97d43f6 100644
60d68cd
--- a/tests/kml/dom/kml_handler_ns_test.cc
60d68cd
+++ b/tests/kml/dom/kml_handler_ns_test.cc
60d68cd
@@ -184,7 +184,7 @@ TEST_F(KmlHandlerNSTest, TestNamespaceParsing) {
60d68cd
   string errors;
60d68cd
   ElementPtr root = parser.ParseNS(kNamespaceKml, &errors);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
 
60d68cd
   // TODO: ultimately the parse is preserved 1:1. Currently the parse will
60d68cd
   // drop the xmlns attrs and the element prefixes so this is a test of an
60d68cd
diff --git a/tests/kml/dom/kml_handler_test.cc b/tests/kml/dom/kml_handler_test.cc
60d68cd
index de4e03e..0f71dbe 100644
60d68cd
--- a/tests/kml/dom/kml_handler_test.cc
60d68cd
+++ b/tests/kml/dom/kml_handler_test.cc
60d68cd
@@ -248,9 +248,9 @@ void KmlHandlerTest::VerifyElementTypes(
60d68cd
 // This helper function verifies the proper state of kKmlFolder's DOM.
60d68cd
 void KmlHandlerTest::VerifyFolderParse(const ElementPtr& root) const {
60d68cd
   KmlPtr kml = AsKml(root);
60d68cd
-  ASSERT_TRUE(kml);
60d68cd
+  ASSERT_TRUE(kml != 0);
60d68cd
   FolderPtr folder = AsFolder(kml->get_feature());
60d68cd
-  ASSERT_TRUE(folder);
60d68cd
+  ASSERT_TRUE(folder != 0);
60d68cd
   ASSERT_TRUE(folder->has_name());
60d68cd
   ASSERT_FALSE(folder->has_visibility());
60d68cd
   ASSERT_FALSE(folder->has_open());
60d68cd
@@ -454,23 +454,23 @@ TEST_F(KmlHandlerTest, InhibitingEndElement) {
60d68cd
   kml_handler.EndElement("NetworkLinkControl");
60d68cd
   kml_handler.EndElement("kml");
60d68cd
   ElementPtr root = kml_handler.PopRoot();
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   KmlPtr kml = AsKml(root);
60d68cd
-  ASSERT_TRUE(kml);
60d68cd
+  ASSERT_TRUE(kml != 0);
60d68cd
   // Document is a Container and is not collected.
60d68cd
   ASSERT_TRUE(kml->has_feature());
60d68cd
-  ASSERT_TRUE(AsDocument(kml->get_feature()));
60d68cd
+  ASSERT_TRUE(AsDocument(kml->get_feature()) != 0);
60d68cd
   // NetworkLinkControl is not a Feature is not collected.
60d68cd
   ASSERT_TRUE(kml->has_networklinkcontrol());
60d68cd
   // One non-Container Feature is collected.
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), features.size());
60d68cd
   PlacemarkPtr placemark = AsPlacemark(features[0]);
60d68cd
-  ASSERT_TRUE(placemark);
60d68cd
+  ASSERT_TRUE(placemark != 0);
60d68cd
   // Verify the collected feature has all expected children.
60d68cd
   ASSERT_TRUE(placemark->has_name());
60d68cd
   ASSERT_TRUE(placemark->has_geometry());
60d68cd
   PointPtr point = AsPoint(placemark->get_geometry());
60d68cd
-  ASSERT_TRUE(point);
60d68cd
+  ASSERT_TRUE(point != 0);
60d68cd
   ASSERT_TRUE(point->has_coordinates());
60d68cd
 }
60d68cd
 
60d68cd
@@ -487,11 +487,11 @@ TEST_F(KmlHandlerTest, TestParserHandlesGrossDescriptions) {
60d68cd
   string data;
60d68cd
   ASSERT_TRUE(kmlbase::File::ReadFileToString(kInvalidDescriptions, &data));
60d68cd
   ElementPtr root = Parse(data, NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   KmlPtr kml = AsKml(root);
60d68cd
-  ASSERT_TRUE(kml);
60d68cd
+  ASSERT_TRUE(kml != 0);
60d68cd
   DocumentPtr document = AsDocument(kml->get_feature());
60d68cd
-  ASSERT_TRUE(document);
60d68cd
+  ASSERT_TRUE(document != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(3), document->get_feature_array_size());
60d68cd
 
60d68cd
   PlacemarkPtr placemark0 = AsPlacemark(document->get_feature_array_at(0));
60d68cd
@@ -514,7 +514,7 @@ TEST_F(KmlHandlerTest, TestParserHandlesBoolWhitespace) {
60d68cd
   string data;
60d68cd
   ASSERT_TRUE(kmlbase::File::ReadFileToString(kOutlineSpace, &data));
60d68cd
   ElementPtr root = Parse(data, NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   DocumentPtr document = AsDocument(AsKml(root)->get_feature());
60d68cd
   StylePtr style = AsStyle(document->get_styleselector_array_at(0));
60d68cd
   PolyStylePtr polystyle = style->get_polystyle();
60d68cd
@@ -534,7 +534,7 @@ TEST_F(KmlHandlerTest, TestMaxNestingOf100Folders) {
60d68cd
   string data;
60d68cd
   ASSERT_TRUE(kmlbase::File::ReadFileToString(k100Folders, &data));
60d68cd
   ElementPtr root = Parse(data, NULL);
60d68cd
-  ASSERT_TRUE(root);  // Parse succeeded.
60d68cd
+  ASSERT_TRUE(root != 0);  // Parse succeeded.
60d68cd
 }
60d68cd
 
60d68cd
 // 101 nested folders exceeds our default nesting limit of 100.
60d68cd
@@ -606,27 +606,27 @@ TEST_F(KmlHandlerTest, TestHandlesOldSchemaUsage) {
60d68cd
   ASSERT_TRUE(kmlbase::File::ReadFileToString(kOldSchemaKml, &data));
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(data, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const KmlPtr kml = AsKml(root);
60d68cd
-  ASSERT_TRUE(kml);
60d68cd
+  ASSERT_TRUE(kml != 0);
60d68cd
   ASSERT_TRUE(kml->has_feature());
60d68cd
   const DocumentPtr document = AsDocument(kml->get_feature());
60d68cd
-  ASSERT_TRUE(document);
60d68cd
+  ASSERT_TRUE(document != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), document->get_schema_array_size());
60d68cd
   const SchemaPtr schema = AsSchema(document->get_schema_array_at(0));
60d68cd
-  ASSERT_TRUE(schema);
60d68cd
+  ASSERT_TRUE(schema != 0);
60d68cd
   ASSERT_EQ("S_521_525_SSSSS_id", schema->get_id());
60d68cd
   ASSERT_EQ("S_521_525_SSSSS", schema->get_name());
60d68cd
   ASSERT_EQ(static_cast<size_t>(2), schema->get_simplefield_array_size());
60d68cd
   const SimpleFieldPtr simplefield0 =
60d68cd
     AsSimpleField(schema->get_simplefield_array_at(0));
60d68cd
-  ASSERT_TRUE(simplefield0);
60d68cd
+  ASSERT_TRUE(simplefield0 != 0);
60d68cd
   ASSERT_EQ("Foo", simplefield0->get_name());
60d68cd
   ASSERT_EQ("string", simplefield0->get_type());
60d68cd
   const SimpleFieldPtr simplefield1 =
60d68cd
     AsSimpleField(schema->get_simplefield_array_at(1));
60d68cd
-  ASSERT_TRUE(simplefield1);
60d68cd
+  ASSERT_TRUE(simplefield1 != 0);
60d68cd
   ASSERT_EQ("Bar", simplefield1->get_name());
60d68cd
   ASSERT_EQ("string", simplefield1->get_type());
60d68cd
   ASSERT_EQ(static_cast<size_t>(2), document->get_feature_array_size());
60d68cd
@@ -637,21 +637,21 @@ TEST_F(KmlHandlerTest, TestHandlesOldSchemaUsage) {
60d68cd
   ASSERT_TRUE(placemark0->has_extendeddata());
60d68cd
   const ExtendedDataPtr extendeddata0 =
60d68cd
     AsExtendedData(placemark0->get_extendeddata());
60d68cd
-  ASSERT_TRUE(extendeddata0);
60d68cd
+  ASSERT_TRUE(extendeddata0 != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), extendeddata0->get_schemadata_array_size());
60d68cd
   const SchemaDataPtr schemadata0 =
60d68cd
     AsSchemaData(extendeddata0->get_schemadata_array_at(0));
60d68cd
-  ASSERT_TRUE(schemadata0);
60d68cd
+  ASSERT_TRUE(schemadata0 != 0);
60d68cd
   ASSERT_EQ("S_521_525_SSSSS_id", schemadata0->get_schemaurl());
60d68cd
   ASSERT_EQ(static_cast<size_t>(2), schemadata0->get_simpledata_array_size());
60d68cd
   const SimpleDataPtr simpledata00 =
60d68cd
     AsSimpleData(schemadata0->get_simpledata_array_at(0));
60d68cd
-  ASSERT_TRUE(simpledata00);
60d68cd
+  ASSERT_TRUE(simpledata00 != 0);
60d68cd
   ASSERT_EQ("Foo", simpledata00->get_name());
60d68cd
   ASSERT_EQ("foo 1", simpledata00->get_text());
60d68cd
   const SimpleDataPtr simpledata01 =
60d68cd
     AsSimpleData(schemadata0->get_simpledata_array_at(1));
60d68cd
-  ASSERT_TRUE(simpledata01);
60d68cd
+  ASSERT_TRUE(simpledata01 != 0);
60d68cd
   ASSERT_EQ("Bar", simpledata01->get_name());
60d68cd
   ASSERT_EQ("bar 1", simpledata01->get_text());
60d68cd
 
60d68cd
@@ -661,21 +661,21 @@ TEST_F(KmlHandlerTest, TestHandlesOldSchemaUsage) {
60d68cd
   ASSERT_TRUE(placemark1->has_extendeddata());
60d68cd
   const ExtendedDataPtr extendeddata1 =
60d68cd
     AsExtendedData(placemark1->get_extendeddata());
60d68cd
-  ASSERT_TRUE(extendeddata1);
60d68cd
+  ASSERT_TRUE(extendeddata1 != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), extendeddata1->get_schemadata_array_size());
60d68cd
   const SchemaDataPtr schemadata1 =
60d68cd
     AsSchemaData(extendeddata1->get_schemadata_array_at(0));
60d68cd
-  ASSERT_TRUE(schemadata1);
60d68cd
+  ASSERT_TRUE(schemadata1 != 0);
60d68cd
   ASSERT_EQ("S_521_525_SSSSS_id", schemadata1->get_schemaurl());
60d68cd
   ASSERT_EQ(static_cast<size_t>(2), schemadata1->get_simpledata_array_size());
60d68cd
   const SimpleDataPtr simpledata10 =
60d68cd
     AsSimpleData(schemadata1->get_simpledata_array_at(0));
60d68cd
-  ASSERT_TRUE(simpledata10);
60d68cd
+  ASSERT_TRUE(simpledata10 != 0);
60d68cd
   ASSERT_EQ("Foo", simpledata10->get_name());
60d68cd
   ASSERT_EQ("foo 2", simpledata10->get_text());
60d68cd
   const SimpleDataPtr simpledata11 =
60d68cd
     AsSimpleData(schemadata1->get_simpledata_array_at(1));
60d68cd
-  ASSERT_TRUE(simpledata11);
60d68cd
+  ASSERT_TRUE(simpledata11 != 0);
60d68cd
   ASSERT_EQ("Bar", simpledata11->get_name());
60d68cd
   ASSERT_EQ("bar 2", simpledata11->get_text());
60d68cd
 }
60d68cd
@@ -701,7 +701,7 @@ TEST_F(KmlHandlerTest, TestOldSchemaParserObserver) {
60d68cd
   parser.AddObserver(&simple_new_element_observer);
60d68cd
   string errors;
60d68cd
   ElementPtr root = parser.Parse(kOldSchemaKml, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   // NewElement() is called only 4 times; The logic that handles the old
60d68cd
   // <Schema> knows to look for <Foo> as a child, and the handing there is
60d68cd
@@ -738,7 +738,7 @@ TEST_F(KmlHandlerTest, TestOldSchemaHandling) {
60d68cd
   kml_handler_->EndElement(kOldStyleSchemaChild);
60d68cd
   kml_handler_->EndElement(kOldStyleSchemaName);
60d68cd
   ElementPtr root = kml_handler_->PopRoot();
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_EQ(Type_Document, root->Type());
60d68cd
   // A Placemark was created from OldStyleSchemaName.
60d68cd
   ASSERT_EQ(Type_Placemark, AsDocument(root)->get_feature_array_at(0)->Type());
60d68cd
diff --git a/tests/kml/dom/link_test.cc b/tests/kml/dom/link_test.cc
60d68cd
index 89c45ae..c41fc47 100644
60d68cd
--- a/tests/kml/dom/link_test.cc
60d68cd
+++ b/tests/kml/dom/link_test.cc
60d68cd
@@ -155,10 +155,10 @@ TEST_F(LinkTest, TestParse) {
60d68cd
   const string kLink = "<Link>" + kHref + "</Link>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kLink, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const LinkPtr link = AsLink(root);
60d68cd
-  ASSERT_TRUE(link);
60d68cd
+  ASSERT_TRUE(link != 0);
60d68cd
   ASSERT_TRUE(link->has_href());
60d68cd
   ASSERT_EQ(kContent, link->get_href());
60d68cd
 }
60d68cd
@@ -170,10 +170,10 @@ TEST_F(LinkTest, TestAcceptCdataInHref) {
60d68cd
   const string kLink = "<Link>" + kHref + "</Link>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kLink, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const LinkPtr link = AsLink(root);
60d68cd
-  ASSERT_TRUE(link);
60d68cd
+  ASSERT_TRUE(link != 0);
60d68cd
   ASSERT_TRUE(link->has_href());
60d68cd
   ASSERT_TRUE(kContent == link->get_href());
60d68cd
 }
60d68cd
@@ -522,7 +522,7 @@ TEST_F(IconStyleIconTest, TestParseSerializeUnknown) {
60d68cd
       "<refreshMode>onExpire</refreshMode>"
60d68cd
       "</Icon>");
60d68cd
   ElementPtr element(Parse(kIcon, NULL));
60d68cd
-  ASSERT_TRUE(element);
60d68cd
+  ASSERT_TRUE(element != 0);
60d68cd
   ASSERT_EQ(kIcon, SerializeRaw(element));
60d68cd
 }
60d68cd
 
60d68cd
diff --git a/tests/kml/dom/networklink_test.cc b/tests/kml/dom/networklink_test.cc
60d68cd
index b2047a4..0a33e0d 100644
60d68cd
--- a/tests/kml/dom/networklink_test.cc
60d68cd
+++ b/tests/kml/dom/networklink_test.cc
60d68cd
@@ -104,7 +104,7 @@ TEST_F(NetworkLinkTest, TestParseUrl) {
60d68cd
   ElementPtr root = Parse(kNetworkLinkUrl + kHref + kUrlNetworkLink, &errors);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const NetworkLinkPtr networklink = AsNetworkLink(root);
60d68cd
-  ASSERT_TRUE(networklink);
60d68cd
+  ASSERT_TRUE(networklink != 0);
60d68cd
   // Verify that the Url was set as the Link.
60d68cd
   ASSERT_TRUE(networklink->has_link());
60d68cd
   ASSERT_EQ(Type_Url, networklink->get_link()->Type());
60d68cd
diff --git a/tests/kml/dom/object_test.cc b/tests/kml/dom/object_test.cc
60d68cd
index 3247a81..33e143e 100644
60d68cd
--- a/tests/kml/dom/object_test.cc
60d68cd
+++ b/tests/kml/dom/object_test.cc
60d68cd
@@ -91,10 +91,10 @@ TEST_F(ObjectTest, TestParse) {
60d68cd
       "<Placemark id=\"" + kId + "\" targetId=\"" + kTargetId + "\" />");
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kKml, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const PlacemarkPtr placemark = AsPlacemark(root);
60d68cd
-  ASSERT_TRUE(placemark);
60d68cd
+  ASSERT_TRUE(placemark != 0);
60d68cd
   ASSERT_TRUE(placemark->has_id());
60d68cd
   ASSERT_TRUE(placemark->has_targetid());
60d68cd
   ASSERT_EQ(kId, placemark->get_id());
60d68cd
diff --git a/tests/kml/dom/overlay_test.cc b/tests/kml/dom/overlay_test.cc
60d68cd
index d619853..31c770d 100644
60d68cd
--- a/tests/kml/dom/overlay_test.cc
60d68cd
+++ b/tests/kml/dom/overlay_test.cc
60d68cd
@@ -364,10 +364,10 @@ TEST_F(OverlayXYTest, TestParse) {
60d68cd
   ElementPtr root = Parse(
60d68cd
     "<overlayXY x=\"0.5\" y=\"123\" xunits=\"fraction\" yunits=\"pixels\"/>",
60d68cd
     &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const OverlayXYPtr overlayxy = AsOverlayXY(root);
60d68cd
-  ASSERT_TRUE(overlayxy);
60d68cd
+  ASSERT_TRUE(overlayxy != 0);
60d68cd
   ASSERT_EQ(0.5, overlayxy->get_x());
60d68cd
   ASSERT_EQ(123, overlayxy->get_y());
60d68cd
   ASSERT_EQ(static_cast<int>(UNITS_FRACTION), overlayxy->get_xunits());
60d68cd
@@ -406,10 +406,10 @@ TEST_F(ScreenXYTest, TestParse) {
60d68cd
     "
60d68cd
       "yunits=\"insetPixels\"/>",
60d68cd
     &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const ScreenXYPtr screenxy = AsScreenXY(root);
60d68cd
-  ASSERT_TRUE(screenxy);
60d68cd
+  ASSERT_TRUE(screenxy != 0);
60d68cd
   ASSERT_EQ(0.5, screenxy->get_x());
60d68cd
   ASSERT_EQ(123., screenxy->get_y());
60d68cd
   ASSERT_EQ(static_cast<int>(UNITS_FRACTION),
60d68cd
@@ -450,10 +450,10 @@ TEST_F(RotationXYTest, TestParse) {
60d68cd
   ElementPtr root = Parse(
60d68cd
     "<rotationXY x=\"512\" y=\"0.7\" xunits=\"pixels\" yunits=\"fraction\"/>",
60d68cd
     &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const RotationXYPtr rotationxy = AsRotationXY(root);
60d68cd
-  ASSERT_TRUE(rotationxy);
60d68cd
+  ASSERT_TRUE(rotationxy != 0);
60d68cd
   ASSERT_EQ(512., rotationxy->get_x());
60d68cd
   ASSERT_EQ(0.7, rotationxy->get_y());
60d68cd
   ASSERT_EQ(static_cast<int>(UNITS_PIXELS),
60d68cd
@@ -494,10 +494,10 @@ TEST_F(SizeTest, TestParse) {
60d68cd
   ElementPtr root = Parse(
60d68cd
     "<size x=\"512\" y=\"0.7\" xunits=\"pixels\" yunits=\"fraction\"/>",
60d68cd
     &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const SizePtr size = AsSize(root);
60d68cd
-  ASSERT_TRUE(size);
60d68cd
+  ASSERT_TRUE(size != 0);
60d68cd
   ASSERT_EQ(512., size->get_x());
60d68cd
   ASSERT_EQ(0.7, size->get_y());
60d68cd
   ASSERT_EQ(static_cast<int>(UNITS_PIXELS), size->get_xunits());
60d68cd
diff --git a/tests/kml/dom/parser_test.cc b/tests/kml/dom/parser_test.cc
60d68cd
index ae6c7b0..b2cd586 100644
60d68cd
--- a/tests/kml/dom/parser_test.cc
60d68cd
+++ b/tests/kml/dom/parser_test.cc
60d68cd
@@ -49,18 +49,18 @@ TEST(ParserTest, TestValidKml) {
60d68cd
                           &errors);
60d68cd
   // KML is valid so there are no errors and the root is <kml>.
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
 
60d68cd
   const KmlPtr kml = AsKml(root);
60d68cd
-  ASSERT_TRUE(kml);
60d68cd
+  ASSERT_TRUE(kml != 0);
60d68cd
 
60d68cd
   errors.clear();
60d68cd
   // Assigning to root releases storage allocated in Parse above.
60d68cd
   root = Parse(" <kml/>", &errors);  // Note leading space.
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
 
60d68cd
-  ASSERT_TRUE(AsKml(root));
60d68cd
+  ASSERT_TRUE(AsKml(root) != 0);
60d68cd
 
60d68cd
   // ElementPtr root going out of scope releases storage allocated in 2nd
60d68cd
   // Parse.
60d68cd
@@ -148,7 +148,7 @@ TEST(ParserTest, TestKmlWithUnknownEmptyFields) {
60d68cd
   const string kKml(
60d68cd
       string("<kml>") + kUnknownXml + "</kml>");
60d68cd
   ElementPtr root = Parse(kKml, NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), root->get_unknown_elements_array_size());
60d68cd
   ASSERT_EQ(kUnknownXml, root->get_unknown_elements_array_at(0));
60d68cd
 }
60d68cd
@@ -171,7 +171,7 @@ TEST(ParserTest, TestBasicParseAtom) {
60d68cd
                               &errors);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   ASSERT_TRUE(root.get());
60d68cd
-  ASSERT_TRUE(AsAtomFeed(root));
60d68cd
+  ASSERT_TRUE(AsAtomFeed(root) != 0);
60d68cd
   ASSERT_EQ(kmlbase::XMLNS_ATOM, root->get_xmlns());
60d68cd
 }
60d68cd
 
60d68cd
diff --git a/tests/kml/dom/placemark_test.cc b/tests/kml/dom/placemark_test.cc
60d68cd
index 42e2f5b..b7b6ec2 100644
60d68cd
--- a/tests/kml/dom/placemark_test.cc
60d68cd
+++ b/tests/kml/dom/placemark_test.cc
60d68cd
@@ -100,10 +100,10 @@ TEST_F(PlacemarkTest, TestParse) {
60d68cd
     "</Placemark>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kPlacemark, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const PlacemarkPtr placemark = AsPlacemark(root);
60d68cd
-  ASSERT_TRUE(placemark);
60d68cd
+  ASSERT_TRUE(placemark != 0);
60d68cd
   ASSERT_FALSE(placemark->has_id());
60d68cd
   ASSERT_FALSE(placemark->has_targetid());
60d68cd
   ASSERT_TRUE(placemark->has_name());
60d68cd
diff --git a/tests/kml/dom/region_test.cc b/tests/kml/dom/region_test.cc
60d68cd
index e58c99e..5901aae 100644
60d68cd
--- a/tests/kml/dom/region_test.cc
60d68cd
+++ b/tests/kml/dom/region_test.cc
60d68cd
@@ -127,10 +127,10 @@ TEST_F(LatLonAltBoxTest, TestParseAltitudeMode) {
60d68cd
     "</LatLonAltBox>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kLatLonAltBoxAbsolute, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const LatLonAltBoxPtr llab_absolute = AsLatLonAltBox(root);
60d68cd
-  ASSERT_TRUE(llab_absolute);
60d68cd
+  ASSERT_TRUE(llab_absolute != 0);
60d68cd
 
60d68cd
   // Verify the proper values in the object model:
60d68cd
   ASSERT_TRUE(llab_absolute->has_north());
60d68cd
@@ -154,10 +154,10 @@ TEST_F(LatLonAltBoxTest, TestParseAltitudeMode) {
60d68cd
     "<altitudeMode>clampToGround</altitudeMode>"
60d68cd
     "</LatLonAltBox>";
60d68cd
   root = Parse(kLatLonAltBoxClampToGround, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const LatLonAltBoxPtr llab_clamptoground = AsLatLonAltBox(root);
60d68cd
-  ASSERT_TRUE(llab_clamptoground);
60d68cd
+  ASSERT_TRUE(llab_clamptoground != 0);
60d68cd
   ASSERT_FALSE(llab_clamptoground->has_north());
60d68cd
   ASSERT_FALSE(llab_clamptoground->has_south());
60d68cd
   ASSERT_FALSE(llab_clamptoground->has_east());
60d68cd
@@ -174,10 +174,10 @@ TEST_F(LatLonAltBoxTest, TestParseAltitudeMode) {
60d68cd
     "<altitudeMode>relativeToGround</altitudeMode>"
60d68cd
     "</LatLonAltBox>";
60d68cd
   root = Parse(kLatLonAltBoxRelativeToGround, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const LatLonAltBoxPtr llab_relativetoground = AsLatLonAltBox(root);
60d68cd
-  ASSERT_TRUE(llab_relativetoground);
60d68cd
+  ASSERT_TRUE(llab_relativetoground != 0);
60d68cd
   ASSERT_TRUE(llab_relativetoground->has_altitudemode());
60d68cd
   ASSERT_FALSE(llab_relativetoground->has_gx_altitudemode());
60d68cd
   ASSERT_EQ(static_cast<int>(ALTITUDEMODE_RELATIVETOGROUND),
60d68cd
@@ -188,10 +188,10 @@ TEST_F(LatLonAltBoxTest, TestParseAltitudeMode) {
60d68cd
     "<gx:altitudeMode>relativeToSeaFloor</gx:altitudeMode>"
60d68cd
     "</LatLonAltBox>";
60d68cd
   root = Parse(kLatLonAltBoxRelativeToSeaFloor, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const LatLonAltBoxPtr llab_relativetoseafloor = AsLatLonAltBox(root);
60d68cd
-  ASSERT_TRUE(llab_relativetoseafloor);
60d68cd
+  ASSERT_TRUE(llab_relativetoseafloor != 0);
60d68cd
   ASSERT_FALSE(llab_relativetoseafloor->has_north());
60d68cd
   ASSERT_FALSE(llab_relativetoseafloor->has_south());
60d68cd
   ASSERT_FALSE(llab_relativetoseafloor->has_east());
60d68cd
@@ -313,10 +313,10 @@ TEST_F(RegionTest, TestParse) {
60d68cd
     "</Region>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kRegion, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const RegionPtr region = AsRegion(root);
60d68cd
-  ASSERT_TRUE(region);
60d68cd
+  ASSERT_TRUE(region != 0);
60d68cd
   ASSERT_EQ(string("region123"), region->get_id());
60d68cd
   ASSERT_TRUE(region->has_latlonaltbox());
60d68cd
   ASSERT_DOUBLE_EQ(101.101, region->get_latlonaltbox()->get_minaltitude());
60d68cd
diff --git a/tests/kml/dom/serializer_test.cc b/tests/kml/dom/serializer_test.cc
60d68cd
index 133af21..08be450 100644
60d68cd
--- a/tests/kml/dom/serializer_test.cc
60d68cd
+++ b/tests/kml/dom/serializer_test.cc
60d68cd
@@ -144,7 +144,7 @@ class ColorSerializer : public Serializer {
60d68cd
 
60d68cd
 // This exists because Serialize is public only on Element.
60d68cd
 static void CallSerializer(const ElementPtr& element, Serializer* serializer) {
60d68cd
-  ASSERT_TRUE(element);  // This is basically an internal check.
60d68cd
+  ASSERT_TRUE(element != 0);  // This is basically an internal check.
60d68cd
   ASSERT_TRUE(serializer);  // This is basically an internal check.
60d68cd
   element->Serialize(*serializer);
60d68cd
 }
60d68cd
diff --git a/tests/kml/dom/snippet_test.cc b/tests/kml/dom/snippet_test.cc
60d68cd
index 62f1d85..fb0a376 100644
60d68cd
--- a/tests/kml/dom/snippet_test.cc
60d68cd
+++ b/tests/kml/dom/snippet_test.cc
60d68cd
@@ -92,9 +92,9 @@ TEST_F(SnippetTest, TestBasicParse) {
60d68cd
   const string kPlacemark = "<Placemark>" + kSnippet + "</Placemark>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kPlacemark, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   const PlacemarkPtr placemark = AsPlacemark(root);
60d68cd
-  ASSERT_TRUE(placemark);
60d68cd
+  ASSERT_TRUE(placemark != 0);
60d68cd
   ASSERT_TRUE(placemark->has_snippet());
60d68cd
   ASSERT_FALSE(placemark->get_snippet()->has_maxlines());
60d68cd
   ASSERT_EQ(2, placemark->get_snippet()->get_maxlines());  // The default.
60d68cd
@@ -115,12 +115,12 @@ TEST_F(SnippetTest, TestParseMaxLines) {
60d68cd
   const string kFolder = "<Folder>" + kSnippet + "</Folder>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kFolder, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const FolderPtr folder = AsFolder(root);
60d68cd
   ASSERT_TRUE(folder->has_snippet());
60d68cd
   const SnippetPtr snippet = folder->get_snippet();
60d68cd
-  ASSERT_TRUE(snippet);
60d68cd
+  ASSERT_TRUE(snippet != 0);
60d68cd
   ASSERT_TRUE(snippet->has_maxlines());
60d68cd
   ASSERT_EQ(5, snippet->get_maxlines());
60d68cd
 }
60d68cd
@@ -195,7 +195,7 @@ TEST_F(LinkSnippetTest, TestBasicParse) {
60d68cd
     kLinkSnippet + "</NetworkLinkControl>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kNetworkLinkControl, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   const NetworkLinkControlPtr networklinkcontrol = AsNetworkLinkControl(root);
60d68cd
   ASSERT_TRUE(networklinkcontrol->has_linksnippet());
60d68cd
   const LinkSnippetPtr linksnippet = networklinkcontrol->get_linksnippet();
60d68cd
@@ -217,12 +217,12 @@ TEST_F(LinkSnippetTest, TestParseMaxLines) {
60d68cd
     kLinkSnippet + "</NetworkLinkControl>";
60d68cd
   string errors;
60d68cd
   ElementPtr root = Parse(kNetworkLinkControl, &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const NetworkLinkControlPtr networklinkcontrol = AsNetworkLinkControl(root);
60d68cd
   ASSERT_TRUE(networklinkcontrol->has_linksnippet());
60d68cd
   const LinkSnippetPtr linksnippet = networklinkcontrol->get_linksnippet();
60d68cd
-  ASSERT_TRUE(linksnippet);
60d68cd
+  ASSERT_TRUE(linksnippet != 0);
60d68cd
   ASSERT_TRUE(linksnippet->has_maxlines());
60d68cd
   ASSERT_EQ(7, linksnippet->get_maxlines());
60d68cd
 }
60d68cd
diff --git a/tests/kml/dom/unknown_test.cc b/tests/kml/dom/unknown_test.cc
60d68cd
index 3c42f52..20c9e8d 100644
60d68cd
--- a/tests/kml/dom/unknown_test.cc
60d68cd
+++ b/tests/kml/dom/unknown_test.cc
60d68cd
@@ -59,7 +59,7 @@ TEST(UnknownTest, TestUnknownElement) {
60d68cd
     "</Placemark>",
60d68cd
     &errors);
60d68cd
   // This is XML valid and hence parses fine.
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   // The root element is a Placemark.
60d68cd
   const PlacemarkPtr placemark = AsPlacemark(root);
60d68cd
@@ -90,7 +90,7 @@ TEST(UnknownTest, TestMisplaced) {
60d68cd
       "<name>placemark</name>"
60d68cd
     "</Placemark>",
60d68cd
     &errors);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   const PlacemarkPtr placemark = AsPlacemark(root);
60d68cd
   ASSERT_EQ(string("placemark"), placemark->get_name());
60d68cd
@@ -114,7 +114,7 @@ TEST(UnknownTest, TestUnknownAttribute) {
60d68cd
     "</GroundOverlay>",
60d68cd
     &errors);
60d68cd
   // This is XML valid so it parses fine.
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   ASSERT_TRUE(errors.empty());
60d68cd
   // The root is a GroundOverlay.
60d68cd
   const GroundOverlayPtr groundoverlay = AsGroundOverlay(root);
60d68cd
@@ -155,7 +155,7 @@ TEST(UnknownTest, TestSaveUnknown) {
60d68cd
                          kUnknownSimple + "<kml/>" +
60d68cd
                          kUnknownComplex + "<kml/>" +
60d68cd
                          "</" + kTagName + ">");
60d68cd
-      ASSERT_TRUE(element) << kTagName;
60d68cd
+      ASSERT_TRUE(element != 0) << kTagName;
60d68cd
       ASSERT_EQ(static_cast<size_t>(2),
60d68cd
                 element->get_unknown_elements_array_size());
60d68cd
       ASSERT_EQ(kUnknownSimple, element->get_unknown_elements_array_at(0));
60d68cd
diff --git a/tests/kml/dom/xal_test.cc b/tests/kml/dom/xal_test.cc
60d68cd
index c825603..09b3f48 100644
60d68cd
--- a/tests/kml/dom/xal_test.cc
60d68cd
+++ b/tests/kml/dom/xal_test.cc
60d68cd
@@ -93,42 +93,42 @@ TEST_F(XalAddressDetailsTest, TestParseDom) {
60d68cd
       File::JoinPaths(DATADIR, File::JoinPaths("xal", "gaddr.kml")));
60d68cd
   ASSERT_TRUE(File::ReadFileToString(kXalGaddr, &gaddr_content));
60d68cd
   ElementPtr root = kmldom::Parse(gaddr_content, NULL);
60d68cd
-  ASSERT_TRUE(root);
60d68cd
+  ASSERT_TRUE(root != 0);
60d68cd
   KmlPtr kml = AsKml(root);
60d68cd
-  ASSERT_TRUE(kml);
60d68cd
+  ASSERT_TRUE(kml != 0);
60d68cd
   ASSERT_TRUE(kml->has_feature());
60d68cd
   DocumentPtr document = AsDocument(kml->get_feature());
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), document->get_feature_array_size());
60d68cd
   PlacemarkPtr placemark = AsPlacemark(document->get_feature_array_at(0));
60d68cd
-  ASSERT_TRUE(placemark);
60d68cd
+  ASSERT_TRUE(placemark != 0);
60d68cd
   XalAddressDetailsPtr xaladdressdetails =
60d68cd
     AsXalAddressDetails(placemark->get_xaladdressdetails());
60d68cd
-  ASSERT_TRUE(xaladdressdetails);
60d68cd
+  ASSERT_TRUE(xaladdressdetails != 0);
60d68cd
   ASSERT_TRUE(xaladdressdetails->has_country());
60d68cd
   XalCountryPtr country = xaladdressdetails->get_country();
60d68cd
   ASSERT_TRUE(country->has_countrynamecode());
60d68cd
   ASSERT_EQ(string("US"), country->get_countrynamecode());
60d68cd
   XalAdministrativeAreaPtr administrativearea =
60d68cd
       country->get_administrativearea();
60d68cd
-  ASSERT_TRUE(administrativearea);
60d68cd
+  ASSERT_TRUE(administrativearea != 0);
60d68cd
   ASSERT_EQ(string("CA"),
60d68cd
       administrativearea->get_administrativeareaname());
60d68cd
   XalSubAdministrativeAreaPtr subadministrativearea =
60d68cd
       administrativearea->get_subadministrativearea();
60d68cd
-  ASSERT_TRUE(subadministrativearea);
60d68cd
+  ASSERT_TRUE(subadministrativearea != 0);
60d68cd
   ASSERT_EQ(string("Santa Clara"),
60d68cd
             subadministrativearea->get_subadministrativeareaname());
60d68cd
   XalLocalityPtr locality = subadministrativearea->get_locality();
60d68cd
-  ASSERT_TRUE(locality);
60d68cd
+  ASSERT_TRUE(locality != 0);
60d68cd
   ASSERT_EQ(string("Mountain View"), locality->get_localityname());
60d68cd
   XalThoroughfarePtr thoroughfare = locality->get_thoroughfare();
60d68cd
-  ASSERT_TRUE(thoroughfare);
60d68cd
+  ASSERT_TRUE(thoroughfare != 0);
60d68cd
   ASSERT_EQ(string("Amphitheatre Pkwy"),
60d68cd
             thoroughfare->get_thoroughfarename());
60d68cd
   ASSERT_EQ(string("1600"),
60d68cd
             thoroughfare->get_thoroughfarenumber());
60d68cd
   XalPostalCodePtr postalcode = locality->get_postalcode();
60d68cd
-  ASSERT_TRUE(postalcode);
60d68cd
+  ASSERT_TRUE(postalcode != 0);
60d68cd
   ASSERT_EQ(string("94043"), postalcode->get_postalcodenumber());
60d68cd
 }
60d68cd
 
60d68cd
diff --git a/tests/kml/dom/xml_serializer_test.cc b/tests/kml/dom/xml_serializer_test.cc
60d68cd
index 5aa4e1c..c3d6946 100644
60d68cd
--- a/tests/kml/dom/xml_serializer_test.cc
60d68cd
+++ b/tests/kml/dom/xml_serializer_test.cc
60d68cd
@@ -264,7 +264,7 @@ TEST_F(XmlSerializerTest, SerializeRawCoordinates) {
60d68cd
       "    <coordinates>1.2,3.4,5.6 9.8,7.6</coordinates>"
60d68cd
       "  </LineString>"
60d68cd
       "</Placemark>"));
60d68cd
-  ASSERT_TRUE(placemark_);
60d68cd
+  ASSERT_TRUE(placemark_ != 0);
60d68cd
   const string want(
60d68cd
       "<Placemark>"
60d68cd
       "<LineString>"
60d68cd
diff --git a/tests/kml/engine/clone_test.cc b/tests/kml/engine/clone_test.cc
60d68cd
index 18b105a..fcd4cca 100644
60d68cd
--- a/tests/kml/engine/clone_test.cc
60d68cd
+++ b/tests/kml/engine/clone_test.cc
60d68cd
@@ -174,7 +174,7 @@ TEST_F(CloneTest, TestClonePointCoordinates) {
60d68cd
 
60d68cd
   // Verify that a new <coordinates> was created and has the expected content.
60d68cd
   CoordinatesPtr coordinates_clone = AsCoordinates(clone);
60d68cd
-  ASSERT_TRUE(coordinates_clone);
60d68cd
+  ASSERT_TRUE(coordinates_clone != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1),
60d68cd
             coordinates_clone->get_coordinates_array_size());
60d68cd
   Vec3 vec3 = coordinates_clone->get_coordinates_array_at(0);
60d68cd
@@ -199,7 +199,7 @@ TEST_F(CloneTest, TestCloneLineCoordinates) {
60d68cd
 
60d68cd
   // Verify all the points came over okay.
60d68cd
   CoordinatesPtr cloned_coordinates = AsCoordinates(element);
60d68cd
-  ASSERT_TRUE(cloned_coordinates);
60d68cd
+  ASSERT_TRUE(cloned_coordinates != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(kNumPoints),
60d68cd
                        cloned_coordinates->get_coordinates_array_size());
60d68cd
   for (i = 0; i < kNumPoints; ++i) {
60d68cd
@@ -215,7 +215,7 @@ TEST_F(CloneTest, TestCloneSnippet) {
60d68cd
   // Clone an empty/default Snippet.
60d68cd
   ElementPtr element = Clone(snippet_);
60d68cd
   SnippetPtr cloned_snippet = AsSnippet(element);
60d68cd
-  ASSERT_TRUE(cloned_snippet);
60d68cd
+  ASSERT_TRUE(cloned_snippet != 0);
60d68cd
   ASSERT_EQ(snippet_->get_maxlines(),
60d68cd
                        cloned_snippet->get_maxlines());
60d68cd
   ASSERT_EQ(snippet_->get_text(), cloned_snippet->get_text());
60d68cd
@@ -237,7 +237,7 @@ TEST_F(CloneTest, TestCloneIconStyle) {
60d68cd
   ASSERT_EQ(kmldom::Type_IconStyleIcon, iconstyle->get_icon()->Type());
60d68cd
 
60d68cd
   IconStylePtr clone = AsIconStyle(Clone(iconstyle));
60d68cd
-  ASSERT_TRUE(clone);
60d68cd
+  ASSERT_TRUE(clone != 0);
60d68cd
   ASSERT_EQ(kmldom::Type_IconStyle, clone->Type());
60d68cd
   ASSERT_TRUE(clone->has_icon());
60d68cd
   ASSERT_TRUE(clone->get_icon()->has_href());
60d68cd
@@ -248,11 +248,11 @@ TEST_F(CloneTest, TestCloneIconStyle) {
60d68cd
 TEST_F(CloneTest, TestCloneWithMisplacedChild) {
60d68cd
   kmldom::IconPtr icon =
60d68cd
     kmldom::AsIcon(kmldom::Parse("<Icon><x>64</x></Icon>", NULL));
60d68cd
-  ASSERT_TRUE(icon);
60d68cd
+  ASSERT_TRUE(icon != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), icon->get_misplaced_elements_array_size());
60d68cd
   ASSERT_EQ(static_cast<size_t>(0), icon->get_unknown_elements_array_size());
60d68cd
   kmldom::IconPtr clone = kmldom::AsIcon(Clone(icon));
60d68cd
-  ASSERT_TRUE(clone);
60d68cd
+  ASSERT_TRUE(clone != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), clone->get_misplaced_elements_array_size());
60d68cd
   ASSERT_EQ(static_cast<size_t>(0), clone->get_unknown_elements_array_size());
60d68cd
   ASSERT_FALSE(kmldom::SerializePretty(clone).empty());
60d68cd
@@ -263,11 +263,11 @@ TEST_F(CloneTest, TestCloneWithFullyUnknownChild) {
60d68cd
   // manifested in cloning any element with a fully unknown child.
60d68cd
   kmldom::IconPtr icon =
60d68cd
       kmldom::AsIcon(kmldom::Parse("<Icon><w>64</w></Icon>", NULL));
60d68cd
-  ASSERT_TRUE(icon);
60d68cd
+  ASSERT_TRUE(icon != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(0), icon->get_misplaced_elements_array_size());
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), icon->get_unknown_elements_array_size());
60d68cd
   kmldom::IconPtr clone = kmldom::AsIcon(Clone(icon));
60d68cd
-  ASSERT_TRUE(clone);
60d68cd
+  ASSERT_TRUE(clone != 0);
60d68cd
   ASSERT_EQ(static_cast<size_t>(0), clone->get_misplaced_elements_array_size());
60d68cd
   ASSERT_EQ(static_cast<size_t>(1), clone->get_unknown_elements_array_size());
60d68cd
   ASSERT_FALSE(kmldom::SerializePretty(clone).empty());
60d68cd
diff --git a/tests/kml/engine/entity_mapper_test.cc b/tests/kml/engine/entity_mapper_test.cc
60d68cd
index 42a76c4..37a6ede 100644
60d68cd
--- a/tests/kml/engine/entity_mapper_test.cc
60d68cd
+++ b/tests/kml/engine/entity_mapper_test.cc
60d68cd
@@ -114,7 +114,7 @@ const static struct {
60d68cd