--- a/toolkit/components/url-classifier/tests/gtest/TestClassifier.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestClassifier.cpp
@@ -90,17 +90,17 @@ TestReadNoiseEntries(Classifier* classif
     // Test the noise entry should exist in the cached prefix array
     nsAutoCString partialHash;
     partialHash.Assign(reinterpret_cast<char*>(&noiseEntries[i]), PREFIX_SIZE);
     EXPECT_TRUE(aPrefixArray.Contains(partialHash));
   }
 
 }
 
-TEST(Classifier, ReadNoiseEntriesV4)
+TEST(UrlClassifier, ReadNoiseEntriesV4)
 {
   UniquePtr<Classifier> classifier(GetClassifier());
   _PrefixArray array = { GeneratePrefix(_Fragment("bravo.com/"), 5),
                          GeneratePrefix(_Fragment("browsing.com/"), 9),
                          GeneratePrefix(_Fragment("gound.com/"), 4),
                          GeneratePrefix(_Fragment("small.com/"), 4),
                          GeneratePrefix(_Fragment("gdfad.com/"), 4),
                          GeneratePrefix(_Fragment("afdfound.com/"), 4),
@@ -110,17 +110,17 @@ TEST(Classifier, ReadNoiseEntriesV4)
 
   nsresult rv;
   rv = SetupLookupCacheV4(classifier.get(), array, GTEST_TABLE_V4);
   ASSERT_TRUE(rv == NS_OK);
 
   TestReadNoiseEntries(classifier.get(), array, GTEST_TABLE_V4, _Fragment("gound.com/"));
 }
 
-TEST(Classifier, ReadNoiseEntriesV2)
+TEST(UrlClassifier, ReadNoiseEntriesV2)
 {
   UniquePtr<Classifier> classifier(GetClassifier());
   _PrefixArray array = { GeneratePrefix(_Fragment("helloworld.com/"), 4),
                          GeneratePrefix(_Fragment("firefox.com/"), 4),
                          GeneratePrefix(_Fragment("chrome.com/"), 4),
                          GeneratePrefix(_Fragment("safebrowsing.com/"), 4),
                          GeneratePrefix(_Fragment("opera.com/"), 4),
                          GeneratePrefix(_Fragment("torbrowser.com/"), 4),

--- a/toolkit/components/url-classifier/tests/gtest/TestFailUpdate.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestFailUpdate.cpp
@@ -28,17 +28,17 @@ void CheckFileExist(const char* table, c
 
     bool exists;
     file->Exists(&exists);
 
     ASSERT_EQ(expectExists, exists) << file->HumanReadablePath().get();
   }
 }
 
-TEST(FailUpdate, CheckTableReset)
+TEST(UrlClassifierFailUpdate, CheckTableReset)
 {
   const bool FULL_UPDATE = true;
   const bool PARTIAL_UPDATE = false;
 
   // Apply V2 update
   {
     auto update = new TableUpdateV2(NS_LITERAL_CSTRING(V2_TABLE));
     Unused << update->NewAddChunk(1);

--- a/toolkit/components/url-classifier/tests/gtest/TestFindFullHash.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestFindFullHash.cpp
@@ -35,17 +35,17 @@ Base64EncodedStringArray
 MakeBase64EncodedStringArray(nsCString (&aArray)[N])
 {
   return Base64EncodedStringArray(aArray, N);
 }
 
 } // end of unnamed namespace.
 
 
-TEST(FindFullHash, Request)
+TEST(UrlClassifierFindFullHash, Request)
 {
   nsCOMPtr<nsIUrlClassifierUtils> urlUtil =
     do_GetService("@mozilla.org/url-classifier/utils;1");
 
   const char* listNames[] = { "test-phish-proto", "test-unwanted-proto" };
 
   nsCString listStates[] = { nsCString("sta\x00te1", 7),
                              nsCString("sta\x00te2", 7) };
@@ -198,17 +198,17 @@ private:
 
   uint32_t& mCallbackCount;
 };
 
 NS_IMPL_ISUPPORTS(MyParseCallback, nsIUrlClassifierParseFindFullHashCallback)
 
 } // end of unnamed namespace.
 
-TEST(FindFullHash, ParseRequest)
+TEST(UrlClassifierFindFullHash, ParseRequest)
 {
   // Build response.
   FindFullHashesResponse r;
 
   // Init response-wise durations.
   auto minWaitDuration = r.mutable_minimum_wait_duration();
   PopulateDuration(*minWaitDuration, EXPECTED_MIN_WAIT_DURATION);
   auto negCacheDuration = r.mutable_negative_cache_duration();

--- a/toolkit/components/url-classifier/tests/gtest/TestLookupCacheV4.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestLookupCacheV4.cpp
@@ -31,22 +31,22 @@ TestHasPrefix(const _Fragment& aFragment
     EXPECT_EQ(matchLength == COMPLETE_SIZE, aExpectedComplete);
     EXPECT_EQ(confirmed, false);
 
     cache->ClearAll();
   });
 
 }
 
-TEST(LookupCacheV4, HasComplete)
+TEST(UrlClassifierLookupCacheV4, HasComplete)
 {
   TestHasPrefix(_Fragment("bravo.com/"), true, true);
 }
 
-TEST(LookupCacheV4, HasPrefix)
+TEST(UrlClassifierLookupCacheV4, HasPrefix)
 {
   TestHasPrefix(_Fragment("browsing.com/"), true, false);
 }
 
-TEST(LookupCacheV4, Nomatch)
+TEST(UrlClassifierLookupCacheV4, Nomatch)
 {
   TestHasPrefix(_Fragment("nomatch.com/"), false, false);
 }

--- a/toolkit/components/url-classifier/tests/gtest/TestPerProviderDirectory.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestPerProviderDirectory.cpp
@@ -58,34 +58,34 @@ void VerifyPrivateStorePath(const char* 
          aTableName,
          aProvider,
          NS_ConvertUTF16toUTF8(rootStorePath).get(),
          NS_ConvertUTF16toUTF8(privateStorePath).get());
 
   ASSERT_TRUE(privateStorePath == expectedPrivateStorePath);
 }
 
