From: JINMEI Tatuya Date: Mon, 12 Nov 2012 20:05:46 +0000 (-0800) Subject: [2372] made sure entire test sstring is built before starting test case. X-Git-Tag: trac2487_base~1^2~21^2~3 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=6a2d1a5cbdeb2603982abbf148012e0879bba4ee;p=thirdparty%2Fkea.git [2372] made sure entire test sstring is built before starting test case. The previous code should actually be safe based on the iostream/streambuf APIs, but it's even much safer to completely give the ownership of the passed stream to the input source. --- diff --git a/src/lib/dns/tests/master_lexer_state_unittest.cc b/src/lib/dns/tests/master_lexer_state_unittest.cc index f6d99a9b0e..bcee7fd1ec 100644 --- a/src/lib/dns/tests/master_lexer_state_unittest.cc +++ b/src/lib/dns/tests/master_lexer_state_unittest.cc @@ -34,9 +34,7 @@ protected: s_string(State::getInstance(State::String)), options(MasterLexer::NONE), orig_options(options) - { - lexer.pushSource(ss); - } + {} // Specify INITIAL_WS as common initial options. const MasterLexer::Options common_options; @@ -61,12 +59,15 @@ eofCheck(const State& state, MasterLexer& lexer) { TEST_F(MasterLexerStateTest, startAndEnd) { // A simple case: the input is empty, so we begin with start and // are immediately done. + lexer.pushSource(ss); EXPECT_EQ(s_null, State::start(lexer, common_options)); eofCheck(s_crlf, lexer); } TEST_F(MasterLexerStateTest, startToEOL) { ss << "\n"; + lexer.pushSource(ss); + EXPECT_EQ(s_null, State::start(lexer, common_options)); EXPECT_TRUE(s_crlf.wasLastEOL(lexer)); EXPECT_EQ(Token::END_OF_LINE, s_crlf.getToken(lexer).getType()); @@ -77,12 +78,15 @@ TEST_F(MasterLexerStateTest, startToEOL) { } TEST_F(MasterLexerStateTest, space) { + // repeat '\t\n' twice (see below), then space after EOL + ss << " \t\n\t\n "; + lexer.pushSource(ss); + // by default space characters and tabs will be ignored. We check this // twice; at the second iteration, it's a white space at the beginning // of line, but since we don't specify INITIAL_WS option, it's treated as // normal space and ignored. for (size_t i = 0; i < 2; ++i) { - ss << " \t\n"; EXPECT_EQ(s_null, State::start(lexer, MasterLexer::NONE)); EXPECT_TRUE(s_crlf.wasLastEOL(lexer)); EXPECT_EQ(Token::END_OF_LINE, s_crlf.getToken(lexer).getType()); @@ -90,7 +94,6 @@ TEST_F(MasterLexerStateTest, space) { // Now we specify the INITIAL_WS option. It will be recognized and the // corresponding token will be returned. - ss << " "; EXPECT_EQ(s_null, State::start(lexer, MasterLexer::INITIAL_WS)); EXPECT_FALSE(s_crlf.wasLastEOL(lexer)); EXPECT_EQ(Token::INITIAL_WS, s_crlf.getToken(lexer).getType()); @@ -98,6 +101,7 @@ TEST_F(MasterLexerStateTest, space) { TEST_F(MasterLexerStateTest, parentheses) { ss << "\n(\na\n )\n "; // 1st \n is to check if 'was EOL' is set to false + lexer.pushSource(ss); EXPECT_EQ(s_null, State::start(lexer, common_options)); // handle \n @@ -127,6 +131,8 @@ TEST_F(MasterLexerStateTest, parentheses) { TEST_F(MasterLexerStateTest, nestedParentheses) { // This is an unusual, but allowed (in this implementation) case. ss << "(a(b)\n c)\n "; + lexer.pushSource(ss); + EXPECT_EQ(&s_string, State::start(lexer, common_options)); // consume '(' s_string.handle(lexer); // consume 'a' EXPECT_EQ(&s_string, State::start(lexer, common_options)); // consume '(' @@ -155,6 +161,8 @@ TEST_F(MasterLexerStateTest, unbalancedParentheses) { // Only closing paren is provided. We prepend a \n to check if it's // correctly canceled after detecting the error. ss << "\n)"; + ss << "(a"; + lexer.pushSource(ss); EXPECT_EQ(s_null, State::start(lexer, common_options)); // consume '\n' EXPECT_TRUE(s_crlf.wasLastEOL(lexer)); // this \n was remembered @@ -169,7 +177,6 @@ TEST_F(MasterLexerStateTest, unbalancedParentheses) { EXPECT_FALSE(s_crlf.wasLastEOL(lexer)); // Reach EOF with a dangling open parenthesis. - ss << "(a"; EXPECT_EQ(&s_string, State::start(lexer, common_options)); // consume '(' s_string.handle(lexer); // consume 'a' EXPECT_EQ(1, s_crlf.getParenCount(lexer)); @@ -184,11 +191,14 @@ TEST_F(MasterLexerStateTest, startToComment) { // the rest of the line, and recognize the new line. Note that the // second ';' is simply ignored. ss << " ;a;\n"; + ss << ";a;"; // Likewise, but the comment ends with EOF. + lexer.pushSource(ss); + + // Comment ending with EOL EXPECT_EQ(s_null, State::start(lexer, common_options)); EXPECT_EQ(Token::END_OF_LINE, s_crlf.getToken(lexer).getType()); - // Likewise, but the comment ends with EOF. - ss << ";a;"; + // Comment ending with EOF EXPECT_EQ(s_null, State::start(lexer, common_options)); EXPECT_EQ(Token::END_OF_FILE, s_crlf.getToken(lexer).getType()); } @@ -198,6 +208,8 @@ TEST_F(MasterLexerStateTest, commentAfterParen) { // other tests should also ensure that it works correctly, but we // check it explicitly. ss << "( ;this is a comment\na)\n"; + lexer.pushSource(ss); + // consume '(', skip comments, consume 'a', then consume ')' EXPECT_EQ(&s_string, State::start(lexer, common_options)); s_string.handle(lexer); @@ -206,30 +218,34 @@ TEST_F(MasterLexerStateTest, commentAfterParen) { } TEST_F(MasterLexerStateTest, crlf) { - // A sequence of \r, \n is recognized as a single 'end-of-line' - ss << "\r\n"; + ss << "\r\n"; // case 1 + ss << "\r "; // case 2 + ss << "\r;comment\na"; // case 3 + ss << "\r"; // case 4 + lexer.pushSource(ss); + + // 1. A sequence of \r, \n is recognized as a single 'end-of-line' EXPECT_EQ(&s_crlf, State::start(lexer, common_options)); // recognize '\r' EXPECT_EQ(s_null, s_crlf.handle(lexer)); // recognize '\n' EXPECT_EQ(Token::END_OF_LINE, s_crlf.getToken(lexer).getType()); EXPECT_TRUE(s_crlf.wasLastEOL(lexer)); - // Single '\r' (not followed by \n) is recognized as a single 'end-of-line' - ss << "\r "; // then there will be "initial WS" + // 2. Single '\r' (not followed by \n) is recognized as a single + // 'end-of-line'. then there will be "initial WS" EXPECT_EQ(&s_crlf, State::start(lexer, common_options)); // recognize '\r' // see ' ', "unget" it EXPECT_EQ(s_null, s_crlf.handle(lexer)); EXPECT_EQ(s_null, State::start(lexer, common_options)); // recognize ' ' EXPECT_EQ(Token::INITIAL_WS, s_crlf.getToken(lexer).getType()); - ss << "\r;comment\na"; + // 3. comment between \r and \n EXPECT_EQ(&s_crlf, State::start(lexer, common_options)); // recognize '\r' // skip comments, recognize '\n' EXPECT_EQ(s_null, s_crlf.handle(lexer)); EXPECT_EQ(Token::END_OF_LINE, s_crlf.getToken(lexer).getType()); EXPECT_EQ(&s_string, State::start(lexer, common_options)); - // \r then EOF - ss << "\r"; + // 4. \r then EOF EXPECT_EQ(&s_crlf, State::start(lexer, common_options)); // recognize '\r' // see EOF, then "unget" it EXPECT_EQ(s_null, s_crlf.handle(lexer));