Fixes a slew of compiler warnings and turns on "warning as error" in the scons build.
diff --git a/include/gmock/gmock-actions.h b/include/gmock/gmock-actions.h
index d965e10..007ad9d 100644
--- a/include/gmock/gmock-actions.h
+++ b/include/gmock/gmock-actions.h
@@ -268,6 +268,7 @@
 
   // Returns true iff this is the DoDefault() action.
   bool IsDoDefault() const { return is_do_default_; }
+
  private:
   template <typename Function>
   friend class internal::MonomorphicDoDefaultActionImpl;
@@ -279,6 +280,8 @@
 
   // True iff this action is DoDefault().
   const bool is_do_default_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
 };
 
 // An Action<F> is a copyable and IMMUTABLE (except by assignment)
@@ -325,6 +328,7 @@
   Result Perform(const ArgumentTuple& args) const {
     return impl_->Perform(args);
   }
+
  private:
   template <typename F1, typename F2>
   friend class internal::ActionAdaptor;
@@ -362,6 +366,7 @@
   operator Action<F>() const {
     return Action<F>(new MonomorphicImpl<F>(impl_));
   }
+
  private:
   template <typename F>
   class MonomorphicImpl : public ActionInterface<F> {
@@ -377,9 +382,13 @@
 
    private:
     Impl impl_;
+
+    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
   };
 
   Impl impl_;
+
+  GTEST_DISALLOW_ASSIGN_(PolymorphicAction);
 };
 
 // Creates an Action from its implementation and returns it.  The
@@ -416,8 +425,11 @@
   virtual Result Perform(const ArgumentTuple& args) {
     return impl_->Perform(args);
   }
+
  private:
   const internal::linked_ptr<ActionInterface<F2> > impl_;
+
+  GTEST_DISALLOW_ASSIGN_(ActionAdaptor);
 };
 
 // Implements the polymorphic Return(x) action, which can be used in
@@ -470,6 +482,7 @@
         use_ReturnRef_instead_of_Return_to_return_a_reference);
     return Action<F>(new Impl<F>(value_));
   }
+
  private:
   // Implements the Return(x) action for a particular function type F.
   template <typename F>
@@ -494,9 +507,13 @@
     GMOCK_COMPILE_ASSERT_(!internal::is_reference<Result>::value,
                           Result_cannot_be_a_reference_type);
     Result value_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };
 
   R value_;
+
+  GTEST_DISALLOW_ASSIGN_(ReturnAction);
 };
 
 // Implements the ReturnNull() action.
@@ -542,6 +559,7 @@
                           use_Return_instead_of_ReturnRef_to_return_a_value);
     return Action<F>(new Impl<F>(ref_));
   }
+
  private:
   // Implements the ReturnRef(x) action for a particular function type F.
   template <typename F>
@@ -555,11 +573,16 @@
     virtual Result Perform(const ArgumentTuple&) {
       return ref_;
     }
+
    private:
     T& ref_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };
 
   T& ref_;
+
+  GTEST_DISALLOW_ASSIGN_(ReturnRefAction);
 };
 
 // Implements the DoDefault() action for a particular function type F.
@@ -611,9 +634,12 @@
   void Perform(const ArgumentTuple& /* args */) const {
     *ptr_ = value_;
   }
+
  private:
   T1* const ptr_;
   const T2 value_;
+
+  GTEST_DISALLOW_ASSIGN_(AssignAction);
 };
 
 #if !GTEST_OS_WINDOWS_MOBILE
@@ -631,9 +657,12 @@
     errno = errno_;
     return result_;
   }
+
  private:
   const int errno_;
   const T result_;
+
+  GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction);
 };
 
 #endif  // !GTEST_OS_WINDOWS_MOBILE
@@ -657,6 +686,8 @@
 
  private:
   const A value_;
+
+  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
 };
 
 template <size_t N, typename Proto>
@@ -675,8 +706,11 @@
     CompileAssertTypesEqual<void, Result>();
     ::std::tr1::get<N>(args)->CopyFrom(*proto_);
   }
+
  private:
   const internal::linked_ptr<Proto> proto_;
+
+  GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
 };
 
 // Implements the InvokeWithoutArgs(f) action.  The template argument
@@ -696,8 +730,11 @@
   // compatible with f.
   template <typename Result, typename ArgumentTuple>
   Result Perform(const ArgumentTuple&) { return function_impl_(); }
+
  private:
   FunctionImpl function_impl_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction);
 };
 
 // Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
@@ -711,9 +748,12 @@
   Result Perform(const ArgumentTuple&) const {
     return (obj_ptr_->*method_ptr_)();
   }
+
  private:
   Class* const obj_ptr_;
   const MethodPtr method_ptr_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction);
 };
 
 // Implements the IgnoreResult(action) action.
@@ -739,6 +779,7 @@
 
     return Action<F>(new Impl<F>(action_));
   }
+
  private:
   template <typename F>
   class Impl : public ActionInterface<F> {
@@ -760,9 +801,13 @@
         OriginalFunction;
 
     const Action<OriginalFunction> action_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };
 
   const A action_;
+
+  GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
 };
 
 // A ReferenceWrapper<T> object represents a reference to type T,
@@ -827,10 +872,14 @@
    private:
     const Action<VoidResult> action1_;
     const Action<F> action2_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };
 
   Action1 action1_;
   Action2 action2_;
+
+  GTEST_DISALLOW_ASSIGN_(DoBothAction);
 };
 
 }  // namespace internal
diff --git a/include/gmock/gmock-generated-actions.h b/include/gmock/gmock-generated-actions.h
index 143a99b..2b53c7b 100644
--- a/include/gmock/gmock-generated-actions.h
+++ b/include/gmock/gmock-generated-actions.h
@@ -615,6 +615,8 @@
   };
 
   const InnerAction action_;
+
+  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
 };
 
 // A macro from the ACTION* family (defined later in this file)
@@ -1406,12 +1408,16 @@
           arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
           arg9_type arg9) const;\
       GMOCK_INTERNAL_DEFN_##value_params\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(\
           new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
     }\
     GMOCK_INTERNAL_DEFN_##value_params\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
   };\
   template <GMOCK_INTERNAL_DECL_##template_params\
             GMOCK_INTERNAL_DECL_TYPE_##value_params>\
@@ -1462,10 +1468,14 @@
           arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
           arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
           arg9_type arg9) const;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>());\
     }\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##Action);\
   };\
   inline name##Action name() {\
     return name##Action();\
@@ -1505,11 +1515,15 @@
           arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
           arg9_type arg9) const;\
       p0##_type p0;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0));\
     }\
     p0##_type p0;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP);\
   };\
   template <typename p0##_type>\
   inline name##ActionP<p0##_type> name(p0##_type p0) {\
@@ -1554,12 +1568,16 @@
           arg9_type arg9) const;\
       p0##_type p0;\
       p1##_type p1;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
     }\
     p0##_type p0;\
     p1##_type p1;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
   };\
   template <typename p0##_type, typename p1##_type>\
   inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
@@ -1606,6 +1624,8 @@
       p0##_type p0;\
       p1##_type p1;\
       p2##_type p2;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
@@ -1613,6 +1633,8 @@
     p0##_type p0;\
     p1##_type p1;\
     p2##_type p2;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type>\
   inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
@@ -1664,6 +1686,8 @@
       p1##_type p1;\
       p2##_type p2;\
       p3##_type p3;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
@@ -1672,6 +1696,8 @@
     p1##_type p1;\
     p2##_type p2;\
     p3##_type p3;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type>\
@@ -1729,6 +1755,8 @@
       p2##_type p2;\
       p3##_type p3;\
       p4##_type p4;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
@@ -1738,6 +1766,8 @@
     p2##_type p2;\
     p3##_type p3;\
     p4##_type p4;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type>\
@@ -1797,6 +1827,8 @@
       p3##_type p3;\
       p4##_type p4;\
       p5##_type p5;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
@@ -1807,6 +1839,8 @@
     p3##_type p3;\
     p4##_type p4;\
     p5##_type p5;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type>\
@@ -1869,6 +1903,8 @@
       p4##_type p4;\
       p5##_type p5;\
       p6##_type p6;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
@@ -1881,6 +1917,8 @@
     p4##_type p4;\
     p5##_type p5;\
     p6##_type p6;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type, \
@@ -1949,6 +1987,8 @@
       p5##_type p5;\
       p6##_type p6;\
       p7##_type p7;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
@@ -1962,6 +2002,8 @@
     p5##_type p5;\
     p6##_type p6;\
     p7##_type p7;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type, \
@@ -2034,6 +2076,8 @@
       p6##_type p6;\
       p7##_type p7;\
       p8##_type p8;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
@@ -2048,6 +2092,8 @@
     p6##_type p6;\
     p7##_type p7;\
     p8##_type p8;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type, \
@@ -2123,6 +2169,8 @@
       p7##_type p7;\
       p8##_type p8;\
       p9##_type p9;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
@@ -2138,6 +2186,8 @@
     p7##_type p7;\
     p8##_type p8;\
     p9##_type p9;\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type, \
@@ -2172,6 +2222,16 @@
 // updated.
 namespace testing {
 
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4100)
+#endif
+
 // Various overloads for InvokeArgument<N>().
 //
 // The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
@@ -2350,6 +2410,10 @@
   return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 }  // namespace testing
 
 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
diff --git a/include/gmock/gmock-generated-actions.h.pump b/include/gmock/gmock-generated-actions.h.pump
index 05bf3db..75b1e7a 100644
--- a/include/gmock/gmock-generated-actions.h.pump
+++ b/include/gmock/gmock-generated-actions.h.pump
@@ -228,6 +228,8 @@
   };
 
   const InnerAction action_;
+
+  GTEST_DISALLOW_ASSIGN_(WithArgsAction);
 };
 
 // A macro from the ACTION* family (defined later in this file)
