From: Davi Arnaut Date: April 12 2011 7:50pm Subject: bzr commit into mysql-trunk branch (davi:3348) List-Archive: http://lists.mysql.com/commits/135288 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="===============4006080062094541284==" --===============4006080062094541284== MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Content-Disposition: inline # At a local mysql-trunk repository of davi 3348 Davi Arnaut 2011-04-12 Increment the I_P_List counter whenever a element is inserted into the list. Previously, the counter would only be incremented if the insertion method push_front() was used, in which case the counter wouldn't be incremented if a element was inserted using the push_back() and/or insert_after() methods. Currently this does not affect the code base because there isn't any code that uses a counted list with the push_back() or insert_after() methods. Thus, add a unit test case to ensure that the counted list works properly. added: unittest/gunit/sql_plist-t.cc modified: sql/sql_plist.h unittest/gunit/CMakeLists.txt === modified file 'sql/sql_plist.h' --- a/sql/sql_plist.h 2011-04-11 11:52:24 +0000 +++ b/sql/sql_plist.h 2011-04-12 19:50:44 +0000 @@ -95,6 +95,7 @@ public: *last= a; *B::prev_ptr(a)= last; I::set_last(B::next_ptr(a)); + C::inc(); } inline void insert_after(T *pos, T *a) { @@ -112,6 +113,7 @@ public: } else I::set_last(B::next_ptr(a)); + C::inc(); } } inline void remove(T *a) === modified file 'unittest/gunit/CMakeLists.txt' --- a/unittest/gunit/CMakeLists.txt 2011-04-04 08:47:25 +0000 +++ b/unittest/gunit/CMakeLists.txt 2011-04-12 19:50:44 +0000 @@ -212,6 +212,7 @@ SET(TESTS my_decimal my_regex sql_list + sql_plist thread_utils ) === added file 'unittest/gunit/sql_plist-t.cc' --- a/unittest/gunit/sql_plist-t.cc 1970-01-01 00:00:00 +0000 +++ b/unittest/gunit/sql_plist-t.cc 2011-04-12 19:50:44 +0000 @@ -0,0 +1,147 @@ +/* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ + +// First include (the generated) my_config.h, to get correct platform defines, +// then gtest.h (before any other MySQL headers), to avoid min() macros etc ... +#include "my_config.h" +#include + +#include "sql_plist.h" + +namespace { + +// A simple helper function to determine array size. +template +int array_size(const T (&)[size]) +{ + return size; +} + +// A simple helper function to insert values into a List. +template +void insert_values(T (&array)[size], L *list) +{ + uint ix, elements= list->elements(); + for (ix= 0; ix < size; ++ix) + list->push_back(&array[ix]); + EXPECT_EQ(ix + elements, list->elements()); +} + +/* + The fixture for testing the MySQL List and List_iterator classes. + A fresh instance of this class will be created for each of the + TEST_F functions below. +*/ +class I_P_ListTest : public ::testing::Test +{ +protected: + I_P_ListTest() + : m_int_list(), m_int_list_iter(m_int_list) + { + } + +public: + template + struct I_P_ListTestValue + { + V value; + I_P_ListTestValue(V val) : value(val) {} + bool operator == (const V val) const { return value == val; } + bool operator == (const I_P_ListTestValue &obj) const + { return value == obj.value; } + struct I_P_ListTestValue *next; + struct I_P_ListTestValue **prev; + }; + +protected: + template + struct I_P_ListCountedPushBack + { + typedef I_P_ListTestValue Value; + typedef I_P_List, + I_P_List_counter, + I_P_List_fast_push_back + > Type; + }; + + I_P_ListCountedPushBack::Type m_int_list; + I_P_ListCountedPushBack::Type::Iterator m_int_list_iter; + +private: + // Declares (but does not define) copy constructor and assignment operator. + GTEST_DISALLOW_COPY_AND_ASSIGN_(I_P_ListTest); +}; + + +// Allow construction of test messages via the << operator. +template +std::ostream &operator << (std::ostream &s, const I_P_ListTest::I_P_ListTestValue &v) +{ + return s << v.value; +} + + +// Tests that we can construct and destruct lists. +TEST_F(I_P_ListTest, ConstructAndDestruct) +{ + EXPECT_TRUE(m_int_list.is_empty()); + I_P_ListCountedPushBack::Type *p_int_list; + p_int_list= new I_P_ListCountedPushBack::Type; + EXPECT_TRUE(p_int_list->is_empty()); + delete p_int_list; +} + + +// Tests basic operations push and remove. +TEST_F(I_P_ListTest, BasicOperations) +{ + I_P_ListTestValue v1(1), v2(2), v3(3); + m_int_list.push_front(&v1); + m_int_list.insert_after(&v1, &v2); + m_int_list.push_back(&v3); + EXPECT_FALSE(m_int_list.is_empty()); + EXPECT_EQ(3U, m_int_list.elements()); + + EXPECT_EQ(&v1, m_int_list.front()); + m_int_list.remove(&v1); + EXPECT_EQ(&v2, m_int_list.front()); + m_int_list.remove(&v2); + EXPECT_EQ(&v3, m_int_list.front()); + m_int_list.remove(&v3); + EXPECT_TRUE(m_int_list.is_empty()) << "The list should be empty now!"; +} + + +// Tests that we can iterate over values. +TEST_F(I_P_ListTest, Iterate) +{ + I_P_ListTestValue values[]= {3, 2, 1}; + insert_values(values, &m_int_list); + m_int_list_iter.init(m_int_list); + for (int ix= 0; ix < array_size(values); ++ix) + { + EXPECT_EQ(values[ix], *m_int_list_iter++); + } + m_int_list_iter.init(m_int_list); + I_P_ListTestValue *value; + int value_number= 0; + while ((value= m_int_list_iter++)) + { + EXPECT_EQ(values[value_number++], value->value); + } +} + +} // namespace --===============4006080062094541284== MIME-Version: 1.0 Content-Type: text/bzr-bundle; charset="us-ascii"; name="bzr/davi.arnaut@stripped" Content-Transfer-Encoding: 7bit Content-Disposition: inline # Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: davi.arnaut@stripped # target_branch: file:///home/davi/mysql/repo/stage/mysql-trunk/ # testament_sha1: 995460a111bc959147dab6d29969c495e3a1c2b8 # timestamp: 2011-04-12 16:50:49 -0300 # source_branch: file:///home/davi/mysql/repo/stage/mysql-5.5/ # base_revision_id: davi.arnaut@stripped\ # kwazs67xi8a6j2wp # # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWXl/LRgABRt/gFAQYAB5//// f+f/6r////pgDW2+9veYHM3vRlJDve9SjetuzueePenttmUy0A9d2pRRDFBNRozVTbTIaaYqNqaZ AA00AGID0m0gyaCUIAjQEEnoEyTNJk2UPRDRo0NADQNGQMgRNNTTRTwnqhskeo0aaADQDQDQAAPU CTUiCFN6mqeTU/RTQ9pRoeKep6mjQNGTQAA0NAHMJoyNDQyGEaGQ00aADEZMgGEAwCRIQBBoApmi eo0NJtFPEGp+pHqbKeo2kaHpNAZR8ggIEm7rNJYN1vWpc6OGFleA4f2xnPzTpC1Kl4nHMjIHRw7K jWxbqN492Uq20dPNFQaoyMjo4nvMSLlHl95Ic/An62e8LrsmbwKiY3htdRoOij2QN+bC3bOywl2F 9R5Mtds8GZMvpmXGOH+bBRsRvtjoQkoFJZIUIDqoo4WVBQBQnXwm6dzzDXlL/r7MOwzst0q/F897 nr7tT16HQjHQKCqKv93Yp/SJnHNfMol2X38OTEtUBC4OlDHHdxwjQGZ6tCEiaEOWreGq9lO4eBpE CnJD86K50AUe0r1r3O3KrEOptL5zPZ9vxKcZG5+nR2jOY134wz5yhnvrKA30Z+rfS/M2ScTWSblV CBOBbLWnk+PY6EKxce2s75Xx53rr3LO30kysovjwwflYjaZ6MJSlJwUKMfHaPC89Ua505Ho3WrKY YOJUIYXmyY579ClCDX0uHE4rTyOf5XhQR7QcT2yq1Hjdic88Dk2uWmbQ7cb+nlMebnyrM000Sdg2 KRLLkzpnaTDCNO7yDWfk6+qCttxuEelhXnPxzcTX2MR4Xj+K/hGeMJzgzNWt9nu2ZdND1nJccT3z M5ct90OCka4xebJxubGSEcKugKHr8R7ng6g1b8LHZ7u+YfF5+EnjwrRAUWfHPosIwYKHKUdnJt3f tZvVYYXwxat0d5lSnaVx9fFs8/bMdNAIhhLqj3gMIyJOYbwDXZ4nCynt/b8rCn8WdBvoG4lBFdOm jhmbFpC3IkpSiDFlWanJh2BoG6gHkQWjllQpu8T9Ln3tlpnn80aKc6xaU6Lw3egd9EbW37l6lLYd vtkqt2nn89pWHejwjEb+4mG3uEZGRvp76Bfr30vyL57lx8Hie4YGP4HOVEL6Y1EmBlAAli0HypIt CIGI7+/rG8I8iMzBtrZvwxV+xUO3d/C1LixdA+gVCp7SQgoSrKoqKE6VMAmysRBAyh1Et5Uw+JCJ K5UPBeGN5aq7xnWMXzWa9KVUFbc6I3+hqt1ne79POyAVCeww7vfIiRruVAHCeo3CQJ+WsoptJCEx h+m75X8fUZ6Zmdy2OCGxNfFpGT7Hom6pyeGZ1W9xQmIvVy26s+smceXM02nEjl1Mh4HAUmgKjkTm pAlBFGxBjdXUjuHPntkJqhs5Y9QXU6c00+trixnIdku4vNCRcxqS03mdCpcT1yqX3V12pt2Fxekm EYA5Fo0MAZz5SzjInAi1rEdvhKXFUpTQ9AuRcVHTxMiWjRa8HIQ1v37w0GbTV+Fs+sKYbpazWQwK mpjU7w44aIRNzm3uwpkeINDDGKEnHc73EsAthiEOgtxYxWTHUUIpd1rf3+TJMuEdKoanAkGI8QxU 4aG0QgGsd9WMUY6ydx5GfQnlXbhfkxvDUOIhoWY44GBZQ5YD7EHCDpapWwTsOZi/micuWM8NmfvA fMNUJTTqwQHNXRcQssEkHzsBNzJyFVkgNpMsM6z+7wqdNacbci0ha1SW2UW6r1vvSvbiNfI+xcYq SSAYRLNe4+Qp5aA1h94f6h3XYHjiY2tJj6c6YSGYB5df2KnxH3/KUMv+cQcWHD60ZpJL8f0iBK3j 5Oj7yR6emRwxLJqCKSS2ZiHcq5vNNXikJH8gMZF9P9emnL57WPTkkWJb7d6LUaRhRDQszD66F3f+ u/wcbEHyBmGqEvonDb/sPXn6bXNGlsQnsZkyeSH9KTo1XS+7COokXM6pyQWAWEXE6Q+MHUNG4ZG0 TWT/qWWNF6OFsL2ctsutY53pTqx3JMGHHwoC0ObUgdS+Nyr4016Y6maQwGfQlICUFWtIw3l1PXvf uH1+0f0/7d+3zebFCxSF4EhQsg9CM5GYHIx7pKD1Q8ySMSWksRhInygVllUzGHdh97Y8p9ZFDzqn QOE8ZeYkg8wh/0uz7jUn5m/JBg9KAbvJrI+2UWm7Eju8WZefMHNn47CiKKxAVkNhgtgFulOVYexk DN35fotaDl+aSlV6RkN7sB7qxQ/bZzoK8wNWTV210Mx6BfsAKeCCIl8ULYhzmQZegYLZg59hGIah aPx2hsGwSA8KqGMZhzjaDxD1wwWBmvxoJIu/PqK5EOX7rYWcY/EWHPBD4Gw7F6JYvKqxEpxAm0S0 W94yaAqD8tE6rwDR0EzUmCjiIrVNehOARG0Wueua1NIbWNc17hxNTk29nOGAphXimheUOYqhYQeQ mMVOMqiQchUycbA3m8FRuLnjqdJmbg3FjelpjJI4eIJShM2saQFXwAMhvLwbqUTAWpVsA0Cbk0Gw 2PltsTpCwDXJJlodWCBw1WGK5gw6lyxKr2mdKUOProkY2LJOGuJAxa6bxcNO2EBIGq3TF84CSWMZ WEBxTTmLGdulF7Py4TGYGAuGqsYzRoZ31POM0GGtEWqt9IaTSMOUI/HsXuFgsgs9oSFE9VdtFw0z RXe2sFgyNDBPER0CWlIIhBtRX5gpw17V8V1U1hZtC8GO1QiEX1TtM8TA0ZbfUtulDjChMtKsZZ3A umBDVXL3zhqa27c1yrMwfYUGhppEQY+Gaulp2RWrBTwhJq1KePAwIGw5+k8VO7A47iiKrQ8ZuzHa vQslZiR56oRLRjw+8MYneSyYbEpOSeUhcin8tGaJFVgmFEd5M+s8OGfR7C0WJW4q4SyBeGpkm9ih x2ulupOIhBBUPsGqVEc9bq4gV0pCSg3HvCXPxMYXN/zDqfjxFOVE6Wpfmjw/NeQqWiNe8Q2HNAiU KqeDee0sp2EvrN2rU94yUl16/DadEnJCSi1uDHVqgigzm6Tvm7k2KM0nb3cyYUemMIsIKwIkfAiG EuhjDjqFJ8VG6fJbZnwGR8DjtBYbDuDQdu/sS9ZzhHPZqg2Clr6Kw8ZUs54xyCS5/cSXANaMaLiY 0BpJ2kyM4kHZdlygCpqZhmBWxFXZEcVpP1agfunKQQDSCLCRmtPy8jzz8mVirjSFEINvDVumNm1J e4iNHWvvhEJgbGF5YtBYJTGyoDj355Kas1OToy7IFQrUGQolGQX4YwhNZSVwsh73jh2vSzw7RQiv wDJUMaAEj03DAympSSgXgkoLrQh25ttCib5iPFZIaup67QeMleGUCiKFUoorUGpGMJEykGhixFfW SUG3pA9hw5Y7OknBm3lEu84zXpMi1AZxYtL3SOd01JL8WWo8pVGavQwkVFeReqMiPtJORjJf+AGK Wr1wFvbRX+/rPKpGOHw+TMjE9BiZIYbaaQu2Yv9hPj3eSskPJpooGc06FCG1cS+bS8tSLGvEBv7J Y4eesIg7KInJn3e6C6IwXI2bjWaxgfgI09tgmNMYs7gEwYGuBIheddnLrmCaMDkItLDfU5cymVjt MprUp1hUxRRhnPlw3zDHA3dM/PvuysYPg9Qd2hJfHGxaUZoNbKhX23G1iJWkhSQpS/mgK4xyMkFk HUx4nlMrKxiofcU14Y2aKSZEL6gclgEXEri9u5xBhwkgpOpwwU/U1rSuhUmxLKAkR4Ki+csmKkow 7bFuN7061VcEIimW1sUFU6VRaqIgyCgsBGQiQRE4l0+aRv1CZWXn2llQ01MVUtYfVfGnohtjIvq2 f/Zt9bjkVhmmdqqqM217NuFotgfJekGw4qJs9rtoTJBU1s2kIRNotolekrpoAvTJppNCTqFIwkNl ZW5XQiq8iwqsgcrSSNSyKm+a5ScDvfhXTLWnVHkSb77My4Q5U4EPQQuVO+ymnIwNZLUqhs361gKq aowrkKiYNiNuEWMmDB2tEE9uYNK8y21sOJ+9ZGTJ9qZ15hG8IGCXW0G3GwHgNQSOJZJIy6Gw9mzf Ys2dDJWd+wqpJR4juPTiILFm4o50PAnvekX9q55iRAzljmCNl+5OdfUVgETS8UoorDcql2gz2jAs b7g6CVYj2B1oNxoERfixgVWcNPV4LbCJ5UmERRvyn8ifqGd5p8Z+CLkYV+T7y3ShZQFyNwl6qlQV /tlCfV/4u5IpwoSDy/lowA== --===============4006080062094541284==--