Minimized the test code

Also, modified the Completer interface to facilitate the minimization of the
test code.

cpp/Completer.cpp

@@ -53,14 +53,14 @@ void ThreadMain( TaskStack &task_stack )
 } // unnamed namespace
 
 
-Completer::Completer( const Pylist &candidates )
+Completer::Completer( const std::vector< std::string > &candidates )
   : threading_enabled_( false )
 {
   AddCandidatesToDatabase( candidates, "", "" );
 }
 
 
-Completer::Completer( const Pylist &candidates,
+Completer::Completer( const std::vector< std::string > &candidates,
                       const std::string &filetype,
                       const std::string &filepath )
   : threading_enabled_( false )
@@ -91,18 +91,35 @@ void Completer::EnableThreading()
 void Completer::AddCandidatesToDatabase( const Pylist &new_candidates,
                                          const std::string &filetype,
                                          const std::string &filepath )
+{
+  int num_candidates = len( new_candidates );
+  std::vector< std::string > candidates;
+  candidates.reserve( num_candidates );
+
+  for (int i = 0; i < num_candidates; ++i)
+  {
+    candidates.push_back( extract< std::string >( new_candidates[ i ] ) );
+  }
+
+  AddCandidatesToDatabase( candidates, filetype, filepath );
+}
+
+
+void Completer::AddCandidatesToDatabase(
+    const std::vector< std::string > &new_candidates,
+    const std::string &filetype,
+    const std::string &filepath )
 {
   std::vector< Candidate *> &candidates =
     GetCandidateVector( filetype, filepath );
 
-  int num_candidates = len( new_candidates );
+  int num_candidates = new_candidates.size();
   candidates.clear();
   candidates.reserve( num_candidates );
 
-  std::string candidate_text;
   for (int i = 0; i < num_candidates; ++i)
   {
-    candidate_text = extract< std::string >( new_candidates[ i ] );
+    const std::string &candidate_text = new_candidates[ i ];
     Candidate *&candidate = GetValueElseInsert( candidate_repository_,
                                                 candidate_text, NULL );
     if ( !candidate )
@@ -113,24 +130,26 @@ void Completer::AddCandidatesToDatabase( const Pylist &new_candidates,
 }
 
 
-void Completer::CandidatesForQuery( const std::string &query,
+std::vector< std::string > Completer::CandidatesForQuery(
-                                    Pylist &candidates ) const
+    const std::string &query ) const
 {
-  CandidatesForQueryAndType( query, "", candidates );
+  return CandidatesForQueryAndType( query, "" );
 }
 
 
-void Completer::CandidatesForQueryAndType( const std::string &query,
+std::vector< std::string > Completer::CandidatesForQueryAndType(
-                                           const std::string &filetype,
+    const std::string &query,
-                                           Pylist &candidates ) const
+    const std::string &filetype ) const
 {
   std::vector< Result > results;
   ResultsForQueryAndType( query, filetype, results );
 
+  std::vector< std::string > candidates;
   foreach ( const Result& result, results )
   {
-    candidates.append( *result.Text() );
+    candidates.push_back( *result.Text() );
   }
+  return candidates;
 }
 
 
@@ -156,6 +175,7 @@ Future Completer::CandidatesForQueryAndTypeAsync(
   return Future( move( future ) );
 }
 
+
 AsyncResults Completer::ResultsForQueryAndType(
     const std::string &query,
     const std::string &filetype ) const
@@ -165,6 +185,7 @@ AsyncResults Completer::ResultsForQueryAndType(
   return results;
 }
 
+
 void Completer::ResultsForQueryAndType( const std::string &query,
                                         const std::string &filetype,
                                         std::vector< Result > &results ) const

cpp/Completer.h

@@ -56,25 +56,30 @@ class Completer : boost::noncopyable
 {
 public:
   Completer() {}
-  Completer( const Pylist &candidates );
+  Completer( const std::vector< std::string > &candidates );
-  Completer( const Pylist &candidates,
+  Completer( const std::vector< std::string > &candidates,
              const std::string &filetype,
              const std::string &filepath );
   ~Completer();
 
   void EnableThreading();
 
+  void AddCandidatesToDatabase(
+      const std::vector< std::string > &new_candidates,
+      const std::string &filetype,
+      const std::string &filepath );
+
   void AddCandidatesToDatabase( const Pylist &new_candidates,
                                 const std::string &filetype,
                                 const std::string &filepath );
 
   // Only provided for tests!
-	void CandidatesForQuery( const std::string &query,
+	std::vector< std::string > CandidatesForQuery(
-                           Pylist &candidates ) const;
+	    const std::string &query ) const;
 
-	void CandidatesForQueryAndType( const std::string &query,
+  std::vector< std::string > CandidatesForQueryAndType(
-                                  const std::string &filetype,
+      const std::string &query,
-                                  Pylist &candidates ) const;
+      const std::string &filetype ) const;
 
 	Future CandidatesForQueryAndTypeAsync( const std::string &query,
                                          const std::string &filetype ) const;

cpp/indexer.cpp

@@ -30,9 +30,14 @@ BOOST_PYTHON_MODULE(indexer)
     .def( "ResultsReady", &Future::ResultsReady )
     .def( "GetResults", &Future::GetResults );
 
+  void (Completer::*actd) (const Pylist&,
+                           const std::string&,
+                           const std::string&) =
+    &Completer::AddCandidatesToDatabase;
+
   class_< Completer, boost::noncopyable >( "Completer" )
     .def( "EnableThreading", &Completer::EnableThreading )
-    .def( "AddCandidatesToDatabase", &Completer::AddCandidatesToDatabase )
+    .def( "AddCandidatesToDatabase", actd )
     .def( "CandidatesForQueryAndTypeAsync",
           &Completer::CandidatesForQueryAndTypeAsync );
 }

cpp/tests/Completer_test.cpp

@@ -30,19 +30,7 @@ namespace YouCompleteMe
 namespace
 {
 
-std::vector<std::string> ToStringVector( const boost::python::list &pylist )
+std::vector< std::string > Candidates( const std::string &a,
-{
-	std::vector<std::string> values;
-  for (int i = 0; i < boost::python::len( pylist ); ++i)
-  {
-    values.push_back(
-      boost::python::extract< std::string >( pylist[ i ] ) );
-  }
-
-  return values;
-}
-
-Pylist Candidates( const std::string &a,
                                        const std::string &b = std::string(),
                                        const std::string &c = std::string(),
                                        const std::string &d = std::string(),
@@ -52,167 +40,124 @@ Pylist Candidates( const std::string &a,
                                        const std::string &h = std::string(),
                                        const std::string &i = std::string() )
 {
-  Pylist candidates;
+  std::vector< std::string > candidates;
-	candidates.append( a );
+	candidates.push_back( a );
 	if ( !b.empty() )
-    candidates.append( b );
+    candidates.push_back( b );
 	if ( !c.empty() )
-    candidates.append( c );
+    candidates.push_back( c );
 	if ( !d.empty() )
-    candidates.append( d );
+    candidates.push_back( d );
 	if ( !e.empty() )
-    candidates.append( e );
+    candidates.push_back( e );
 	if ( !f.empty() )
-    candidates.append( f );
+    candidates.push_back( f );
 	if ( !g.empty() )
-    candidates.append( g );
+    candidates.push_back( g );
 	if ( !h.empty() )
-    candidates.append( h );
+    candidates.push_back( h );
 	if ( !i.empty() )
-    candidates.append( i );
+    candidates.push_back( i );
 
   return candidates;
 }
 
 } // unnamed namespace
 
-class CompleterTest : public ::testing::Test
+
+TEST( CompleterTest, OneCandidate )
 {
- protected:
+	EXPECT_THAT( Completer( Candidates(
-  virtual void SetUp()
+               "foobar" ) ).CandidatesForQuery( "fbr" ),
-  {
+	             ElementsAre( "foobar" ) );
-    Py_Initialize();
-  }
-};
-
-
-TEST_F( CompleterTest, OneCandidate )
-{
-	Pylist results;
-	Completer( Candidates( "foobar" ) ).CandidatesForQuery( "fbr", results );
-
-	EXPECT_THAT( ToStringVector( results ), ElementsAre( "foobar" ) );
 }
 
-TEST_F( CompleterTest, ManyCandidateSimple )
+TEST( CompleterTest, ManyCandidateSimple )
 {
-	Pylist results;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "foobar",
                "foobartest",
-    "Foobartest" ) ).CandidatesForQuery( "fbr", results );
+               "Foobartest" ) ).CandidatesForQuery( "fbr" ),
-
-	EXPECT_THAT( ToStringVector( results ),
 	             WhenSorted( ElementsAre( "Foobartest",
 	                                      "foobar",
 	                                      "foobartest" ) ) );
 }
 
-TEST_F( CompleterTest, FirstCharSameAsQueryWins )
+TEST( CompleterTest, FirstCharSameAsQueryWins )
 {
-	Pylist results;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "foobar",
-    "afoobar" ) ).CandidatesForQuery( "fbr", results );
+               "afoobar" ) ).CandidatesForQuery( "fbr" ),
-
-	EXPECT_THAT( ToStringVector( results ),
 	             ElementsAre( "foobar",
 	                          "afoobar" ) );
 }
 