@@ -630,12 +632,16 @@
       return_type gmock_PerformImpl(const args_type& args[[]]
 $for k [[, arg$k[[]]_type arg$k]]) const;\
       GMOCK_INTERNAL_DEFN_##value_params\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(\
           new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
     }\
     GMOCK_INTERNAL_DEFN_##value_params\
+   private:\
+    GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
   };\
   template <GMOCK_INTERNAL_DECL_##template_params\
             GMOCK_INTERNAL_DECL_TYPE_##value_params>\
@@ -712,10 +718,14 @@
       template <$typename_arg_types>\
       return_type gmock_PerformImpl(const args_type& args, [[]]
 $arg_types_and_names) const;\$param_field_decls
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename F> operator ::testing::Action<F>() const {\
       return ::testing::Action<F>(new gmock_Impl<F>($params));\
     }\$param_field_decls2
+   private:\
+    GTEST_DISALLOW_ASSIGN_($class_name);\
   };\$template
   inline $class_name$param_types name($param_types_and_names) {\
     return $class_name$param_types($params);\
@@ -735,6 +745,16 @@
 // updated.
 namespace testing {
 
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4100)
+#endif
+
 // Various overloads for InvokeArgument<N>().
 //
 // The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
@@ -796,6 +816,10 @@
 
 ]]
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 }  // namespace testing
 
 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
diff --git a/include/gmock/gmock-generated-function-mockers.h b/include/gmock/gmock-generated-function-mockers.h
index 9f3a956..3b2ede1 100644
--- a/include/gmock/gmock-generated-function-mockers.h
+++ b/include/gmock/gmock-generated-function-mockers.h
@@ -794,66 +794,116 @@
 template <typename R>
 class MockFunction<R()> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD0_T(Call, R());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0>
 class MockFunction<R(A0)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD1_T(Call, R(A0));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1>
 class MockFunction<R(A0, A1)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD2_T(Call, R(A0, A1));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1, typename A2>
 class MockFunction<R(A0, A1, A2)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD3_T(Call, R(A0, A1, A2));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1, typename A2, typename A3>
 class MockFunction<R(A0, A1, A2, A3)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1, typename A2, typename A3,
     typename A4>
 class MockFunction<R(A0, A1, A2, A3, A4)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1, typename A2, typename A3,
     typename A4, typename A5>
 class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6>
 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6, typename A7>
 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1, typename A2, typename A3,
     typename A4, typename A5, typename A6, typename A7, typename A8>
 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 template <typename R, typename A0, typename A1, typename A2, typename A3,
@@ -861,7 +911,12 @@
     typename A9>
 class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 }  // namespace testing
diff --git a/include/gmock/gmock-generated-function-mockers.h.pump b/include/gmock/gmock-generated-function-mockers.h.pump
index 82106eb..619debd 100644
--- a/include/gmock/gmock-generated-function-mockers.h.pump
+++ b/include/gmock/gmock-generated-function-mockers.h.pump
@@ -242,7 +242,12 @@
 template <typename R$for j [[, typename A$j]]>
 class MockFunction<R($for j, [[A$j]])> {
  public:
+  MockFunction() {}
+
   MOCK_METHOD$i[[]]_T(Call, R($for j, [[A$j]]));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
 };
 
 
diff --git a/include/gmock/gmock-generated-matchers.h b/include/gmock/gmock-generated-matchers.h
index a59e457..18420c1 100644
--- a/include/gmock/gmock-generated-matchers.h
+++ b/include/gmock/gmock-generated-matchers.h
@@ -89,7 +89,7 @@
 class TupleFields<Tuple, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1> {
  public:
   typedef ::std::tr1::tuple<> type;
-  static type GetSelectedFields(const Tuple& t) {
+  static type GetSelectedFields(const Tuple& /* t */) {
     using ::std::tr1::get;
     return type();
   }
@@ -271,6 +271,8 @@
   }
 
   const MonomorphicInnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
 };
 
 template <class InnerMatcher, int k0 = -1, int k1 = -1, int k2 = -1,
@@ -287,7 +289,10 @@
         k6, k7, k8, k9>(inner_matcher_));
   }
 
+ private:
   const InnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
 };
 
 // Implements ElementsAre() of 1-10 arguments.
@@ -317,6 +322,8 @@
 
  private:
   const T1& e1_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher1);
 };
 
 template <typename T1, typename T2>
@@ -342,6 +349,8 @@
  private:
   const T1& e1_;
   const T2& e2_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher2);
 };
 
 template <typename T1, typename T2, typename T3>
@@ -370,6 +379,8 @@
   const T1& e1_;
   const T2& e2_;
   const T3& e3_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher3);
 };
 
 template <typename T1, typename T2, typename T3, typename T4>
@@ -400,6 +411,8 @@
   const T2& e2_;
   const T3& e3_;
   const T4& e4_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher4);
 };
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5>
@@ -432,6 +445,8 @@
   const T3& e3_;
   const T4& e4_;
   const T5& e5_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher5);
 };
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5,
@@ -468,6 +483,8 @@
   const T4& e4_;
   const T5& e5_;
   const T6& e6_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher6);
 };
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5,
@@ -506,6 +523,8 @@
   const T5& e5_;
   const T6& e6_;
   const T7& e7_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher7);
 };
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5,
@@ -546,6 +565,8 @@
   const T6& e6_;
   const T7& e7_;
   const T8& e8_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher8);
 };
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5,
@@ -589,6 +610,8 @@
   const T7& e7_;
   const T8& e8_;
   const T9& e9_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher9);
 };
 
 template <typename T1, typename T2, typename T3, typename T4, typename T5,
@@ -634,6 +657,8 @@
   const T8& e8_;
   const T9& e9_;
   const T10& e10_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher10);
 };
 
 }  // namespace internal
@@ -1012,6 +1037,8 @@
                      #name, description, gmock_interp_, gmock_printed_params);\
       }\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1023,7 +1050,9 @@
       gmock_interp_ = ::testing::internal::ValidateMatcherDescription(\
           gmock_param_names, ("" description ""));\
     }\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##Matcher);\
   };\
   inline name##Matcher name() {\
     return name##Matcher();\
@@ -1052,6 +1081,8 @@
       }\
       p0##_type p0;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1064,7 +1095,9 @@
           gmock_param_names, ("" description ""));\
     }\
     p0##_type p0;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP);\
   };\
   template <typename p0##_type>\
   inline name##MatcherP<p0##_type> name(p0##_type p0) {\
@@ -1096,6 +1129,8 @@
       p0##_type p0;\
       p1##_type p1;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1110,7 +1145,9 @@
     }\
     p0##_type p0;\
     p1##_type p1;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP2);\
   };\
   template <typename p0##_type, typename p1##_type>\
   inline name##MatcherP2<p0##_type, p1##_type> name(p0##_type p0, \
@@ -1146,6 +1183,8 @@
       p1##_type p1;\
       p2##_type p2;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1161,7 +1200,9 @@
     p0##_type p0;\
     p1##_type p1;\
     p2##_type p2;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP3);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type>\
   inline name##MatcherP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
@@ -1200,6 +1241,8 @@
       p2##_type p2;\
       p3##_type p3;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1217,7 +1260,9 @@
     p1##_type p1;\
     p2##_type p2;\
     p3##_type p3;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP4);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type>\
@@ -1261,6 +1306,8 @@
       p3##_type p3;\
       p4##_type p4;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1280,7 +1327,9 @@
     p2##_type p2;\
     p3##_type p3;\
     p4##_type p4;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP5);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type>\
@@ -1325,6 +1374,8 @@
       p4##_type p4;\
       p5##_type p5;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1345,7 +1396,9 @@
     p3##_type p3;\
     p4##_type p4;\
     p5##_type p5;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP6);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type>\
@@ -1396,6 +1449,8 @@
       p5##_type p5;\
       p6##_type p6;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1419,7 +1474,9 @@
     p4##_type p4;\
     p5##_type p5;\
     p6##_type p6;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP7);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type, \
@@ -1474,6 +1531,8 @@
       p6##_type p6;\
       p7##_type p7;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1500,7 +1559,9 @@
     p5##_type p5;\
     p6##_type p6;\
     p7##_type p7;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP8);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type, \
@@ -1557,6 +1618,8 @@
       p7##_type p7;\
       p8##_type p8;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1584,7 +1647,9 @@
     p6##_type p6;\
     p7##_type p7;\
     p8##_type p8;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP9);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type, \
@@ -1645,6 +1710,8 @@
       p8##_type p8;\
       p9##_type p9;\
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -1673,7 +1740,9 @@
     p7##_type p7;\
     p8##_type p8;\
     p9##_type p9;\
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_(name##MatcherP10);\
   };\
   template <typename p0##_type, typename p1##_type, typename p2##_type, \
       typename p3##_type, typename p4##_type, typename p5##_type, \
diff --git a/include/gmock/gmock-generated-matchers.h.pump b/include/gmock/gmock-generated-matchers.h.pump
index c43aa87..8abbc0c 100644
--- a/include/gmock/gmock-generated-matchers.h.pump
+++ b/include/gmock/gmock-generated-matchers.h.pump
@@ -91,7 +91,7 @@
 class TupleFields<Tuple, $for k, [[$if k < i [[k$k]] $else [[-1]]]]> {
  public:
   typedef ::std::tr1::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;
-  static type GetSelectedFields(const Tuple& t) {
+  static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
     using ::std::tr1::get;
     return type($for j, [[get<k$j>(t)]]);
   }
@@ -157,6 +157,8 @@
   }
 
   const MonomorphicInnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
 };
 
 template <class InnerMatcher$for i [[, int k$i = -1]]>
@@ -170,7 +172,10 @@
     return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, $ks>(inner_matcher_));
   }
 
+ private:
   const InnerMatcher inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
 };
 
 // Implements ElementsAre() of 1-$n arguments.
@@ -224,6 +229,8 @@
   const T$j& e$j[[]]_;
 
 ]]
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher$i);
 };
 
 
