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