-TEST_F( CompleterTest, CompleteMatchForWordBoundaryCharsWins )
+TEST( CompleterTest, CompleteMatchForWordBoundaryCharsWins )
 {
-	Pylist results;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "FooBarQux",
-    "FBaqux" ) ).CandidatesForQuery( "fbq", results );
+               "FBaqux" ) ).CandidatesForQuery( "fbq" ),
-
-	EXPECT_THAT( ToStringVector( results ),
 	             ElementsAre( "FooBarQux",
 	                          "FBaqux" ) );
 
-	Pylist results2;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "CompleterTest",
-    "CompleteMatchForWordBoundaryCharsWins"
+               "CompleteMatchForWordBoundaryCharsWins" ) )
-    ) ).CandidatesForQuery( "ct", results2 );
+                  .CandidatesForQuery( "ct" ),
-
-	EXPECT_THAT( ToStringVector( results2 ),
 	             ElementsAre( "CompleterTest",
 	                          "CompleteMatchForWordBoundaryCharsWins" ) );
 
-	Pylist results3;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "FooBar",
-    "FooBarRux" ) ).CandidatesForQuery( "fbr", results3 );
+               "FooBarRux" ) ).CandidatesForQuery( "fbr" ),
-
-	EXPECT_THAT( ToStringVector( results3 ),
 	             ElementsAre( "FooBarRux",
 	                          "FooBar" ) );
 }
 