@@ -512,6 +519,8 @@
                      #name, description, gmock_interp_, gmock_printed_params);\
       }\$param_field_decls
       const ::testing::internal::Interpolations gmock_interp_;\
+     private:\
+      GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
     };\
     template <typename arg_type>\
     operator ::testing::Matcher<arg_type>() const {\
@@ -523,7 +532,9 @@
       gmock_interp_ = ::testing::internal::ValidateMatcherDescription(\
           gmock_param_names, ("" description ""));\
     }\$param_field_decls2
+   private:\
     ::testing::internal::Interpolations gmock_interp_;\
+    GTEST_DISALLOW_ASSIGN_($class_name);\
   };\$template
   inline $class_name$param_types name($param_types_and_names) {\
     return $class_name$param_types($params);\
diff --git a/include/gmock/gmock-generated-nice-strict.h b/include/gmock/gmock-generated-nice-strict.h
index fc9a81b..435467f 100644
--- a/include/gmock/gmock-generated-nice-strict.h
+++ b/include/gmock/gmock-generated-nice-strict.h
@@ -155,6 +155,9 @@
     ::testing::Mock::UnregisterCallReaction(
         internal::implicit_cast<MockClass*>(this));
   }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
 };
 
 template <class MockClass>
@@ -246,6 +249,9 @@
     ::testing::Mock::UnregisterCallReaction(
         internal::implicit_cast<MockClass*>(this));
   }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
 };
 
 // The following specializations catch some (relatively more common)
diff --git a/include/gmock/gmock-generated-nice-strict.h.pump b/include/gmock/gmock-generated-nice-strict.h.pump
index b265c2e..96371f5 100644
--- a/include/gmock/gmock-generated-nice-strict.h.pump
+++ b/include/gmock/gmock-generated-nice-strict.h.pump
@@ -100,6 +100,9 @@
     ::testing::Mock::UnregisterCallReaction(
         internal::implicit_cast<MockClass*>(this));
   }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
 };
 
 template <class MockClass>
@@ -132,6 +135,9 @@
     ::testing::Mock::UnregisterCallReaction(
         internal::implicit_cast<MockClass*>(this));
   }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
 };
 
 // The following specializations catch some (relatively more common)
diff --git a/include/gmock/gmock-matchers.h b/include/gmock/gmock-matchers.h
index deb0946..5f5a29f 100644
--- a/include/gmock/gmock-matchers.h
+++ b/include/gmock/gmock-matchers.h
@@ -121,6 +121,7 @@
   void ExplainMatchResultTo(T x, ::std::ostream* os) const {
     impl_->ExplainMatchResultTo(x, os);
   }
+
  protected:
   MatcherBase() {}
 
@@ -129,6 +130,7 @@
       : impl_(impl) {}
 
   virtual ~MatcherBase() {}
+
  private:
   // shared_ptr (util/gtl/shared_ptr.h) and linked_ptr have similar
   // interfaces.  The former dynamically allocates a chunk of memory
@@ -234,7 +236,7 @@
 template <class Impl>
 class PolymorphicMatcher {
  public:
-  explicit PolymorphicMatcher(const Impl& impl) : impl_(impl) {}
+  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
 
   // Returns a mutable reference to the underlying matcher
   // implementation object.
@@ -248,6 +250,7 @@
   operator Matcher<T>() const {
     return Matcher<T>(new MonomorphicImpl<T>(impl_));
   }
+
  private:
   template <typename T>
   class MonomorphicImpl : public MatcherInterface<T> {
@@ -284,9 +287,13 @@
 
    private:
     const Impl impl_;
+
+    GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
   };
 
   Impl impl_;
+
+  GTEST_DISALLOW_ASSIGN_(PolymorphicMatcher);
 };
 
 // Creates a matcher from its implementation.  This is easier to use
@@ -522,6 +529,7 @@
   static Matcher<T> Cast(const Matcher<U>& source_matcher) {
     return Matcher<T>(new Impl(source_matcher));
   }
+
  private:
   class Impl : public MatcherInterface<T> {
    public:
@@ -544,8 +552,11 @@
     virtual void ExplainMatchResultTo(T x, ::std::ostream* os) const {
       source_matcher_.ExplainMatchResultTo(static_cast<U>(x), os);
     }
+
    private:
     const Matcher<U> source_matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };
 };
 
@@ -618,8 +629,10 @@
       } \
      private: \
       Rhs rhs_; \
+      GTEST_DISALLOW_ASSIGN_(Impl); \
     }; \
     Rhs rhs_; \
+    GTEST_DISALLOW_ASSIGN_(name##Matcher); \
   }
 
 // Implements Eq(v), Ge(v), Gt(v), Le(v), Lt(v), and Ne(v)
@@ -697,6 +710,7 @@
     // reference to a non-const reference.
     return MakeMatcher(new Impl<Super>(object_));
   }
+
  private:
   template <typename Super>
   class Impl : public MatcherInterface<Super&> {
@@ -721,11 +735,16 @@
                                       ::std::ostream* os) const {
       *os << "is located @" << static_cast<const void*>(&x);
     }
+
    private:
     const Super& object_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };
 
   T& object_;
+
+  GTEST_DISALLOW_ASSIGN_(RefMatcher);
 };
 
 // Polymorphic helper functions for narrow and wide string matchers.
@@ -795,6 +814,7 @@
   void DescribeNegationTo(::std::ostream* os) const {
     DescribeToHelper(!expect_eq_, os);
   }
+
  private:
   void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
     *os << "is ";
@@ -811,6 +831,8 @@
   const StringType string_;
   const bool expect_eq_;
   const bool case_sensitive_;
+
+  GTEST_DISALLOW_ASSIGN_(StrEqualityMatcher);
 };
 
 // Implements the polymorphic HasSubstr(substring) matcher, which
@@ -845,8 +867,11 @@
     *os << "has no substring ";
     UniversalPrinter<StringType>::Print(substring_, os);
   }
+
  private:
   const StringType substring_;
+
+  GTEST_DISALLOW_ASSIGN_(HasSubstrMatcher);
 };
 
 // Implements the polymorphic StartsWith(substring) matcher, which
@@ -881,8 +906,11 @@
     *os << "doesn't start with ";
     UniversalPrinter<StringType>::Print(prefix_, os);
   }
+
  private:
   const StringType prefix_;
+
+  GTEST_DISALLOW_ASSIGN_(StartsWithMatcher);
 };
 
 // Implements the polymorphic EndsWith(substring) matcher, which
@@ -916,8 +944,11 @@
     *os << "doesn't end with ";
     UniversalPrinter<StringType>::Print(suffix_, os);
   }
+
  private:
   const StringType suffix_;
+
+  GTEST_DISALLOW_ASSIGN_(EndsWithMatcher);
 };
 
 #if GMOCK_HAS_REGEX
@@ -954,9 +985,12 @@
         << " regular expression ";
     UniversalPrinter<internal::string>::Print(regex_->pattern(), os);
   }
+
  private:
   const internal::linked_ptr<const RE> regex_;
   const bool full_match_;
+
+  GTEST_DISALLOW_ASSIGN_(MatchesRegexMatcher);
 };
 
 #endif  // GMOCK_HAS_REGEX
@@ -1030,8 +1064,11 @@
   virtual void ExplainMatchResultTo(T x, ::std::ostream* os) const {
     matcher_.ExplainMatchResultTo(x, os);
   }
+
  private:
   const Matcher<T> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(NotMatcherImpl);
 };
 
 // Implements the Not(m) matcher, which matches a value that doesn't
@@ -1047,8 +1084,11 @@
   operator Matcher<T>() const {
     return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
   }
+
  private:
   InnerMatcher matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(NotMatcher);
 };
 
 // Implements the AllOf(m1, m2) matcher for a particular argument type
@@ -1108,9 +1148,12 @@
       }
     }
   }
+
  private:
   const Matcher<T> matcher1_;
   const Matcher<T> matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(BothOfMatcherImpl);
 };
 
 // Used for implementing the AllOf(m_1, ..., m_n) matcher, which
@@ -1129,9 +1172,12 @@
     return Matcher<T>(new BothOfMatcherImpl<T>(SafeMatcherCast<T>(matcher1_),
                                                SafeMatcherCast<T>(matcher2_)));
   }
+
  private:
   Matcher1 matcher1_;
   Matcher2 matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(BothOfMatcher);
 };
 
 // Implements the AnyOf(m1, m2) matcher for a particular argument type
@@ -1190,9 +1236,12 @@
       }
     }
   }
+
  private:
   const Matcher<T> matcher1_;
   const Matcher<T> matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(EitherOfMatcherImpl);
 };
 
 // Used for implementing the AnyOf(m_1, ..., m_n) matcher, which
@@ -1212,9 +1261,12 @@
     return Matcher<T>(new EitherOfMatcherImpl<T>(
         SafeMatcherCast<T>(matcher1_), SafeMatcherCast<T>(matcher2_)));
   }
+
  private:
   Matcher1 matcher1_;
   Matcher2 matcher2_;
+
+  GTEST_DISALLOW_ASSIGN_(EitherOfMatcher);
 };
 
 // Used for implementing Truly(pred), which turns a predicate into a
@@ -1248,8 +1300,11 @@
   void DescribeNegationTo(::std::ostream* os) const {
     *os << "doesn't satisfy the given predicate";
   }
+
  private:
   Predicate predicate_;
+
+  GTEST_DISALLOW_ASSIGN_(TrulyMatcher);
 };
 
 // Used for implementing Matches(matcher), which turns a matcher into
@@ -1283,8 +1338,11 @@
     // in all of the above situations.
     return MatcherCast<const T&>(matcher_).Matches(x);
   }
+
  private:
   M matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(MatcherAsPredicate);
 };
 
 // For implementing ASSERT_THAT() and EXPECT_THAT().  The template
@@ -1322,8 +1380,11 @@
       return AssertionFailure(Message() << ss.str());
     }
   }