-TEST(PerProviderDirectory, LookupCache)
+TEST(UrlClassifierPerProviderDirectory, LookupCache)
 {
   RunTestInNewThread([] () -> void {
     nsCOMPtr<nsIFile> rootDir;
     NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(rootDir));
 
     // For V2 tables (NOT ending with '-proto'), root directory should be
     // used as the private store.
     VerifyPrivateStorePath<LookupCacheV2>("goog-phish-shavar", "google", rootDir, false);
 
     // For V4 tables, if provider is found, use per-provider subdirectory;
     // If not found, use root directory.
     VerifyPrivateStorePath<LookupCacheV4>("goog-noprovider-proto", "", rootDir, false);
     VerifyPrivateStorePath<LookupCacheV4>("goog-phish-proto", "google4", rootDir, true);
   });
 }
 
-TEST(PerProviderDirectory, HashStore)
+TEST(UrlClassifierPerProviderDirectory, HashStore)
 {
   RunTestInNewThread([] () -> void {
     nsCOMPtr<nsIFile> rootDir;
     NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(rootDir));
 
     // For V2 tables (NOT ending with '-proto'), root directory should be
     // used as the private store.
     VerifyPrivateStorePath<HashStore>("goog-phish-shavar", "google", rootDir, false);

--- a/toolkit/components/url-classifier/tests/gtest/TestProtocolParser.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestProtocolParser.cpp
@@ -17,17 +17,17 @@ InitUpdateResponse(ListUpdateResponse* a
                    const nsACString& aChecksum,
                    bool isFullUpdate,
                    const nsTArray<uint32_t>& aFixedLengthPrefixes,
                    bool aDoPrefixEncoding);
 
 static void
 DumpBinary(const nsACString& aBinary);
 
-TEST(ProtocolParser, UpdateWait)
+TEST(UrlClassifierProtocolParser, UpdateWait)
 {
   // Top level response which contains a list of update response
   // for different lists.
   FetchThreatListUpdatesResponse response;
 
   auto r = response.mutable_list_update_responses()->Add();
   InitUpdateResponse(r, SOCIAL_ENGINEERING_PUBLIC,
                         nsCString("sta\x00te", 6),
@@ -48,17 +48,17 @@ TEST(ProtocolParser, UpdateWait)
 
   ProtocolParser* p = new ProtocolParserProtobuf();
   p->AppendStream(nsCString(s.c_str(), s.length()));
   p->End();
   ASSERT_EQ(p->UpdateWaitSec(), 9u);
   delete p;
 }
 
-TEST(ProtocolParser, SingleValueEncoding)
+TEST(UrlClassifierProtocolParser, SingleValueEncoding)
 {
   // Top level response which contains a list of update response
   // for different lists.
   FetchThreatListUpdatesResponse response;
 
   auto r = response.mutable_list_update_responses()->Add();
 
   const char* expectedPrefix = "\x00\x01\x02\x00";
@@ -151,9 +151,9 @@ InitUpdateResponse(ListUpdateResponse* a
 
 static void DumpBinary(const nsACString& aBinary)
 {
   nsCString s;
   for (size_t i = 0; i < aBinary.Length(); i++) {
     s.AppendPrintf("\\x%.2X", (uint8_t)aBinary[i]);
   }
   printf("%s\n", s.get());
-}
\ No newline at end of file
+}

--- a/toolkit/components/url-classifier/tests/gtest/TestRiceDeltaDecoder.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestRiceDeltaDecoder.cpp
@@ -11,26 +11,26 @@ using namespace mozilla::safebrowsing;
 struct TestingData {
   std::vector<uint32_t> mExpectedDecoded;
   std::vector<uint8_t> mEncoded;
   uint32_t mRiceParameter;
 };
 
 static bool runOneTest(TestingData& aData);
 
-TEST(RiceDeltaDecoder, SingleEncodedValue) {
+TEST(UrlClassifierRiceDeltaDecoder, SingleEncodedValue) {
   TestingData td = { { 99 }, { 99 }, 0 };
 
   ASSERT_TRUE(runOneTest(td));
 }
 
 // In this batch of tests, the encoded data would be like
 // what we originally receive from the network. See comment
 // in |runOneTest| for more detail.
-TEST(RiceDeltaDecoder, Empty) {
+TEST(UrlClassifierRiceDeltaDecoder, Empty) {
 
   // The following structure and testing data is copied from Chromium source code:
   //
   // https://chromium.googlesource.com/chromium/src.git/+/950f9975599768b6a08c7146cb4befa161be87aa/components/safe_browsing_db/v4_rice_unittest.cc#75
   //
   // and will be translated to our own testing format.
 
   struct RiceDecodingTestInfo {

--- a/toolkit/components/url-classifier/tests/gtest/TestSafeBrowsingProtobuf.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestSafeBrowsingProtobuf.cpp
@@ -1,12 +1,12 @@
 #include "safebrowsing.pb.h"
 #include "gtest/gtest.h"
 
-TEST(SafeBrowsingProtobuf, Empty)
+TEST(UrlClassifierProtobuf, Empty)
 {
   using namespace mozilla::safebrowsing;
 
   const std::string CLIENT_ID = "firefox";
 
   // Construct a simple update request.
   FetchThreatListUpdatesRequest r;
   r.set_allocated_client(new ClientInfo());

--- a/toolkit/components/url-classifier/tests/gtest/TestSafebrowsingHash.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestSafebrowsingHash.cpp
@@ -1,12 +1,12 @@
 #include "Entries.h"
 #include "mozilla/EndianUtils.h"
 
-TEST(SafebrowsingHash, ToFromUint32)
+TEST(UrlClassifierHash, ToFromUint32)
 {
   using namespace mozilla::safebrowsing;
 
   // typedef SafebrowsingHash<PREFIX_SIZE, PrefixComparator> Prefix;
   // typedef nsTArray<Prefix> PrefixArray;
 
   const char PREFIX_RAW[4] = { 0x1, 0x2, 0x3, 0x4 };
   uint32_t PREFIX_UINT32;
@@ -15,17 +15,17 @@ TEST(SafebrowsingHash, ToFromUint32)
   Prefix p;
   p.Assign(nsCString(PREFIX_RAW, 4));
   ASSERT_EQ(p.ToUint32(), PREFIX_UINT32);
 
   p.FromUint32(PREFIX_UINT32);
   ASSERT_EQ(memcmp(PREFIX_RAW, p.buf, 4), 0);
 }
 
-TEST(SafebrowsingHash, Compare)
+TEST(UrlClassifierHash, Compare)
 {
   using namespace mozilla;
   using namespace mozilla::safebrowsing;
 
   Prefix p1, p2, p3;
 
   // The order of p1,p2,p3 is "p1 == p3 < p2"
 #if MOZ_LITTLE_ENDIAN
@@ -44,9 +44,9 @@ TEST(SafebrowsingHash, Compare)
   ASSERT_EQ(p1.Compare(p2), -1);
   ASSERT_EQ(p1.Compare(p1), 0);
   ASSERT_EQ(p2.Compare(p1), 1);
   ASSERT_EQ(p1.Compare(p3), 0);
 
   ASSERT_TRUE(p1 < p2);
   ASSERT_TRUE(p1 == p1);
   ASSERT_TRUE(p1 == p3);
-}
\ No newline at end of file
+}

--- a/toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestVariableLengthPrefixSet.cpp
@@ -172,17 +172,17 @@ static void SetupPrefixMap(const _Prefix
     }
 
     map.Put(size, str);
   }
 }
 
 
 // Test setting prefix set with only 4-bytes prefixes
-TEST(VariableLengthPrefixSet, FixedLengthSet)
+TEST(UrlClassifierVLPrefixSet, FixedLengthSet)
 {
   srand(time(nullptr));
 
   RefPtr<VariableLengthPrefixSet> pset = new VariableLengthPrefixSet;
   pset->Init(NS_LITERAL_CSTRING("test"));
 
   PrefixStringMap map;
   _PrefixArray array = { _Prefix("alph"), _Prefix("brav"), _Prefix("char"),
@@ -210,17 +210,17 @@ TEST(VariableLengthPrefixSet, FixedLengt
   DoExpectedLookup(pset, array);
 
   DoRandomLookup(pset, 1000, array);
 
   CheckContent(pset, map);
 }
 
 // Test setting prefix set with only 5~32 bytes prefixes
-TEST(VariableLengthPrefixSet, VariableLengthSet)
+TEST(UrlClassifierVLPrefixSet, VariableLengthSet)
 {
   RefPtr<VariableLengthPrefixSet> pset = new VariableLengthPrefixSet;
   pset->Init(NS_LITERAL_CSTRING("test"));
 
   PrefixStringMap map;
   _PrefixArray array = { _Prefix("bravo"), _Prefix("charlie"), _Prefix("delta"),
                          _Prefix("EchoEchoEchoEchoEcho"), _Prefix("foxtrot"),
                          _Prefix("GolfGolfGolfGolfGolfGolfGolfGolf"),
@@ -253,17 +253,17 @@ TEST(VariableLengthPrefixSet, VariableLe
 
   DoRandomLookup(pset, 1000, array);
 
   CheckContent(pset, map);
 
 }
 
 // Test setting prefix set with both 4-bytes prefixes and 5~32 bytes prefixes
-TEST(VariableLengthPrefixSet, MixedPrefixSet)
+TEST(UrlClassifierVLPrefixSet, MixedPrefixSet)
 {
   RefPtr<VariableLengthPrefixSet> pset = new VariableLengthPrefixSet;
   pset->Init(NS_LITERAL_CSTRING("test"));
 
   PrefixStringMap map;
   _PrefixArray array = { _Prefix("enus"), _Prefix("apollo"), _Prefix("mars"),
                          _Prefix("Hecatonchires cyclopes"),
                          _Prefix("vesta"), _Prefix("neptunus"), _Prefix("jupiter"),
@@ -295,17 +295,17 @@ TEST(VariableLengthPrefixSet, MixedPrefi
   DoExpectedLookup(pset, array);
 
   DoRandomLookup(pset, 1000, array);
 
   CheckContent(pset, map);
 }
 
 // Test resetting prefix set
-TEST(VariableLengthPrefixSet, ResetPrefix)
+TEST(UrlClassifierVLPrefixSet, ResetPrefix)
 {
   RefPtr<VariableLengthPrefixSet> pset = new VariableLengthPrefixSet;
   pset->Init(NS_LITERAL_CSTRING("test"));
 
   // First prefix set
   _PrefixArray array1 = { _Prefix("Iceland"), _Prefix("Peru"), _Prefix("Mexico"),
                           _Prefix("Australia"), _Prefix("Japan"), _Prefix("Egypt"),
                           _Prefix("America"), _Prefix("Finland"), _Prefix("Germany"),
@@ -341,17 +341,17 @@ TEST(VariableLengthPrefixSet, ResetPrefi
     UniquePtr<nsACString> fullhash(CreateFullHash(array1[i]));
 
     pset->Matches(*fullhash, &matchLength);
     ASSERT_TRUE(matchLength == 0);
   }
 }
 
 // Test only set one 4-bytes prefix and one full-length prefix
-TEST(VariableLengthPrefixSet, TinyPrefixSet)
+TEST(UrlClassifierVLPrefixSet, TinyPrefixSet)
 {
   RefPtr<VariableLengthPrefixSet> pset = new VariableLengthPrefixSet;
   pset->Init(NS_LITERAL_CSTRING("test"));
 
   PrefixStringMap map;
   _PrefixArray array = { _Prefix("AAAA"),
                          _Prefix("11112222333344445555666677778888"),
                        };
@@ -362,17 +362,17 @@ TEST(VariableLengthPrefixSet, TinyPrefix
   DoExpectedLookup(pset, array);
 
   DoRandomLookup(pset, 1000, array);
 
   CheckContent(pset, map);
 }
 
 // Test empty prefix set and IsEmpty function
-TEST(VariableLengthPrefixSet, EmptyPrefixSet)
+TEST(UrlClassifierVLPrefixSet, EmptyPrefixSet)
 {
   RefPtr<VariableLengthPrefixSet> pset = new VariableLengthPrefixSet;
   pset->Init(NS_LITERAL_CSTRING("test"));
 
   bool empty;
   pset->IsEmpty(&empty);
   ASSERT_TRUE(empty);
 
@@ -396,17 +396,17 @@ TEST(VariableLengthPrefixSet, EmptyPrefi
   SetupPrefixMap(array3, map);
   pset->SetPrefixes(map);
 
   pset->IsEmpty(&empty);
   ASSERT_TRUE(!empty);
 }
 
 // Test prefix size should only between 4~32 bytes
-TEST(VariableLengthPrefixSet, MinMaxPrefixSet)
+TEST(UrlClassifierVLPrefixSet, MinMaxPrefixSet)
 {
   RefPtr<VariableLengthPrefixSet> pset = new VariableLengthPrefixSet;
   pset->Init(NS_LITERAL_CSTRING("test"));
 
   PrefixStringMap map;
   {
     _PrefixArray array = { _Prefix("1234"),
                            _Prefix("ABCDEFGHIJKKMNOP"),
@@ -432,17 +432,17 @@ TEST(VariableLengthPrefixSet, MinMaxPref
 
     SetupPrefixMap(array, map);
     nsresult rv = pset->SetPrefixes(map);
     ASSERT_TRUE(NS_FAILED(rv));
   }
 }
 
 // Test save then load prefix set with only 4-bytes prefixes
-TEST(VariableLengthPrefixSet, LoadSaveFixedLengthPrefixSet)
+TEST(UrlClassifierVLPrefixSet, LoadSaveFixedLengthPrefixSet)
 {
   RefPtr<VariableLengthPrefixSet> save = new VariableLengthPrefixSet;
   save->Init(NS_LITERAL_CSTRING("test-save"));
 
   _PrefixArray array;
   RandomPrefixes(10000, 4, 4, array);
 
   PrefixStringMap map;
@@ -472,17 +472,17 @@ TEST(VariableLengthPrefixSet, LoadSaveFi
   DoRandomLookup(load, 1000, array);
 
   CheckContent(load, map);
 
   file->Remove(false);
 }
 
 // Test save then load prefix set with only 5~32 bytes prefixes
-TEST(VariableLengthPrefixSet, LoadSaveVariableLengthPrefixSet)
+TEST(UrlClassifierVLPrefixSet, LoadSaveVariableLengthPrefixSet)
 {
   RefPtr<VariableLengthPrefixSet> save = new VariableLengthPrefixSet;
   save->Init(NS_LITERAL_CSTRING("test-save"));
 
   _PrefixArray array;
   RandomPrefixes(10000, 5, 32, array);
 
   PrefixStringMap map;
@@ -512,17 +512,17 @@ TEST(VariableLengthPrefixSet, LoadSaveVa
   DoRandomLookup(load, 1000, array);
 
   CheckContent(load, map);
 
   file->Remove(false);
 }
 
 // Test save then load prefix with both 4 bytes prefixes and 5~32 bytes prefixes
-TEST(VariableLengthPrefixSet, LoadSavePrefixSet)
+TEST(UrlClassifierVLPrefixSet, LoadSavePrefixSet)
 {
   RefPtr<VariableLengthPrefixSet> save = new VariableLengthPrefixSet;
   save->Init(NS_LITERAL_CSTRING("test-save"));
 
   // Try to simulate the real case that most prefixes are 4bytes
   _PrefixArray array;
   RandomPrefixes(20000, 4, 4, array);
   RandomPrefixes(1000, 5, 32, array);