diff --git a/src/bin/align-text.cc b/src/bin/align-text.cc
index 04172f3b5f3..6d638871e1a 100644
--- a/src/bin/align-text.cc
+++ b/src/bin/align-text.cc
@@ -26,10 +26,9 @@ bool IsNotToken(const std::string &token) {
   return ! kaldi::IsToken(token);
 }
 
-int main(int argc, char *argv[]) {
-  using namespace kaldi;
-  typedef kaldi::int32 int32;
+namespace kaldi {
 
+int main(int argc, char *argv[]) {
   try {
     const char *usage =
         "Computes alignment between two sentences with the same key in the\n"
@@ -133,3 +132,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/bin/extract-ctx.cc b/src/bin/extract-ctx.cc
index d3c36119581..2e6734d15e4 100644
--- a/src/bin/extract-ctx.cc
+++ b/src/bin/extract-ctx.cc
@@ -29,7 +29,7 @@
 #include "tree/build-tree-questions.h"
 #include "fst/fstlib.h"
 
-using namespace kaldi;
+namespace kaldi {
 
 using std::vector;
 
@@ -212,4 +212,9 @@ int main(int argc, char *argv[]) {
   }
 }
 
+}  //namespace kaldi
 
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/bin/phones-to-prons.cc b/src/bin/phones-to-prons.cc
index 2d3caddf78d..c420188fc00 100644
--- a/src/bin/phones-to-prons.cc
+++ b/src/bin/phones-to-prons.cc
@@ -26,6 +26,8 @@
 #include "fst/fstlib.h"
 #include "fstext/fstext-lib.h"
 
+namespace kaldi {
+
 // Create FST that accepts the phone sequence, with any number
 // of word-start and word-end symbol in between each phone. 
 void CreatePhonesAltFst(const std::vector<int32> &phones,
@@ -60,10 +62,8 @@ void CreatePhonesAltFst(const std::vector<int32> &phones,
 }
 
 int main(int argc, char *argv[]) {
-  using namespace kaldi;
   using fst::VectorFst;
   using fst::StdArc;
-  typedef kaldi::int32 int32;
   try {
     const char *usage =
         "Convert pairs of (phone-level, word-level) transcriptions to\n"
@@ -220,4 +220,9 @@ int main(int argc, char *argv[]) {
   }
 }
 
+}  //namespace kaldi
+
 
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/bin/post-to-phone-post.cc b/src/bin/post-to-phone-post.cc
index 92f67514a0f..5b6af2945a4 100644
--- a/src/bin/post-to-phone-post.cc
+++ b/src/bin/post-to-phone-post.cc
@@ -23,11 +23,10 @@
 #include "hmm/transition-model.h"
 #include "hmm/posterior.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;  
-
     const char *usage =
         "Convert posteriors to phone-level posteriors\n"
         "See also: post-to-pdf-post, post-to-weights, get-post-on-ali\n"
@@ -75,3 +74,9 @@ int main(int argc, char *argv[]) {
   }
 }
 
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/gmmbin/gmm-decode-nbest.cc b/src/gmmbin/gmm-decode-nbest.cc
index 815d29dff21..fe773e6b4ea 100644
--- a/src/gmmbin/gmm-decode-nbest.cc
+++ b/src/gmmbin/gmm-decode-nbest.cc
@@ -30,7 +30,7 @@
 #include "lat/kaldi-lattice.h" // for CompactLatticeArc
 #include "fstext/lattice-utils.h" // for ConvertLattice
 
-using namespace kaldi;
+namespace kaldi {
 
 fst::Fst<fst::StdArc> *ReadNetwork(std::string filename) {
   // read decoding network FST
@@ -67,8 +67,6 @@ fst::Fst<fst::StdArc> *ReadNetwork(std::string filename) {
 
 int main(int argc, char *argv[]) {
   try {
-    typedef kaldi::int32 int32;
-
     const char *usage =
       "Decode features using GMM-based model, producing N-best lattice output.\n"
       "Note: this program was mainly intended to validate the lattice generation\n"
@@ -245,4 +243,9 @@ int main(int argc, char *argv[]) {
   }
 }
 
+}  //namespace kaldi
+
 
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/kwsbin/generate-proxy-keywords.cc b/src/kwsbin/generate-proxy-keywords.cc
index 6067484276f..c37b0ee33e3 100644
--- a/src/kwsbin/generate-proxy-keywords.cc
+++ b/src/kwsbin/generate-proxy-keywords.cc
@@ -17,7 +17,6 @@
 // See the Apache 2 License for the specific language governing permissions and
 // limitations under the License.
 
-
 #include "base/kaldi-common.h"
 #include "util/common-utils.h"
 #include "fstext/fstext-utils.h"
@@ -53,15 +52,16 @@ bool PrintProxyFstPath(const VectorFst<StdArc> &proxy,
 }
 }
 
+using namespace fst;
+using kaldi::int32;
+using kaldi::uint64;
+using kaldi::BasicVectorHolder;
+using kaldi::ParseOptions;
+using kaldi::SequentialInt32VectorReader;
+using kaldi::TableWriter;
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    using namespace fst;
-    typedef kaldi::int32 int32;
-    typedef kaldi::uint64 uint64;
-    typedef StdArc::StateId StateId;
-    typedef StdArc::Weight Weight;
-
     const char *usage =
         "Convert the keywords into in-vocabulary words using the given phone\n"
         "level edit distance fst (E.fst). The large lexicon (L2.fst) and\n"
diff --git a/src/kwsbin/kws-index-union.cc b/src/kwsbin/kws-index-union.cc
index 5986318d630..08b4b9c0ab2 100644
--- a/src/kwsbin/kws-index-union.cc
+++ b/src/kwsbin/kws-index-union.cc
@@ -24,13 +24,17 @@
 #include "lat/kaldi-kws.h"
 #include "lat/kws-functions.h"
 
+using namespace fst;
+using kaldi::int32;
+using kaldi::uint64;
+using kaldi::KwsLexicographicArc;
+using kaldi::KwsLexicographicFst;
+using kaldi::ParseOptions;
+using kaldi::SequentialTableReader;
+using kaldi::TableWriter;
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    using namespace fst;
-    typedef kaldi::int32 int32;
-    typedef kaldi::uint64 uint64;
-
     const char *usage =
         "Take a union of the indexed lattices. The input index is in the T*T*T semiring and\n"
         "the output index is also in the T*T*T semiring. At the end of this program, encoded\n"
diff --git a/src/kwsbin/kws-search.cc b/src/kwsbin/kws-search.cc
index eafdade0818..b4df009ecf9 100644
--- a/src/kwsbin/kws-search.cc
+++ b/src/kwsbin/kws-search.cc
@@ -70,17 +70,25 @@ class VectorFstToKwsLexicographicFstMapper {
 
 }
 
+using namespace fst;
+using kaldi::int32;
+using kaldi::uint64;
+using kaldi::BasicVectorHolder;
+using kaldi::DecodeLabelUid;
+using kaldi::EncodeLabel;
+using kaldi::KwsLexicographicArc;
+using kaldi::KwsLexicographicFst;
+using kaldi::ParseOptions;
+using kaldi::RandomAccessTableReader;
+using kaldi::SequentialTableReader;
+using kaldi::TableWriter;
+using kaldi::VectorFstToKwsLexicographicFstMapper;
+
 int main(int argc, char *argv[]) {
+  typedef KwsLexicographicArc Arc;
+  typedef Arc::Weight Weight;
+  typedef Arc::StateId StateId;
   try {
-    using namespace kaldi;
-    using namespace fst;
-    typedef kaldi::int32 int32;
-    typedef kaldi::uint32 uint32;
-    typedef kaldi::uint64 uint64;
-    typedef KwsLexicographicArc Arc;
-    typedef Arc::Weight Weight;
-    typedef Arc::StateId StateId;
-
     const char *usage =
         "Search the keywords over the index. This program can be executed parallely, either\n"
         "on the index side or the keywords side; we use a script to combine the final search\n"
diff --git a/src/kwsbin/lattice-to-kws-index.cc b/src/kwsbin/lattice-to-kws-index.cc
index 81aa463df2e..cfc6edd5c4b 100644
--- a/src/kwsbin/lattice-to-kws-index.cc
+++ b/src/kwsbin/lattice-to-kws-index.cc
@@ -28,13 +28,32 @@
 #include "lat/kws-functions.h"
 #include "fstext/epsilon-property.h"
 
+using fst::VectorFst;
+using kaldi::int32;
+using kaldi::uint64;
+using kaldi::BaseFloat;
+using kaldi::ClusterLattice;
+using kaldi::CompactLattice;
+using kaldi::CompactLatticeStateTimes;
+using kaldi::CompactLatticeStateTimes;
+using kaldi::CreateFactorTransducer;
+using kaldi::DoFactorDisambiguation;
+using kaldi::DoFactorMerging;
+using kaldi::KwsLexicographicArc;
+using kaldi::KwsLexicographicFst;
+using kaldi::KwsProductFst;
+using kaldi::MaybeDoSanityCheck;
+using kaldi::OptimizeFactorTransducer;
+using kaldi::ParseOptions;
+using kaldi::RandomAccessInt32Reader;
+using kaldi::RandomAccessTableReader;
+using kaldi::RemoveLongSilences;
+using kaldi::SequentialCompactLatticeReader;
+using kaldi::SequentialTableReader;
+using kaldi::TableWriter;
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    using fst::VectorFst;
-    typedef kaldi::int32 int32;
-    typedef kaldi::uint64 uint64;
-
     const char *usage =
         "Create an inverted index of the given lattices. The output index is in the T*T*T\n"
         "semiring. For details for the semiring, please refer to Dogan Can and Muran Saraclar's"
diff --git a/src/latbin/lattice-add-trans-probs.cc b/src/latbin/lattice-add-trans-probs.cc
index 1e44fa4ab8e..1cafd51ce85 100644
--- a/src/latbin/lattice-add-trans-probs.cc
+++ b/src/latbin/lattice-add-trans-probs.cc
@@ -26,11 +26,10 @@
 #include "hmm/transition-model.h"
 #include "hmm/hmm-utils.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -90,3 +89,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-arcgraph.cc b/src/latbin/lattice-arcgraph.cc
index a7fcb8b5924..d66f946a2c2 100644
--- a/src/latbin/lattice-arcgraph.cc
+++ b/src/latbin/lattice-arcgraph.cc
@@ -24,6 +24,8 @@
 #include "lat/kaldi-lattice.h"
 #include "hmm/transition-model.h"
 
+namespace kaldi {
+
 typedef fst::StdArc::StateId StateId;
 typedef fst::StdArc::Weight Weight;
 typedef fst::StdArc::Label Label;
@@ -135,9 +137,6 @@ void MapTransitionIdsToTransitionStates(kaldi::CompactLattice *lat,
 
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -263,3 +262,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-compose.cc b/src/latbin/lattice-compose.cc
index 8011ec6573e..0dbd574b079 100644
--- a/src/latbin/lattice-compose.cc
+++ b/src/latbin/lattice-compose.cc
@@ -23,11 +23,10 @@
 #include "fstext/fstext-lib.h"
 #include "lat/kaldi-lattice.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -164,3 +163,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-determinize-pruned.cc b/src/latbin/lattice-determinize-pruned.cc
index 1724f4993b5..fe2c77d0f49 100644
--- a/src/latbin/lattice-determinize-pruned.cc
+++ b/src/latbin/lattice-determinize-pruned.cc
@@ -24,11 +24,10 @@
 #include "lat/push-lattice.h"
 #include "lat/minimize-lattice.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    
     const char *usage =
         "Determinize lattices, keeping only the best path (sequence of acoustic states)\n"
         "for each input-symbol sequence.  This version does pruning as part of the\n"
@@ -117,3 +116,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-interp.cc b/src/latbin/lattice-interp.cc
index db2a155fdb2..b8cd409e410 100644
--- a/src/latbin/lattice-interp.cc
+++ b/src/latbin/lattice-interp.cc
@@ -23,11 +23,10 @@
 #include "fstext/fstext-lib.h"
 #include "lat/kaldi-lattice.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -111,3 +110,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-lmrescore-const-arpa.cc b/src/latbin/lattice-lmrescore-const-arpa.cc
index 798852236f4..c09e595abcf 100644
--- a/src/latbin/lattice-lmrescore-const-arpa.cc
+++ b/src/latbin/lattice-lmrescore-const-arpa.cc
@@ -25,12 +25,10 @@
 #include "lm/const-arpa-lm.h"
 #include "util/common-utils.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
-
     const char *usage =
         "Rescores lattice with the ConstArpaLm format language model. The LM\n"
         "will be wrapped into the DeterministicOnDemandFst interface and the\n"
@@ -121,3 +119,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-lmrescore.cc b/src/latbin/lattice-lmrescore.cc
index d20b0414c53..0c2d035cd05 100644
--- a/src/latbin/lattice-lmrescore.cc
+++ b/src/latbin/lattice-lmrescore.cc
@@ -24,11 +24,10 @@
 #include "fstext/fstext-lib.h"
 #include "lat/kaldi-lattice.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -150,3 +149,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-oracle.cc b/src/latbin/lattice-oracle.cc
index e5e8590fc11..ba83496a947 100644
--- a/src/latbin/lattice-oracle.cc
+++ b/src/latbin/lattice-oracle.cc
@@ -218,13 +218,8 @@ bool GetOracleLattice(Lattice *oracle_lat,
   return status;
 }
 
-}
-
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -433,3 +428,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-rescore-mapped.cc b/src/latbin/lattice-rescore-mapped.cc
index 4dd8dfd875c..482b26dd2dc 100644
--- a/src/latbin/lattice-rescore-mapped.cc
+++ b/src/latbin/lattice-rescore-mapped.cc
@@ -69,13 +69,8 @@ void LatticeAcousticRescore(const TransitionModel &trans_model,
   }
 }
 
-}  // namespace kaldi
-
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -172,3 +167,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-reverse.cc b/src/latbin/lattice-reverse.cc
index 962ccad2d03..29989fc90e4 100644
--- a/src/latbin/lattice-reverse.cc
+++ b/src/latbin/lattice-reverse.cc
@@ -24,11 +24,10 @@
 #include "lat/kaldi-lattice.h"
 //#include "lat/lattice-functions.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::VectorFst;
     using fst::StdArc;
 
@@ -80,3 +79,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-to-nbest.cc b/src/latbin/lattice-to-nbest.cc
index 7c711afb18b..cee69d3717e 100644
--- a/src/latbin/lattice-to-nbest.cc
+++ b/src/latbin/lattice-to-nbest.cc
@@ -23,11 +23,10 @@
 #include "fstext/fstext-lib.h"
 #include "lat/kaldi-lattice.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -130,3 +129,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/lattice-to-phone-lattice.cc b/src/latbin/lattice-to-phone-lattice.cc
index fad419ee5b7..40ee510e761 100644
--- a/src/latbin/lattice-to-phone-lattice.cc
+++ b/src/latbin/lattice-to-phone-lattice.cc
@@ -25,11 +25,10 @@
 #include "lat/lattice-functions.h"
 #include "hmm/transition-model.h"
 
+namespace kaldi {
+
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -97,3 +96,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/latbin/linear-to-nbest.cc b/src/latbin/linear-to-nbest.cc
index 968f5204c9b..2081176e9be 100644
--- a/src/latbin/linear-to-nbest.cc
+++ b/src/latbin/linear-to-nbest.cc
@@ -24,6 +24,7 @@
 #include "lat/kaldi-lattice.h"
 
 namespace kaldi {
+
 void MakeLatticeFromLinear(const std::vector<int32> &ali,
                            const std::vector<int32> &words,
                            BaseFloat lm_cost,
@@ -45,13 +46,9 @@ void MakeLatticeFromLinear(const std::vector<int32> &ali,
   }
   lat_out->SetFinal(cur_state, Weight(lm_cost, ac_cost));
 }
-}
 
 int main(int argc, char *argv[]) {
   try {
-    using namespace kaldi;
-    typedef kaldi::int32 int32;
-    typedef kaldi::int64 int64;
     using fst::SymbolTable;
     using fst::VectorFst;
     using fst::StdArc;
@@ -134,3 +131,10 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 }
+
+}  //namespace kaldi
+
+
+int main(int argc, char *argv[]) {
+  return kaldi::main(argc, argv);
+}
diff --git a/src/sgmm/estimate-am-sgmm-multi-test.cc b/src/sgmm/estimate-am-sgmm-multi-test.cc
index 6222fb1b900..77bc5961d14 100644
--- a/src/sgmm/estimate-am-sgmm-multi-test.cc
+++ b/src/sgmm/estimate-am-sgmm-multi-test.cc
@@ -23,18 +23,12 @@
 #include "sgmm/estimate-am-sgmm-multi.h"
 #include "util/kaldi-io.h"
 
-using kaldi::AmSgmm;
-using kaldi::MleAmSgmmAccs;
-using kaldi::BaseFloat;
-namespace ut = kaldi::unittest;
+namespace kaldi {
 
 // Tests the MleAmSgmmUpdaterMulti (and MleAmSgmmGlobalAccs) classes.
 void TestMultiSgmmEst(const std::vector<AmSgmm*> &models,
                       const std::vector< kaldi::Matrix<BaseFloat> > &feats,
                       kaldi::SgmmUpdateFlagsType flags) {
-  using namespace kaldi;
-  typedef kaldi::int32 int32;
-
   int32 num_gauss = models[0]->NumGauss(),
       feat_dim = models[0]->FeatureDim(),
       phn_dim = models[0]->PhoneSpaceDim(),
@@ -101,7 +95,7 @@ void UnitTestEstimateSgmm() {
   int32 dim = 2 + kaldi::RandInt(0, 9);  // random dimension of the gmm
   int32 num_comp = 2 + kaldi::RandInt(0, 9);  // random mixture size
   kaldi::FullGmm full_gmm;
-  ut::InitRandFullGmm(dim, num_comp, &full_gmm);
+  unittest::InitRandFullGmm(dim, num_comp, &full_gmm);
 
   int32 num_states = 1;
   int32 num_models = kaldi::RandInt(2, 9);
@@ -129,7 +123,7 @@ void UnitTestEstimateSgmm() {
     feats[i].Resize(num_feat_comp * 200, dim);
     for (int32 m = 0; m < num_feat_comp; ++m) {
       kaldi::SubMatrix<BaseFloat> tmp(feats[i], m*200, 200, 0, dim);
-      ut::RandDiagGaussFeatures(200, means.Row(m), vars.Row(m), &tmp);
+      unittest::RandDiagGaussFeatures(200, means.Row(m), vars.Row(m), &tmp);
     }
   }
   kaldi::SgmmUpdateFlagsType flags = kaldi::kSgmmAll;
@@ -143,9 +137,12 @@ void UnitTestEstimateSgmm() {
   kaldi::DeletePointers(&models);
 }
 
+}  // namespace kaldi
+
+
 int main() {
   for (int i = 0; i < 10; ++i)
-    UnitTestEstimateSgmm();
+    kaldi::UnitTestEstimateSgmm();
   std::cout << "Test OK.\n";
   return 0;
 }
diff --git a/src/sgmm/estimate-am-sgmm-test.cc b/src/sgmm/estimate-am-sgmm-test.cc
index 35ba19941ec..d7c5a6fd801 100644
--- a/src/sgmm/estimate-am-sgmm-test.cc
+++ b/src/sgmm/estimate-am-sgmm-test.cc
@@ -23,18 +23,12 @@
 #include "sgmm/estimate-am-sgmm.h"
 #include "util/kaldi-io.h"
 
-using kaldi::AmSgmm;
-using kaldi::MleAmSgmmAccs;
-using kaldi::BaseFloat;
-namespace ut = kaldi::unittest;
+namespace kaldi {
 
 // Tests the Read() and Write() methods for the accumulators, in both binary
 // and ASCII mode, as well as Check().
 void TestUpdateAndAccsIO(const AmSgmm &sgmm,
                          const kaldi::Matrix<BaseFloat> &feats) {
-  using namespace kaldi;
-  typedef kaldi::int32 int32;
-
   kaldi::SgmmUpdateFlagsType flags = kaldi::kSgmmAll;
   kaldi::SgmmPerFrameDerivedVars frame_vars;
   kaldi::SgmmPerSpkDerivedVars empty;
@@ -120,7 +114,7 @@ void UnitTestEstimateSgmm() {
   int32 dim = 1 + kaldi::RandInt(0, 9);  // random dimension of the gmm
   int32 num_comp = 2 + kaldi::RandInt(0, 9);  // random mixture size
   kaldi::FullGmm full_gmm;
-  ut::InitRandFullGmm(dim, num_comp, &full_gmm);
+  unittest::InitRandFullGmm(dim, num_comp, &full_gmm);
 
   int32 num_states = 1;
   AmSgmm sgmm;
@@ -144,15 +138,18 @@ void UnitTestEstimateSgmm() {
     feats.Resize(num_feat_comp * 200, dim);
     for (int32 m = 0; m < num_feat_comp; m++) {
       kaldi::SubMatrix<BaseFloat> tmp(feats, m*200, 200, 0, dim);
-      ut::RandDiagGaussFeatures(200, means.Row(m), vars.Row(m), &tmp);
+      unittest::RandDiagGaussFeatures(200, means.Row(m), vars.Row(m), &tmp);
     }
   }
   TestUpdateAndAccsIO(sgmm, feats);
 }
 
+}  // namespace kaldi
+
+
 int main() {
   for (int i = 0; i < 10; i++)
-    UnitTestEstimateSgmm();
+    kaldi::UnitTestEstimateSgmm();
   std::cout << "Test OK.\n";
   return 0;
 }