+
  private:
   const M matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PredicateFormatterFromMatcher);
 };
 
 // A helper function for converting a matcher to a predicate-formatter
@@ -1405,6 +1466,8 @@
    private:
     const FloatType rhs_;
     const bool nan_eq_nan_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };
 
   // The following 3 type conversion operators allow FloatEq(rhs) and
@@ -1427,6 +1490,8 @@
  private:
   const FloatType rhs_;
   const bool nan_eq_nan_;
+
+  GTEST_DISALLOW_ASSIGN_(FloatingEqMatcher);
 };
 
 // Implements the Pointee(m) matcher for matching a pointer whose
@@ -1448,6 +1513,7 @@
   operator Matcher<Pointer>() const {
     return MakeMatcher(new Impl<Pointer>(matcher_));
   }
+
  private:
   // The monomorphic implementation that works for a particular pointer type.
   template <typename Pointer>
@@ -1485,11 +1551,16 @@
         *os << "points to a value that " << s;
       }
     }
+
    private:
     const Matcher<const Pointee&> matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };
 
   const InnerMatcher matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PointeeMatcher);
 };
 
 // Implements the Field() matcher for matching a field (i.e. member
@@ -1543,9 +1614,12 @@
       ExplainMatchResultTo(false_type(), *p, os);
     }
   }
+
  private:
   const FieldType Class::*field_;
   const Matcher<const FieldType&> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(FieldMatcher);
 };
 
 // Explains the result of matching an object or pointer against a field matcher.
@@ -1613,9 +1687,12 @@
       ExplainMatchResultTo(false_type(), *p, os);
     }
   }
+
  private:
   PropertyType (Class::*property_)() const;
   const Matcher<RefToConstProperty> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PropertyMatcher);
 };
 
 // Explains the result of matching an object or pointer against a
@@ -1636,7 +1713,7 @@
   typedef typename Functor::result_type ResultType;
   typedef Functor StorageType;
 
-  static void CheckIsValid(Functor functor) {}
+  static void CheckIsValid(Functor /* functor */) {}
   template <typename T>
   static ResultType Invoke(Functor f, T arg) { return f(arg); }
 };
@@ -1709,6 +1786,7 @@
       if (s != "")
         *os << "result of the given callable " << s;
     }
+
    private:
     // Functors often define operator() as non-const method even though
     // they are actualy stateless. But we need to use them even when
@@ -1717,10 +1795,14 @@
     // how many times the callable will be invoked.
     mutable CallableStorageType callable_;
     const Matcher<ResultType> matcher_;
+
+    GTEST_DISALLOW_ASSIGN_(Impl);
   };  // class Impl
 
   const CallableStorageType callable_;
   const Matcher<ResultType> matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ResultOfMatcher);
 };
 
 // Explains the result of matching a value against a functor matcher.
@@ -1818,8 +1900,11 @@
       }
     }
   }
+
  private:
   const StlContainer rhs_;
+
+  GTEST_DISALLOW_ASSIGN_(ContainerEqMatcher);
 };
 
 template <typename LhsContainer, typename Container>
@@ -1884,6 +1969,8 @@
 
  private:
   const Matcher<const Element&> inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ContainsMatcherImpl);
 };
 
 // Implements polymorphic Contains(element_matcher).
@@ -1899,6 +1986,8 @@
 
  private:
   const M inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(ContainsMatcher);
 };
 
 // Implements Key(inner_matcher) for the given argument pair type.
@@ -1942,6 +2031,8 @@
 
  private:
   const Matcher<const KeyType&> inner_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(KeyMatcherImpl);
 };
 
 // Implements polymorphic Key(matcher_for_key).
@@ -1957,6 +2048,8 @@
 
  private:
   const M matcher_for_key_;
+
+  GTEST_DISALLOW_ASSIGN_(KeyMatcher);
 };
 
 // Implements Pair(first_matcher, second_matcher) for the given argument pair
@@ -2026,6 +2119,8 @@
  private:
   const Matcher<const FirstType&> first_matcher_;
   const Matcher<const SecondType&> second_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PairMatcherImpl);
 };
 
 // Implements polymorphic Pair(first_matcher, second_matcher).
@@ -2045,6 +2140,8 @@
  private:
   const FirstMatcher first_matcher_;
   const SecondMatcher second_matcher_;
+
+  GTEST_DISALLOW_ASSIGN_(PairMatcher);
 };
 
 // Implements ElementsAre() and ElementsAreArray().
@@ -2060,10 +2157,10 @@
   // Constructs the matcher from a sequence of element values or
   // element matchers.
   template <typename InputIter>
-  ElementsAreMatcherImpl(InputIter first, size_t count) {
-    matchers_.reserve(count);
+  ElementsAreMatcherImpl(InputIter first, size_t a_count) {
+    matchers_.reserve(a_count);
     InputIter it = first;
-    for (size_t i = 0; i != count; ++i, ++it) {
+    for (size_t i = 0; i != a_count; ++i, ++it) {
       matchers_.push_back(MatcherCast<const Element&>(*it));
     }
   }
@@ -2185,6 +2282,8 @@
 
   size_t count() const { return matchers_.size(); }
   std::vector<Matcher<const Element&> > matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreMatcherImpl);
 };
 
 // Implements ElementsAre() of 0 arguments.
@@ -2224,6 +2323,8 @@
  private:
   const T* const first_;
   const size_t count_;
+
+  GTEST_DISALLOW_ASSIGN_(ElementsAreArrayMatcher);
 };
 
 // Constants denoting interpolations in a matcher description string.
diff --git a/include/gmock/gmock-more-actions.h b/include/gmock/gmock-more-actions.h
index c6fa6bb..6226392 100644
--- a/include/gmock/gmock-more-actions.h
+++ b/include/gmock/gmock-more-actions.h
@@ -58,8 +58,11 @@
   Result Perform(const ArgumentTuple& args) {
     return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args);
   }
+
  private:
   FunctionImpl function_impl_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeAction);
 };
 
 // Implements the Invoke(object_ptr, &Class::Method) action.
@@ -74,9 +77,12 @@
     return InvokeHelper<Result, ArgumentTuple>::InvokeMethod(
         obj_ptr_, method_ptr_, args);
   }
+
  private:
   Class* const obj_ptr_;
   const MethodPtr method_ptr_;
+
+  GTEST_DISALLOW_ASSIGN_(InvokeMethodAction);
 };
 
 }  // namespace internal
@@ -122,6 +128,16 @@
   return internal::WithArgsAction<InnerAction, k>(action);
 }
 
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4100)
+#endif
+
 // Action ReturnArg<k>() returns the k-th argument of the mock function.
 ACTION_TEMPLATE(ReturnArg,
                 HAS_1_TEMPLATE_PARAMS(int, k),
@@ -185,6 +201,10 @@
 ACTION_P(Throw, exception) { throw exception; }
 #endif  // GTEST_HAS_EXCEPTIONS
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 }  // namespace testing
 
 #endif  // GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
diff --git a/include/gmock/gmock-spec-builders.h b/include/gmock/gmock-spec-builders.h
index 9cb549a..9aa0a9e 100644
--- a/include/gmock/gmock-spec-builders.h
+++ b/include/gmock/gmock-spec-builders.h
@@ -142,10 +142,10 @@
 
   // Constructs a DefaultActionSpec object from the information inside
   // the parenthesis of an ON_CALL() statement.
-  DefaultActionSpec(const char* file, int line,
+  DefaultActionSpec(const char* a_file, int a_line,
                     const ArgumentMatcherTuple& matchers)
-      : file_(file),
-        line_(line),
+      : file_(a_file),
+        line_(a_line),
         matchers_(matchers),
         // By default, extra_matcher_ should match anything.  However,
         // we cannot initialize it with _ as that triggers a compiler
@@ -196,6 +196,7 @@
                        "once in an ON_CALL().");
     return action_;
   }
+
  private:
   // Gives each clause in the ON_CALL() statement a name.
   enum Clause {
@@ -582,6 +583,7 @@
   // expectation has occurred.
   // L >= g_gmock_mutex
   virtual void DescribeCallCountTo(::std::ostream* os) const = 0;
+
  protected:
   friend class ::testing::Expectation;
 
@@ -620,8 +622,8 @@
   bool cardinality_specified() const { return cardinality_specified_; }
 
   // Sets the cardinality of this expectation spec.
-  void set_cardinality(const Cardinality& cardinality) {
-    cardinality_ = cardinality;
+  void set_cardinality(const Cardinality& a_cardinality) {
+    cardinality_ = a_cardinality;
   }
 
   // The following group of methods should only be called after the
@@ -716,6 +718,8 @@
   // and can change as the mock function is called.
   int call_count_;  // How many times this expectation has been invoked.
   bool retired_;    // True iff this expectation has retired.
+
+  GTEST_DISALLOW_ASSIGN_(ExpectationBase);
 };  // class ExpectationBase
 
 // Impements an expectation for the given function type.
@@ -727,9 +731,9 @@
   typedef typename Function<F>::Result Result;
 
   TypedExpectation(FunctionMockerBase<F>* owner,
-                   const char* file, int line, const string& source_text,
+                   const char* a_file, int a_line, const string& a_source_text,
                    const ArgumentMatcherTuple& m)
-      : ExpectationBase(file, line, source_text),
+      : ExpectationBase(a_file, a_line, a_source_text),
         owner_(owner),
         matchers_(m),
         extra_matcher_specified_(false),
@@ -769,7 +773,7 @@
   }
 
   // Implements the .Times() clause.
