diff --git a/include/fmt/os.h b/include/fmt/os.h
index f43bb089..a1a0d03b 100644
--- a/include/fmt/os.h
+++ b/include/fmt/os.h
@@ -345,15 +345,15 @@ long getpagesize();
 
 #ifdef FMT_LOCALE
 // A "C" numeric locale.
-class Locale {
+class locale {
  private:
 #  ifdef _WIN32
   using locale_t = _locale_t;
 
-  static void freelocale(locale_t locale) { _free_locale(locale); }
+  static void freelocale(locale_t loc) { _free_locale(loc); }
 
-  static double strtod_l(const char* nptr, char** endptr, _locale_t locale) {
-    return _strtod_l(nptr, endptr, locale);
+  static double strtod_l(const char* nptr, char** endptr, _locale_t loc) {
+    return _strtod_l(nptr, endptr, loc);
   }
 #  endif
 
@@ -361,10 +361,10 @@ class Locale {
 
  public:
   using type = locale_t;
-  Locale(const Locale&) = delete;
-  void operator=(const Locale&) = delete;
+  locale(const locale&) = delete;
+  void operator=(const locale&) = delete;
 
-  Locale() {
+  locale() {
 #  ifndef _WIN32
     locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr));
 #  else
@@ -372,7 +372,7 @@ class Locale {
 #  endif
     if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
   }
-  ~Locale() { freelocale(locale_); }
+  ~locale() { freelocale(locale_); }
 
   type get() const { return locale_; }
 
@@ -385,6 +385,7 @@ class Locale {
     return result;
   }
 };
+using Locale FMT_DEPRECATED_ALIAS = locale;
 #endif  // FMT_LOCALE
 FMT_END_NAMESPACE
 
diff --git a/test/os-test.cc b/test/os-test.cc
index 0854e4fa..ee963087 100644
--- a/test/os-test.cc
+++ b/test/os-test.cc
@@ -489,9 +489,9 @@ TEST(FileTest, Fdopen) {
 
 #  ifdef FMT_LOCALE
 TEST(LocaleTest, Strtod) {
-  fmt::Locale locale;
+  fmt::locale loc;
   const char *start = "4.2", *ptr = start;
-  EXPECT_EQ(4.2, locale.strtod(ptr));
+  EXPECT_EQ(4.2, loc.strtod(ptr));
   EXPECT_EQ(start + 3, ptr);
 }
 #  endif
diff --git a/test/posix-mock-test.cc b/test/posix-mock-test.cc
index acc0e2f5..c4cd5530 100644
--- a/test/posix-mock-test.cc
+++ b/test/posix-mock-test.cc
@@ -53,7 +53,7 @@ std::size_t read_nbyte;
 std::size_t write_nbyte;
 bool sysconf_error;
 
-enum FStatSimulation { NONE, MAX_SIZE, ERROR } fstat_sim;
+enum { NONE, MAX_SIZE, ERROR } fstat_sim;
 }  // namespace
 
 #define EMULATE_EINTR(func, error_result) \
@@ -437,33 +437,33 @@ TEST(BufferedFileTest, FilenoNoRetry) {
 }
 #endif  // FMT_USE_FCNTL
 
-struct TestMock {
-  static TestMock* instance;
-} * TestMock::instance;
+struct test_mock {
+  static test_mock* instance;
+} * test_mock::instance;
 
 TEST(ScopedMock, Scope) {
   {
-    ScopedMock<TestMock> mock;
-    EXPECT_EQ(&mock, TestMock::instance);
-    TestMock& copy = mock;
+    ScopedMock<test_mock> mock;
+    EXPECT_EQ(&mock, test_mock::instance);
+    test_mock& copy = mock;
     static_cast<void>(copy);
   }
-  EXPECT_EQ(nullptr, TestMock::instance);
+  EXPECT_EQ(nullptr, test_mock::instance);
 }
 
 #ifdef FMT_LOCALE
 
-typedef fmt::Locale::type LocaleType;
+typedef fmt::locale::type locale_type;
 
-struct LocaleMock {
-  static LocaleMock* instance;
-  MOCK_METHOD3(newlocale, LocaleType(int category_mask, const char* locale,
-                                     LocaleType base));
-  MOCK_METHOD1(freelocale, void(LocaleType locale));
+struct locale_mock {
+  static locale_mock* instance;
+  MOCK_METHOD3(newlocale, locale_type(int category_mask, const char* locale,
+                                      locale_type base));
+  MOCK_METHOD1(freelocale, void(locale_type locale));
 
   MOCK_METHOD3(strtod_l,
-               double(const char* nptr, char** endptr, LocaleType locale));
-} * LocaleMock::instance;
+               double(const char* nptr, char** endptr, locale_type locale));
+} * locale_mock::instance;
 
 #  ifdef _MSC_VER
 #    pragma warning(push)
@@ -474,15 +474,15 @@ struct LocaleMock {
 #    endif
 
 _locale_t _create_locale(int category, const char* locale) {
-  return LocaleMock::instance->newlocale(category, locale, 0);
+  return locale_mock::instance->newlocale(category, locale, 0);
 }
 
 void _free_locale(_locale_t locale) {
-  LocaleMock::instance->freelocale(locale);
+  locale_mock::instance->freelocale(locale);
 }
 
 double _strtod_l(const char* nptr, char** endptr, _locale_t locale) {
-  return LocaleMock::instance->strtod_l(nptr, endptr, locale);
+  return locale_mock::instance->strtod_l(nptr, endptr, locale);
 }
 #    ifdef __clang__
 #      pragma clang diagnostic pop
@@ -503,26 +503,26 @@ typedef int FreeLocaleResult;
 typedef void FreeLocaleResult;
 #  endif
 
-FreeLocaleResult freelocale(LocaleType locale) FMT_LOCALE_THROW {
-  LocaleMock::instance->freelocale(locale);
+FreeLocaleResult freelocale(locale_type locale) FMT_LOCALE_THROW {
+  locale_mock::instance->freelocale(locale);
   return FreeLocaleResult();
 }
 
 double strtod_l(const char* nptr, char** endptr,
-                LocaleType locale) FMT_LOCALE_THROW {
-  return LocaleMock::instance->strtod_l(nptr, endptr, locale);
+                locale_type locale) FMT_LOCALE_THROW {
+  return locale_mock::instance->strtod_l(nptr, endptr, locale);
 }
 
 #  undef FMT_LOCALE_THROW
 
 #  ifndef _WIN32
 locale_t test::newlocale(int category_mask, const char* locale, locale_t base) {
-  return LocaleMock::instance->newlocale(category_mask, locale, base);
+  return locale_mock::instance->newlocale(category_mask, locale, base);
 }
 
 TEST(LocaleTest, LocaleMock) {
-  ScopedMock<LocaleMock> mock;
-  LocaleType locale = reinterpret_cast<LocaleType>(11);
+  ScopedMock<locale_mock> mock;
+  locale_type locale = reinterpret_cast<locale_type>(11);
   EXPECT_CALL(mock, newlocale(222, StrEq("foo"), locale));
   FMT_SYSTEM(newlocale(222, "foo", locale));
 }
@@ -532,26 +532,26 @@ TEST(LocaleTest, Locale) {
 #  ifndef LC_NUMERIC_MASK
   enum { LC_NUMERIC_MASK = LC_NUMERIC };
 #  endif
-  ScopedMock<LocaleMock> mock;
-  LocaleType impl = reinterpret_cast<LocaleType>(42);
+  ScopedMock<locale_mock> mock;
+  locale_type impl = reinterpret_cast<locale_type>(42);
   EXPECT_CALL(mock, newlocale(LC_NUMERIC_MASK, StrEq("C"), nullptr))
       .WillOnce(Return(impl));
   EXPECT_CALL(mock, freelocale(impl));
-  fmt::Locale locale;
-  EXPECT_EQ(impl, locale.get());
+  fmt::locale loc;
+  EXPECT_EQ(impl, loc.get());
 }
 
 TEST(LocaleTest, Strtod) {
-  ScopedMock<LocaleMock> mock;
+  ScopedMock<locale_mock> mock;
   EXPECT_CALL(mock, newlocale(_, _, _))
-      .WillOnce(Return(reinterpret_cast<LocaleType>(42)));
+      .WillOnce(Return(reinterpret_cast<locale_type>(42)));
   EXPECT_CALL(mock, freelocale(_));
-  fmt::Locale locale;
+  fmt::locale loc;
   const char* str = "4.2";
   char end = 'x';
-  EXPECT_CALL(mock, strtod_l(str, _, locale.get()))
+  EXPECT_CALL(mock, strtod_l(str, _, loc.get()))
       .WillOnce(testing::DoAll(testing::SetArgPointee<1>(&end), Return(777)));
-  EXPECT_EQ(777, locale.strtod(str));
+  EXPECT_EQ(777, loc.strtod(str));
   EXPECT_EQ(&end, str);
 }