-TEST_F( CompleterTest, RatioUtilizationTieBreak )
+TEST( CompleterTest, RatioUtilizationTieBreak )
 {
-	Pylist results;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "FooBarQux",
-    "FooBarQuxZaa" ) ).CandidatesForQuery( "fbq", results );
+               "FooBarQuxZaa" ) ).CandidatesForQuery( "fbq" ),
-
-	EXPECT_THAT( ToStringVector( results ),
 	             ElementsAre( "FooBarQux",
 	                          "FooBarQuxZaa" ) );
 
-	Pylist results2;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "FooBar",
-    "FooBarRux" ) ).CandidatesForQuery( "fba", results2 );
+               "FooBarRux" ) ).CandidatesForQuery( "fba" ),
-
-	EXPECT_THAT( ToStringVector( results2 ),
 	             ElementsAre( "FooBar",
 	                          "FooBarRux" ) );
 }
 
-TEST_F( CompleterTest, QueryPrefixOfCandidateWins )
+TEST( CompleterTest, QueryPrefixOfCandidateWins )
 {
-	Pylist results;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "foobar",
-    "fbaroo" ) ).CandidatesForQuery( "foo", results );
+               "fbaroo" ) ).CandidatesForQuery( "foo" ),
-
-	EXPECT_THAT( ToStringVector( results ),
 	             ElementsAre( "foobar",
 	                          "fbaroo" ) );
 }
 
-TEST_F( CompleterTest, ShorterCandidateWins )
+TEST( CompleterTest, ShorterCandidateWins )
 {
-	Pylist results;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "FooBarQux",
-    "FaBarQux" ) ).CandidatesForQuery( "fbq", results );
+               "FaBarQux" ) ).CandidatesForQuery( "fbq" ),
-
-	EXPECT_THAT( ToStringVector( results ),
 	             ElementsAre( "FaBarQux",
 	                          "FooBarQux" ) );
 
-	Pylist results2;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "CompleterT",
-    "CompleterTest" ) ).CandidatesForQuery( "co", results2 );
+               "CompleterTest" ) ).CandidatesForQuery( "co" ),
-
-	EXPECT_THAT( ToStringVector( results2 ),
 	             ElementsAre( "CompleterT",
 	                          "CompleterTest" ) );
 }
 
-TEST_F( CompleterTest, SameLowercaseCandidateWins )
+TEST( CompleterTest, SameLowercaseCandidateWins )
 {
-	Pylist results;
+	EXPECT_THAT( Completer( Candidates(
-	Completer( Candidates(
                "foobar",
-    "Foobar" ) ).CandidatesForQuery( "foo", results );
+               "Foobar" ) ).CandidatesForQuery( "foo" ),
-
-	EXPECT_THAT( ToStringVector( results ),
 	             ElementsAre( "foobar",
 	                          "Foobar" ) );
 }