-  TypedExpectation& Times(const Cardinality& cardinality) {
+  TypedExpectation& Times(const Cardinality& a_cardinality) {
     if (last_clause_ ==kTimes) {
       ExpectSpecProperty(false,
                          ".Times() cannot appear "
@@ -782,7 +786,7 @@
     }
     last_clause_ = kTimes;
 
-    ExpectationBase::SpecifyCardinality(cardinality);
+    ExpectationBase::SpecifyCardinality(a_cardinality);
     return *this;
   }
 
@@ -1164,6 +1168,8 @@
   Clause last_clause_;
   mutable bool action_count_checked_;  // Under mutex_.
   mutable Mutex mutex_;  // Protects action_count_checked_.
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
 };  // class TypedExpectation
 
 // A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
@@ -1228,6 +1234,8 @@
   internal::FunctionMockerBase<F>* const function_mocker_;
   // The argument matchers specified in the spec.
   ArgumentMatcherTuple matchers_;
+
+  GTEST_DISALLOW_ASSIGN_(MockSpec);
 };  // class MockSpec
 
 // MSVC warns about using 'this' in base member initializer list, so
@@ -1251,7 +1259,7 @@
 template <typename T>
 class ActionResultHolder {
  public:
-  explicit ActionResultHolder(T value) : value_(value) {}
+  explicit ActionResultHolder(T a_value) : value_(a_value) {}
 
   // The compiler-generated copy constructor and assignment operator
   // are exactly what we need, so we don't need to define them.
@@ -1285,6 +1293,9 @@
 
  private:
   T value_;
+
+  // T could be a reference type, so = isn't supported.
+  GTEST_DISALLOW_ASSIGN_(ActionResultHolder);
 };
 
 // Specialization for T = void.
@@ -1433,6 +1444,7 @@
     }
     return name;
   }
+
  protected:
   template <typename Function>
   friend class MockSpec;
@@ -1477,6 +1489,7 @@
   // The current spec (either default action spec or expectation spec)
   // being described on this function mocker.
   MockSpec<F>& current_spec() { return current_spec_; }
+
  private:
   template <typename Func> friend class TypedExpectation;
 
diff --git a/include/gmock/internal/gmock-internal-utils.h b/include/gmock/internal/gmock-internal-utils.h
index 7b17335..0c33fdd 100644
--- a/include/gmock/internal/gmock-internal-utils.h
+++ b/include/gmock/internal/gmock-internal-utils.h
@@ -640,15 +640,15 @@
 
   // Initializes this object; makes a copy of the input array if
   // 'relation' is kCopy.
-  void Init(const Element* array, size_t size, RelationToSource relation) {
+  void Init(const Element* array, size_t a_size, RelationToSource relation) {
     if (relation == kReference) {
       array_ = array;
     } else {
-      Element* const copy = new Element[size];
-      CopyArray(array, size, copy);
+      Element* const copy = new Element[a_size];
+      CopyArray(array, a_size, copy);
       array_ = copy;
     }
-    size_ = size;
+    size_ = a_size;
     relation_to_source_ = relation;
   }
 
diff --git a/scons/SConscript b/scons/SConscript
index 73c5b91..7c2bfbf 100644
--- a/scons/SConscript
+++ b/scons/SConscript
@@ -105,9 +105,19 @@
 gtest_common_exports = SConscript(GTEST_DIR + '/scons/SConscript.common')
 EnvCreator = gtest_common_exports['EnvCreator']
 
-# TODO(vladl@google.com): restore warnings as errors once all warnings are fixed
-# in gMock.
-env = EnvCreator.Create(env, EnvCreator.WarningOk)
+env = env.Clone()
+if env['PLATFORM'] == 'win32':
+  env.Append(CCFLAGS=[
+      '-wd4127',  # Disables warning "conditional expression is constant",
+                  # triggered by VC 8.0's own STL header <list>.
+      '-wd4702',  # Disables warning "unreachable code", triggered by VC
+                  # 7.1's own STL header <xtree>.
+      '-wd4675',  # Disables warning "resolved overload was found by
+                  # argument-dependent lookup" generated by VC 7.1.
+                  # It just says that VC 7.1 fixed a bug in earlier
+                  # versions of VC so the code behavior will be
+                  # different than compiled with VC 6.0, for example.
+      ])
 
 # Note: The relative paths in SConscript files are relative to the location
 # of the SConscript file itself. To make a path relative to the location of
diff --git a/src/gmock-internal-utils.cc b/src/gmock-internal-utils.cc
index 196ec74..4c51ec0 100644
--- a/src/gmock-internal-utils.cc
+++ b/src/gmock-internal-utils.cc
@@ -64,7 +64,7 @@
     if (isalnum(*p)) {
       if (starts_new_word && result != "")
         result += ' ';
-      result += tolower(*p);
+      result += static_cast<char>(tolower(*p));
     }
   }
   return result;
diff --git a/src/gmock-spec-builders.cc b/src/gmock-spec-builders.cc
index edd60fe..02a3227 100644
--- a/src/gmock-spec-builders.cc
+++ b/src/gmock-spec-builders.cc
@@ -56,12 +56,12 @@
 Mutex g_gmock_mutex(Mutex::NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX);
 
 // Constructs an ExpectationBase object.
-ExpectationBase::ExpectationBase(const char* file,
-                                 int line,
-                                 const string& source_text)
-    : file_(file),
-      line_(line),
-      source_text_(source_text),
+ExpectationBase::ExpectationBase(const char* a_file,
+                                 int a_line,
+                                 const string& a_source_text)
+    : file_(a_file),
+      line_(a_line),
+      source_text_(a_source_text),
       cardinality_specified_(false),
       cardinality_(Exactly(1)),
       call_count_(0),
@@ -73,9 +73,9 @@
 
 // Explicitly specifies the cardinality of this expectation.  Used by
 // the subclasses to implement the .Times() clause.
-void ExpectationBase::SpecifyCardinality(const Cardinality& cardinality) {
+void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
   cardinality_specified_ = true;
-  cardinality_ = cardinality;
+  cardinality_ = a_cardinality;
 }
 
 // Retires all pre-requisites of this expectation.
@@ -427,8 +427,8 @@
 Expectation::Expectation() {}
 
 Expectation::Expectation(
-    const internal::linked_ptr<internal::ExpectationBase>& expectation_base)
-    : expectation_base_(expectation_base) {}
+    const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base)
+    : expectation_base_(an_expectation_base) {}
 
 Expectation::~Expectation() {}
 
diff --git a/test/gmock-actions_test.cc b/test/gmock-actions_test.cc
index ea3c310..a2c6fe1 100644
--- a/test/gmock-actions_test.cc
+++ b/test/gmock-actions_test.cc
@@ -95,26 +95,26 @@
 // Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a
 // built-in numeric type.
 TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
-  EXPECT_EQ(0, BuiltInDefaultValue<unsigned char>::Get());
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());
 #if GMOCK_HAS_SIGNED_WCHAR_T_
-  EXPECT_EQ(0, BuiltInDefaultValue<unsigned wchar_t>::Get());
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned wchar_t>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<signed wchar_t>::Get());
 #endif
 #if GMOCK_WCHAR_T_IS_NATIVE_
   EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
 #endif
-  EXPECT_EQ(0, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get());  // NOLINT
   EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get());  // NOLINT
   EXPECT_EQ(0, BuiltInDefaultValue<short>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<unsigned int>::Get());
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
-  EXPECT_EQ(0, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT
+  EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get());  // NOLINT
   EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get());  // NOLINT
   EXPECT_EQ(0, BuiltInDefaultValue<long>::Get());  // NOLINT
-  EXPECT_EQ(0, BuiltInDefaultValue<UInt64>::Get());
+  EXPECT_EQ(0U, BuiltInDefaultValue<UInt64>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<Int64>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
   EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
@@ -517,11 +517,13 @@
 // gmock-actions.h for more information.
 class FromType {
  public:
-  FromType(bool* converted) : converted_(converted) {}
+  FromType(bool* is_converted) : converted_(is_converted) {}
   bool* converted() const { return converted_; }
 
  private:
   bool* const converted_;
+
+  GTEST_DISALLOW_ASSIGN_(FromType);
 };
 
 class ToType {
@@ -588,8 +590,13 @@
 
 class MockClass {
  public:
+  MockClass() {}
+
   MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT
   MOCK_METHOD0(Foo, MyClass());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
 };
 
 // Tests that DoDefault() returns the built-in default value for the
@@ -615,7 +622,7 @@
 // Tests that using DoDefault() inside a composite action leads to a
 // run-time error.
 
-void VoidFunc(bool flag) {}
+void VoidFunc(bool /* flag */) {}
 
 TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
   MockClass mock;
@@ -801,7 +808,7 @@
 
 const char* Plus1(const char* s) { return s + 1; }
 
-void VoidUnary(int n) { g_done = true; }
+void VoidUnary(int /* n */) { g_done = true; }
 
 bool ByConstRef(const std::string& s) { return s == "Hi"; }
 
@@ -870,7 +877,7 @@
   EXPECT_EQ(1, a.Perform(make_tuple(2)));
 
   // As an action that takes two arguments.
-  Action<short(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
+  Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
   EXPECT_EQ(1, a2.Perform(make_tuple(2, 3.5)));
 
   // As an action that returns void.
@@ -887,7 +894,7 @@
   EXPECT_EQ(2, a.Perform(make_tuple()));
 
   // As an action that takes three arguments.
-  Action<short(int, double, char)> a2 =  // NOLINT
+  Action<int(int, double, char)> a2 =  // NOLINT
       InvokeWithoutArgs(NullaryFunctor());
   EXPECT_EQ(2, a2.Perform(make_tuple(3, 3.5, 'a')));
 
@@ -928,7 +935,7 @@
 
 // Tests using IgnoreResult() on an action that returns a class type.
 
-MyClass ReturnMyClass(double x) {
+MyClass ReturnMyClass(double /* x */) {
   g_done = true;
   return MyClass();
 }
diff --git a/test/gmock-cardinalities_test.cc b/test/gmock-cardinalities_test.cc
index f3f1e10..f6a9491 100644
--- a/test/gmock-cardinalities_test.cc
+++ b/test/gmock-cardinalities_test.cc
@@ -52,7 +52,11 @@
 
 class MockFoo {
  public:
+  MockFoo() {}
   MOCK_METHOD0(Bar, int());  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
 };
 
 // Tests that Cardinality objects can be default constructed.
@@ -398,7 +402,9 @@
   }
 
   // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const { return false; }
+  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
+    return false;
+  }
 
   // Describes self to an ostream.
   virtual void DescribeTo(::std::ostream* ss) const {
diff --git a/test/gmock-generated-actions_test.cc b/test/gmock-generated-actions_test.cc
index 2e6fa0b..3c076d7 100644
--- a/test/gmock-generated-actions_test.cc
+++ b/test/gmock-generated-actions_test.cc
@@ -63,6 +63,10 @@
 using testing::Unused;
 using testing::WithArgs;
 
+// For suppressing compiler warnings on conversion possibly losing precision.
+inline short Short(short n) { return n; }  // NOLINT
+inline char Char(char ch) { return ch; }
+
 // Sample functions and functors for testing various actions.
 int Nullary() { return 1; }
 
@@ -242,7 +246,7 @@
 // Tests using InvokeArgument with a function that takes a pointer argument.
 TEST(InvokeArgumentTest, ByPointerFunction) {
   Action<const char*(const char*(*)(const char* input, short n))> a =  // NOLINT
-      InvokeArgument<0>(static_cast<const char*>("Hi"), 1);
+      InvokeArgument<0>(static_cast<const char*>("Hi"), Short(1));
   EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
 }
 
@@ -250,7 +254,7 @@
 // by passing it a C-string literal.
 TEST(InvokeArgumentTest, FunctionWithCStringLiteral) {
   Action<const char*(const char*(*)(const char* input, short n))> a =  // NOLINT
-      InvokeArgument<0>("Hi", 1);
+      InvokeArgument<0>("Hi", Short(1));
   EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
 }
 
@@ -286,17 +290,17 @@
 
 // Tests using WithArgs with an action that takes 2 arguments.
 TEST(WithArgsTest, TwoArgs) {
-  Action<const char*(const char* s, double x, int n)> a =
+  Action<const char*(const char* s, double x, short n)> a =
       WithArgs<0, 2>(Invoke(Binary));
   const char s[] = "Hello";
-  EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, 2)));
+  EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, Short(2))));
 }
 
 // Tests using WithArgs with an action that takes 3 arguments.
 TEST(WithArgsTest, ThreeArgs) {
   Action<int(int, double, char, short)> a =  // NOLINT
       WithArgs<0, 2, 3>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, 20, 3)));
+  EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, Char(20), Short(3))));
 }
 
 // Tests using WithArgs with an action that takes 4 arguments.
@@ -379,7 +383,7 @@
 TEST(WithArgsTest, Identity) {
   Action<int(int x, char y, short z)> a =  // NOLINT
       WithArgs<0, 1, 2>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(100, 20, 3)));
+  EXPECT_EQ(123, a.Perform(make_tuple(100, Char(20), Short(3))));
 }
 
 // Tests using WithArgs with repeated arguments.
@@ -394,14 +398,14 @@
   Action<const char*(short n, const char* input)> a =  // NOLINT
       WithArgs<1, 0>(Invoke(Binary));
   const char s[] = "Hello";
-  EXPECT_EQ(s + 2, a.Perform(make_tuple(2, CharPtr(s))));
+  EXPECT_EQ(s + 2, a.Perform(make_tuple(Short(2), CharPtr(s))));
 }
 
 // Tests using WithArgs with compatible, but not identical, argument types.
 TEST(WithArgsTest, ArgsOfCompatibleTypes) {
-  Action<long(short x, int y, double z, char c)> a =  // NOLINT
+  Action<long(short x, char y, double z, char c)> a =  // NOLINT
       WithArgs<0, 1, 3>(Invoke(Ternary));
-  EXPECT_EQ(123, a.Perform(make_tuple(100, 20, 5.6, 3)));
+  EXPECT_EQ(123, a.Perform(make_tuple(Short(100), Char(20), 5.6, Char(3))));
 }
 
 // Tests using WithArgs with an action that returns void.
@@ -583,6 +587,16 @@
   EXPECT_EQ('g', g);
 }
 
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4100)
+#endif
+
 // Tests the ACTION*() macro family.
 
 // Tests that ACTION() can define an action that doesn't reference the
@@ -633,7 +647,7 @@
 TEST(ActionMacroTest, CanReferenceArgumentTuple) {
   Action<int(int, char, int*)> a1 = Sum2();
   int dummy = 0;
-  EXPECT_EQ(11, a1.Perform(make_tuple(5, static_cast<char>(6), &dummy)));
+  EXPECT_EQ(11, a1.Perform(make_tuple(5, Char(6), &dummy)));
 }
 
 // Tests that the body of ACTION() can reference the mock function
@@ -731,7 +745,7 @@
 
 TEST(ActionPMacroTest, CanReferenceArgumentAndParameterTypes) {
   Action<int(char m, bool t)> a1 = TypedPlus(9);
-  EXPECT_EQ(10, a1.Perform(make_tuple(static_cast<char>(1), true)));
+  EXPECT_EQ(10, a1.Perform(make_tuple(Char(1), true)));
 }
 
 // Tests that a parameterized action can be used in any mock function
@@ -851,7 +865,7 @@
 ACTION_P2(PadArgument, prefix, suffix) {
   // The following lines promote the two parameters to desired types.
   std::string prefix_str(prefix);
-  char suffix_char(suffix);
+  char suffix_char = static_cast<char>(suffix);
   return prefix_str + arg0 + suffix_char;
 }
 
@@ -1078,7 +1092,7 @@
   explicit BoolResetter(bool* value) : value_(value) {}
   ~BoolResetter() { *value_ = false; }
  private:
-  bool* const value_;
+  bool* value_;
 };
 
 TEST(ActionTemplateTest, WorksForIntegralTemplateParams) {
@@ -1190,5 +1204,9 @@
   EXPECT_EQ(12345, a4.Perform(make_tuple()));
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 }  // namespace gmock_generated_actions_test
 }  // namespace testing
diff --git a/test/gmock-generated-function-mockers_test.cc b/test/gmock-generated-function-mockers_test.cc
index 1ce8c45..5d839c4 100644
--- a/test/gmock-generated-function-mockers_test.cc
+++ b/test/gmock-generated-function-mockers_test.cc
@@ -114,6 +114,8 @@
 
 class MockFoo : public FooInterface {
  public:
+  MockFoo() {}
+
   // Makes sure that a mock function parameter can be named.
   MOCK_METHOD1(VoidReturning, void(int n));  // NOLINT
 
@@ -149,6 +151,9 @@
       const string& k));
   MOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTConst, char(int));
 #endif  // GTEST_OS_WINDOWS
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
 };
 
 class FunctionMockerTest : public testing::Test {
@@ -305,7 +310,12 @@
 
 class MockB {
  public:
+  MockB() {}
+
   MOCK_METHOD0(DoB, void());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
 };
 
 // Tests that functions with no EXPECT_CALL() ruls can be called any
@@ -345,10 +355,15 @@
 template <typename T>
 class MockStack : public StackInterface<T> {
  public:
+  MockStack() {}
+
   MOCK_METHOD1_T(Push, void(const T& elem));
   MOCK_METHOD0_T(Pop, void());
   MOCK_CONST_METHOD0_T(GetSize, int());  // NOLINT
   MOCK_CONST_METHOD0_T(GetTop, const T&());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack);
 };
 
 // Tests that template mock works.
@@ -393,10 +408,15 @@
 template <typename T>
 class MockStackWithCallType : public StackInterfaceWithCallType<T> {
  public:
+  MockStackWithCallType() {}
+
   MOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Push, void(const T& elem));
   MOCK_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Pop, void());
   MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetSize, int());
   MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType);
 };
 
 // Tests that template mock with calltype works.
@@ -430,7 +450,12 @@
 
 class MockOverloadedOnArgNumber {
  public:
+  MockOverloadedOnArgNumber() {}
+
   MY_MOCK_METHODS1_;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
 };
 
 TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
@@ -450,7 +475,12 @@
 
 class MockOverloadedOnConstness {
  public:
+  MockOverloadedOnConstness() {}
+
   MY_MOCK_METHODS2_;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
 };
 
 TEST(OverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
diff --git a/test/gmock-generated-matchers_test.cc b/test/gmock-generated-matchers_test.cc
index 19024d0..4141305 100644
--- a/test/gmock-generated-matchers_test.cc
+++ b/test/gmock-generated-matchers_test.cc
@@ -223,8 +223,9 @@
       *os << "is " << -diff << " less than " << rhs_;
     }
   }
+
  private:
-  const int rhs_;
+  int rhs_;
 };
 
 Matcher<int> GreaterThan(int n) {
@@ -411,7 +412,7 @@
   };
 
   vector<list<char> > nested;
-  for (int i = 0; i < GMOCK_ARRAY_SIZE_(strings); i++) {
+  for (size_t i = 0; i < GMOCK_ARRAY_SIZE_(strings); i++) {
     nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i])));
   }
 
@@ -446,7 +447,12 @@
 
 class NativeArrayPassedAsPointerAndSize {
  public:
+  NativeArrayPassedAsPointerAndSize() {}
+
   MOCK_METHOD2(Helper, void(int* array, int size));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize);
 };
 
 TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
@@ -550,7 +556,10 @@
 // Tests that the description string supplied to MATCHER() must be
 // valid.
 
-MATCHER(HasBadDescription, "Invalid%") { return true; }
+MATCHER(HasBadDescription, "Invalid%") {
+  // Uses arg to suppress "unused parameter" warning.
+  return arg==arg;
+}
 
 TEST(MatcherMacroTest,
      CreatingMatcherWithBadDescriptionGeneratesNonfatalFailure) {
@@ -560,7 +569,7 @@
       "use \"%%\" instead of \"%\" to print \"%\".");
 }
 
-MATCHER(HasGoodDescription, "good") { return true; }
+MATCHER(HasGoodDescription, "good") { return arg==arg; }
 
 TEST(MatcherMacroTest, AcceptsValidDescription) {
   const Matcher<int> m = HasGoodDescription();
@@ -642,7 +651,7 @@
 }
 
 
-MATCHER_P(HasGoodDescription1, n, "good %(n)s") { return true; }
+MATCHER_P(HasGoodDescription1, n, "good %(n)s") { return arg==arg; }
 
 TEST(MatcherPMacroTest, AcceptsValidDescription) {
   const Matcher<int> m = HasGoodDescription1(5);
@@ -709,7 +718,7 @@
 
 MATCHER_P2(HasComplexDescription, foo, bar,
            "is as complex as %(foo)s %(bar)s (i.e. %(*)s or %%%(foo)s!)") {
-  return true;
+  return arg==arg;
 }
 
 TEST(MatcherPnMacroTest, AcceptsValidDescription) {
@@ -861,7 +870,7 @@
 MATCHER_P2(EqConcat, prefix, suffix, "") {
   // The following lines promote the two parameters to desired types.
   std::string prefix_str(prefix);
-  char suffix_char(suffix);
+  char suffix_char = static_cast<char>(suffix);
   return arg == prefix_str + suffix_char;
 }
 
diff --git a/test/gmock-internal-utils_test.cc b/test/gmock-internal-utils_test.cc
index ac3b2dd..7dd8311 100644
--- a/test/gmock-internal-utils_test.cc
+++ b/test/gmock-internal-utils_test.cc
@@ -819,7 +819,7 @@
 TEST(NativeArrayTest, ConstructorFromArrayWorks) {
   const int a[3] = { 0, 1, 2 };
   NativeArray<int> na(a, 3, kReference);
-  EXPECT_EQ(3, na.size());
+  EXPECT_EQ(3U, na.size());
   EXPECT_EQ(a, na.begin());
 }
 
@@ -849,7 +849,7 @@
 TEST(NativeArrayTest, MethodsWork) {
   const int a[3] = { 0, 1, 2 };
   NativeArray<int> na(a, 3, kCopy);
-  ASSERT_EQ(3, na.size());
+  ASSERT_EQ(3U, na.size());
   EXPECT_EQ(3, na.end() - na.begin());
 
   NativeArray<int>::const_iterator it = na.begin();
@@ -875,7 +875,7 @@
 TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
   const char a[2][3] = { "hi", "lo" };
   NativeArray<char[3]> na(a, 2, kReference);
-  ASSERT_EQ(2, na.size());
+  ASSERT_EQ(2U, na.size());
   EXPECT_EQ(a, na.begin());
 }
 
@@ -910,11 +910,11 @@
 
   int a1[3] = { 0, 1, 2 };
   NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
-  EXPECT_EQ(3, a2.size());
+  EXPECT_EQ(3U, a2.size());
   EXPECT_EQ(a1, a2.begin());
 
   const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
-  ASSERT_EQ(3, a3.size());
+  ASSERT_EQ(3U, a3.size());
   EXPECT_EQ(0, a3.begin()[0]);
   EXPECT_EQ(1, a3.begin()[1]);
   EXPECT_EQ(2, a3.begin()[2]);
@@ -937,12 +937,12 @@
   const int* const p1 = a1;
   NativeArray<int> a2 = StlContainerView<tuple<const int*, int> >::
       ConstReference(make_tuple(p1, 3));
-  EXPECT_EQ(3, a2.size());
+  EXPECT_EQ(3U, a2.size());
   EXPECT_EQ(a1, a2.begin());
 
   const NativeArray<int> a3 = StlContainerView<tuple<int*, size_t> >::
       Copy(make_tuple(static_cast<int*>(a1), 3));
-  ASSERT_EQ(3, a3.size());
+  ASSERT_EQ(3U, a3.size());
   EXPECT_EQ(0, a3.begin()[0]);
   EXPECT_EQ(1, a3.begin()[1]);
   EXPECT_EQ(2, a3.begin()[2]);
diff --git a/test/gmock-matchers_test.cc b/test/gmock-matchers_test.cc
index 919ce65..907749d 100644
--- a/test/gmock-matchers_test.cc
+++ b/test/gmock-matchers_test.cc
@@ -152,8 +152,9 @@
       *os << "is " << -diff << " less than " << rhs_;
     }
   }
+
  private:
-  const int rhs_;
+  int rhs_;
 };
 
 Matcher<int> GreaterThan(int n) {
@@ -335,7 +336,7 @@
  public:
   // An int can be statically (although not implicitly) cast to a
   // IntValue.
-  explicit IntValue(int value) : value_(value) {}
+  explicit IntValue(int a_value) : value_(a_value) {}
 
   int value() const { return value_; }
  private:
@@ -560,7 +561,7 @@
  public:
   Unprintable() : c_('a') {}
 
-  bool operator==(const Unprintable& rhs) { return true; }
+  bool operator==(const Unprintable& /* rhs */) { return true; }
  private:
   char c_;
 };
@@ -606,7 +607,7 @@
 // "undefined referece".
 template <typename T>
 struct Type {
-  static bool IsTypeOf(const T& v) { return true; }
+  static bool IsTypeOf(const T& /* v */) { return true; }
 
   template <typename T2>
   static void IsTypeOf(T2 v);
@@ -1861,8 +1862,9 @@
   explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
 
   bool operator()(int n) const { return n > threshold_; }
+
  private:
-  const int threshold_;
+  int threshold_;
 };
 
 // For testing Truly().
@@ -1959,7 +1961,12 @@
 
 class AllArgsHelper {
  public:
+  AllArgsHelper() {}
+
   MOCK_METHOD2(Helper, int(char x, int y));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper);
 };
 
 TEST(AllArgsTest, WorksInWithClause) {
@@ -2384,7 +2391,7 @@
 // An uncopyable class.
 class Uncopyable {
  public:
-  explicit Uncopyable(int value) : value_(value) {}
+  explicit Uncopyable(int a_value) : value_(a_value) {}
 
   int value() const { return value_; }
  private:
@@ -2405,11 +2412,17 @@
   const double y;  // A const field.
   Uncopyable z;    // An uncopyable field.
   const char* p;   // A pointer field.
+
+ private:
+  GTEST_DISALLOW_ASSIGN_(AStruct);
 };
 
 // A derived struct for testing Field().
 struct DerivedStruct : public AStruct {
   char ch;
+
+ private:
+  GTEST_DISALLOW_ASSIGN_(DerivedStruct);
 };
 
 // Tests that Field(&Foo::field, ...) works when field is non-const.
@@ -2943,7 +2956,7 @@
 
 class DivisibleByImpl {
  public:
-  explicit DivisibleByImpl(int divider) : divider_(divider) {}
+  explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {}
 
   template <typename T>
   bool Matches(const T& n) const {
@@ -2958,7 +2971,7 @@
     *os << "is not divisible by " << divider_;
   }
 
-  void set_divider(int divider) { divider_ = divider; }
+  void set_divider(int a_divider) { divider_ = a_divider; }
   int divider() const { return divider_; }
 
  private:
@@ -3021,7 +3034,7 @@
 
 class NotCopyable {
  public:
-  explicit NotCopyable(int value) : value_(value) {}
+  explicit NotCopyable(int a_value) : value_(a_value) {}
 
   int value() const { return value_; }
 
diff --git a/test/gmock-more-actions_test.cc b/test/gmock-more-actions_test.cc
index f5dab5b..b3b17d3 100644
--- a/test/gmock-more-actions_test.cc
+++ b/test/gmock-more-actions_test.cc
@@ -65,6 +65,10 @@
 using testing::WithArg;
 using testing::WithoutArgs;
 
+// For suppressing compiler warnings on conversion possibly losing precision.
+inline short Short(short n) { return n; }  // NOLINT
+inline char Char(char ch) { return ch; }
+
 // Sample functions and functors for testing Invoke() and etc.
 int Nullary() { return 1; }
 
@@ -85,7 +89,7 @@
 
 const char* Plus1(const char* s) { return s + 1; }
 
-void VoidUnary(int n) { g_done = true; }
+void VoidUnary(int /* n */) { g_done = true; }
 
 bool ByConstRef(const string& s) { return s == "Hi"; }
 
@@ -239,13 +243,13 @@
 TEST(InvokeTest, Binary) {
   Action<const char*(const char*, short)> a = Invoke(Binary);  // NOLINT
   const char* p = "Hello";
-  EXPECT_EQ(p + 2, a.Perform(make_tuple(p, 2)));
+  EXPECT_EQ(p + 2, a.Perform(make_tuple(p, Short(2))));
 }
 
 // Tests using Invoke() with a ternary function.
 TEST(InvokeTest, Ternary) {
   Action<int(int, char, short)> a = Invoke(Ternary);  // NOLINT
-  EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', 3)));
+  EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', Short(3))));
 }
 
 // Tests using Invoke() with a 4-argument function.
@@ -340,14 +344,14 @@
 
 // Tests using Invoke() with a functor.
 TEST(InvokeTest, Functor) {
-  Action<int(short, char)> a = Invoke(plus<short>());  // NOLINT
-  EXPECT_EQ(3, a.Perform(make_tuple(1, 2)));
+  Action<long(long, int)> a = Invoke(plus<long>());  // NOLINT
+  EXPECT_EQ(3L, a.Perform(make_tuple(1, 2)));
 }
 
 // Tests using Invoke(f) as an action of a compatible type.
 TEST(InvokeTest, FunctionWithCompatibleType) {
   Action<long(int, short, char, bool)> a = Invoke(SumOf4);  // NOLINT
-  EXPECT_EQ(4321, a.Perform(make_tuple(4000, 300, 20, true)));
+  EXPECT_EQ(4321, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
 }
 
 // Tests using Invoke() with an object pointer and a method pointer.
@@ -378,7 +382,7 @@
 TEST(InvokeMethodTest, Ternary) {
   Foo foo;
   Action<int(int, bool, char)> a = Invoke(&foo, &Foo::Ternary);  // NOLINT
-  EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, 1)));
+  EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, Char(1))));
 }
 
 // Tests using Invoke() with a 4-argument method.
@@ -457,7 +461,7 @@
   Foo foo;
   Action<long(int, short, char, bool)> a =  // NOLINT
       Invoke(&foo, &Foo::SumOf4);
-  EXPECT_EQ(4444, a.Perform(make_tuple(4000, 300, 20, true)));
+  EXPECT_EQ(4444, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
 }
 
 // Tests using WithoutArgs with an action that takes no argument.
diff --git a/test/gmock-nice-strict_test.cc b/test/gmock-nice-strict_test.cc
index faf0145..1d36e03 100644
--- a/test/gmock-nice-strict_test.cc
+++ b/test/gmock-nice-strict_test.cc
@@ -40,7 +40,12 @@
 // clash with ::testing::Mock.
 class Mock {
  public:
+  Mock() {}
+
   MOCK_METHOD0(DoThis, void());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
 };
 
 namespace testing {
@@ -64,10 +69,14 @@
 
 class MockFoo : public Foo {
  public:
+  MockFoo() {}
   void Delete() { delete this; }
 
   MOCK_METHOD0(DoThis, void());
   MOCK_METHOD1(DoThat, int(bool flag));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
 };
 
 class MockBar {
@@ -89,6 +98,8 @@
 
  private:
   string str_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar);
 };
 
 // TODO(wan@google.com): find a way to re-enable these tests.
diff --git a/test/gmock-port_test.cc b/test/gmock-port_test.cc
index b2afb93..054313b 100644
--- a/test/gmock-port_test.cc
+++ b/test/gmock-port_test.cc
@@ -85,7 +85,7 @@
   }
 
  private:
-  bool* const converted_;
+  bool* converted_;
 };
 
 TEST(ImplicitCastTest, CanUseNonConstCastOperator) {
@@ -104,7 +104,7 @@
   }
 
  private:
-  bool* const converted_;
+  bool* converted_;
 };
 
 TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) {
@@ -128,8 +128,8 @@
   }
 
  private:
-  bool* const converted_;
-  bool* const const_converted_;
+  bool* converted_;
+  bool* const_converted_;
 };
 
 TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) {
diff --git a/test/gmock-printers_test.cc b/test/gmock-printers_test.cc
index abfa923..0553e9c 100644
--- a/test/gmock-printers_test.cc
+++ b/test/gmock-printers_test.cc
@@ -77,7 +77,7 @@
   virtual ~StreamableInGlobal() {}
 };
 
-inline void operator<<(::std::ostream& os, const StreamableInGlobal& x) {
+inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) {
   os << "StreamableInGlobal";
 }
 
@@ -107,7 +107,7 @@
 template <typename T>
 class PrintableViaPrintToTemplate {
  public:
-  explicit PrintableViaPrintToTemplate(const T& value) : value_(value) {}
+  explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_value) {}
 
   const T& value() const { return value_; }
  private:
@@ -440,7 +440,7 @@
 
 // Tests printing (non-member) function pointers.
 
-void MyFunction(int n) {}
+void MyFunction(int /* n */) {}
 
 TEST(PrintPointerTest, NonMemberFunctionPointer) {
   // We cannot directly cast &MyFunction to const void* because the
@@ -464,7 +464,7 @@
  public:
   virtual ~Foo() {}
   int MyMethod(char x) { return x + 1; }
-  virtual char MyVirtualMethod(int n) { return 'a'; }
+  virtual char MyVirtualMethod(int /* n */) { return 'a'; }
 
   int value;
 };
@@ -603,7 +603,7 @@
 template <typename Char, typename CharTraits>
 std::basic_ostream<Char, CharTraits>& operator<<(
     std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreaming& a) {
+    const AllowsGenericStreaming& /* a */) {
   return os << "AllowsGenericStreaming";
 }
 
@@ -620,7 +620,7 @@
 template <typename Char, typename CharTraits, typename T>
 std::basic_ostream<Char, CharTraits>& operator<<(
     std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreamingTemplate<T>& a) {
+    const AllowsGenericStreamingTemplate<T>& /* a */) {
   return os << "AllowsGenericStreamingTemplate";
 }
 
@@ -641,7 +641,7 @@
 template <typename Char, typename CharTraits, typename T>
 std::basic_ostream<Char, CharTraits>& operator<<(
     std::basic_ostream<Char, CharTraits>& os,
-    const AllowsGenericStreamingAndImplicitConversionTemplate<T>& a) {
+    const AllowsGenericStreamingAndImplicitConversionTemplate<T>& /* a */) {
   return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
 }
 
diff --git a/test/gmock-spec-builders_test.cc b/test/gmock-spec-builders_test.cc
index 5fd9711..c1e7738 100644
--- a/test/gmock-spec-builders_test.cc
+++ b/test/gmock-spec-builders_test.cc
@@ -97,16 +97,26 @@
 
 class MockA {
  public:
+  MockA() {}
+
   MOCK_METHOD1(DoA, void(int n));  // NOLINT
   MOCK_METHOD1(ReturnResult, Result(int n));  // NOLINT
   MOCK_METHOD2(Binary, bool(int x, int y));  // NOLINT
   MOCK_METHOD2(ReturnInt, int(int x, int y));  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockA);
 };
 
 class MockB {
  public:
+  MockB() {}
+
   MOCK_CONST_METHOD0(DoB, int());  // NOLINT
   MOCK_METHOD1(DoB, int(int n));  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
 };
 
 // Tests that EXPECT_CALL and ON_CALL compile in a presence of macro
@@ -123,7 +133,12 @@
 };
 class MockCC : public CC {
  public:
+  MockCC() {}
+
   MOCK_METHOD0(Method, int());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockCC);
 };
 
 // Tests that a method with expanded name compiles.
@@ -1617,8 +1632,19 @@
 
 // Tests that it's OK to delete a mock object itself in its action.
 
+// Suppresses warning on unreferenced formal parameter in MSVC with
+// -W4.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4100)
+#endif
+
 ACTION_P(Delete, ptr) { delete ptr; }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
   MockA* const a = new MockA;
   EXPECT_CALL(*a, DoA(_)).WillOnce(Delete(a));
@@ -1691,7 +1717,9 @@
   }
 
   // Returns true iff call_count calls will saturate this cardinality.
-  virtual bool IsSaturatedByCallCount(int call_count) const { return false; }
+  virtual bool IsSaturatedByCallCount(int /* call_count */) const {
+    return false;
+  }
 
   // Describes self to an ostream.
   virtual void DescribeTo(::std::ostream* os) const {
@@ -1740,9 +1768,14 @@
 
 class MockC {
  public:
+  MockC() {}
+
   MOCK_METHOD6(VoidMethod, void(bool cond, int n, string s, void* p,
                                 const Printable& x, Unprintable y));
   MOCK_METHOD0(NonVoidMethod, int());  // NOLINT
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC);
 };
 
 // TODO(wan@google.com): find a way to re-enable these tests.
@@ -1935,7 +1968,12 @@
 
 class LogTestHelper {
  public:
+  LogTestHelper() {}
+
   MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
 };
 
 class GMockLogTest : public ::testing::Test {
diff --git a/test/gmock_leak_test_.cc b/test/gmock_leak_test_.cc
index 157bd7e..24dfc1f 100644
--- a/test/gmock_leak_test_.cc
+++ b/test/gmock_leak_test_.cc
@@ -48,7 +48,12 @@
 
 class MockFoo : public FooInterface {
  public:
+  MockFoo() {}
+
   MOCK_METHOD0(DoThis, void());
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
 };
 
 TEST(LeakTest, LeakedMockWithExpectCallCausesFailureWhenLeakCheckingIsEnabled) {
diff --git a/test/gmock_link_test.h b/test/gmock_link_test.h
index 40554bf..d963590 100644
--- a/test/gmock_link_test.h
+++ b/test/gmock_link_test.h
@@ -206,6 +206,8 @@
 
 class Mock: public Interface {
  public:
+  Mock() {}
+
   MOCK_METHOD1(VoidFromString, void(char* str));
   MOCK_METHOD1(StringFromString, char*(char* str));
   MOCK_METHOD1(IntFromString, int(char* str));
@@ -215,6 +217,9 @@
   MOCK_METHOD1(VoidFromFloat, void(float n));
   MOCK_METHOD1(VoidFromDouble, void(double n));
   MOCK_METHOD1(VoidFromVector, void(const std::vector<int>& v));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
 };
 
 class InvokeHelper {
@@ -229,7 +234,7 @@
 
 class FieldHelper {
  public:
-  FieldHelper(int field) : field_(field) {}
+  FieldHelper(int a_field) : field_(a_field) {}
   int field() const { return field_; }
   int field_;  // NOLINT -- need external access to field_ to test
                //           the Field matcher.
@@ -410,6 +415,16 @@
 }
 #endif  // GTEST_HAS_EXCEPTIONS
 
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4100)
+#endif
+
 // Tests the linkage of actions created using ACTION macro.
 namespace {
 ACTION(Return1) { return 1; }
@@ -441,6 +456,10 @@
 }
 }
 
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 TEST(LinkTest, TestActionP2Macro) {
   Mock mock;
   char ch = 'x';
diff --git a/test/gmock_output_test_.cc b/test/gmock_output_test_.cc
index c33dc6f..24c9b38 100644
--- a/test/gmock_output_test_.cc
+++ b/test/gmock_output_test_.cc
@@ -49,9 +49,14 @@
 
 class MockFoo {
  public:
+  MockFoo() {}
+
   MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
   MOCK_METHOD2(Bar2, bool(int x, int y));
   MOCK_METHOD2(Bar3, void(int x, int y));
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
 };
 
 class GMockOutputTest : public testing::Test {