Merge lp:~pblokus/drizzle/unittests-plugin-interfaces into lp:~drizzle-trunk/drizzle/development

[Paul Blokus]

Second portion of unit tests, last during GSoC.
I left some fails after the latest merge tests because I didn't know whether they were fixes or unintended changes.

[Monty Taylor (mordred)]

In merging this, we hit some failing normal test cases.

http://hudson.drizzle.org/job/drizzle-build-ubuntu910-64bit/554/

I've pushed up a branch with some other changes/fixes to the branch here:

lp:~mordred/drizzle/plugin-unittests-merge

If you could merge that in and then see why the test cases are breaking, that would be stellar.

review: Needs Fixing

Unmerged revisions

1490. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-15

fixes after merge to obvious test fails, the rest is left unchanged

1489. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-15

merged latest trunk

1488. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-15

added missing files

1487. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-15

fixed some tests failing after last merge, left those which I was not sure about

1486. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-15

fixed style of assign operator usages
moved stubs to seperate file

1485. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-15

fieldInPrimaryKey tests
setIdentifier test
getShare* tests
release tests

1484. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-15

parse_table_proto last tests

1483. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-13

parse_table_proto_IndexKeyParts_ShouldCopyParametersTo_KeyPartInfo

1482. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-13

parse_table_proto tests for automatic primary key choice

1481. By Paweł Blokus <pawel@pawel-desktop> on 2010-08-13

parse_table_proto null bits test

=== modified file 'drizzled/charset.h'
--- drizzled/charset.h	2010-02-04 08:14:46 +0000
+++ drizzled/charset.h	2010-08-15 23:41:09 +0000
@@ -60,35 +60,6 @@
 extern size_t escape_quotes_for_drizzle(const CHARSET_INFO *charset_info,
 					char *to, size_t to_length,
 					const char *from, size_t length);
-/* character sets */
-void *cs_alloc(size_t size);
-
-extern uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
-extern uint32_t get_collation_number(const char *name);
-extern const char *get_charset_name(uint32_t cs_number);
-
-extern const CHARSET_INFO *get_charset(uint32_t cs_number);
-extern const CHARSET_INFO *get_charset_by_name(const char *cs_name);
-extern const CHARSET_INFO *get_charset_by_csname(const char *cs_name, uint32_t cs_flags);
-
-extern bool resolve_charset(const char *cs_name,
-			    const CHARSET_INFO *default_cs,
-			    const CHARSET_INFO **cs);
-extern bool resolve_collation(const char *cl_name,
-			     const CHARSET_INFO *default_cl,
-			     const CHARSET_INFO **cl);
-
-extern void free_charsets(void);
-extern char *get_charsets_dir(char *buf);
-extern bool my_charset_same(const CHARSET_INFO *cs1, const CHARSET_INFO *cs2);
-extern bool init_compiled_charsets(myf flags);
-extern void add_compiled_collation(CHARSET_INFO *cs);
-extern size_t escape_string_for_drizzle(const CHARSET_INFO *charset_info,
-					char *to, size_t to_length,
-					const char *from, size_t length);
-extern size_t escape_quotes_for_drizzle(const CHARSET_INFO *charset_info,
-					char *to, size_t to_length,
-					const char *from, size_t length);
 
 } /* namespace drizzled */
 

=== modified file 'drizzled/plugin/error_message.cc'
--- drizzled/plugin/error_message.cc	2010-06-04 02:43:34 +0000
+++ drizzled/plugin/error_message.cc	2010-08-15 23:41:09 +0000
@@ -46,6 +46,8 @@
 {
   all_errmsg_handler.erase(find(all_errmsg_handler.begin(),
                                 all_errmsg_handler.end(), handler));
+  if (all_errmsg_handler.size() == 0)
+    errmsg_has = false;
 }
 
 

=== modified file 'drizzled/plugin/event_observer.h'
--- drizzled/plugin/event_observer.h	2010-06-21 23:07:24 +0000
+++ drizzled/plugin/event_observer.h	2010-08-15 23:41:09 +0000
@@ -44,6 +44,7 @@
 #define DRIZZLED_PLUGIN_EVENT_OBSERVER_H
 
 #include "drizzled/plugin/plugin.h"
+#include "drizzled/table.h"
 
 #include <string>
 
@@ -52,6 +53,8 @@
 
 class Table;
 class TableShare;
+class Session;
+class TableIdentifier;
 
 namespace plugin
 {
@@ -198,7 +201,7 @@
 
     /*==========================================================*/
     /* Static meathods called by drizzle to notify interested plugins 
-     * of a schema an event,
+     * of a schema event,
    */
     static bool beforeDropTable(Session &session, const drizzled::TableIdentifier &table);
     static bool afterDropTable(Session &session, const drizzled::TableIdentifier &table, int err);
@@ -207,7 +210,7 @@
 
     /*==========================================================*/
     /* Static meathods called by drizzle to notify interested plugins 
-     * of a table an event,
+     * of a table event,
    */
     static bool beforeInsertRecord(Table &table, unsigned char *buf);
     static bool afterInsertRecord(Table &table, const unsigned char *buf, int err);
@@ -218,7 +221,7 @@
 
     /*==========================================================*/
     /* Static meathods called by drizzle to notify interested plugins 
-     * of a table an event,
+     * of a session event,
    */
     static bool beforeCreateDatabase(Session &session, const std::string &db);
     static bool afterCreateDatabase(Session &session, const std::string &db, int err);

=== modified file 'drizzled/plugin/listen.cc'
--- drizzled/plugin/listen.cc	2009-12-21 09:40:31 +0000
+++ drizzled/plugin/listen.cc	2010-08-15 23:41:09 +0000
@@ -145,6 +145,11 @@
         /* wakeup_pipe[0] was closed in the for loop above. */
         (void) close(wakeup_pipe[1]);
 
+        listen_list.clear();
+        listen_fd_list.clear();
+        fd_list.clear();
+        fd_count= 0;
+
         return NULL;
       }
 

=== modified file 'drizzled/plugin/schema_engine.cc'
--- drizzled/plugin/schema_engine.cc	2010-07-20 02:17:09 +0000
+++ drizzled/plugin/schema_engine.cc	2010-08-15 23:41:09 +0000
@@ -84,11 +84,6 @@
 /*
   Return value is "if parsed"
 */
-bool StorageEngine::getSchemaDefinition(const drizzled::TableIdentifier &identifier, message::Schema &proto)
-{
-  return StorageEngine::getSchemaDefinition(identifier, proto);
-}
-
 bool StorageEngine::getSchemaDefinition(const SchemaIdentifier &identifier, message::Schema &proto)
 {
   proto.Clear();

=== modified file 'drizzled/plugin/storage_engine.cc'
--- drizzled/plugin/storage_engine.cc	2010-08-05 17:51:54 +0000
+++ drizzled/plugin/storage_engine.cc	2010-08-15 23:41:09 +0000
@@ -55,10 +55,6 @@
 #include <drizzled/table_proto.h>
 #include <drizzled/plugin/event_observer.h>
 
-#include <boost/algorithm/string/compare.hpp>
-
-static bool shutdown_has_begun= false; // Once we put in the container for the vector/etc for engines this will go away.
-
 using namespace std;
 
 namespace drizzled
@@ -181,13 +177,8 @@
 
 void StorageEngine::removePlugin(StorageEngine *)
 {
-  if (shutdown_has_begun == false)
-  {
-    vector_of_engines.clear();
-    vector_of_schema_engines.clear();
-
-    shutdown_has_begun= true;
-  }
+  vector_of_engines.clear();
+  vector_of_schema_engines.clear();
 }
 
 class FindEngineByName
@@ -970,7 +961,7 @@
       str.append(STRING_WITH_LEN("..."));
     }
     my_printf_error(ER_DUP_ENTRY, msg,
-		    MYF(0), str.c_ptr(), table.key_info[key_nr].name);
+        MYF(0), str.c_ptr(), table.key_info[key_nr].name);
   }
 }
 

=== modified file 'drizzled/plugin/storage_engine.h'
--- drizzled/plugin/storage_engine.h	2010-08-03 04:19:05 +0000
+++ drizzled/plugin/storage_engine.h	2010-08-15 23:41:09 +0000
@@ -271,7 +271,7 @@
     element - data file extention. This order is assumed by
     prepare_for_repair() when REPAIR Table ... USE_FRM is issued.
   */
-  virtual const char **bas_ext() const =0;
+  virtual const char **bas_ext() const= 0;
 
 protected:
   virtual int doCreateTable(Session &session,
@@ -334,7 +334,6 @@
 
   // @note All schema methods defined here
   static void getIdentifiers(Session &session, SchemaIdentifiers &schemas);
-  static bool getSchemaDefinition(const drizzled::TableIdentifier &identifier, message::Schema &proto);
   static bool getSchemaDefinition(const drizzled::SchemaIdentifier &identifier, message::Schema &proto);
   static bool doesSchemaExist(const drizzled::SchemaIdentifier &identifier);
   static const CHARSET_INFO *getSchemaCollation(const drizzled::SchemaIdentifier &identifier);

=== modified file 'drizzled/plugin/table_function.h'
--- drizzled/plugin/table_function.h	2010-07-28 22:40:44 +0000
+++ drizzled/plugin/table_function.h	2010-08-15 23:41:09 +0000
@@ -167,10 +167,6 @@
   virtual Generator *generator(Field **arg);
 
   void add_field(const char *label,
-                 message::Table::Field::FieldType type,
-                 uint32_t length= 0);
-
-  void add_field(const char *label,
                  uint32_t field_length= MAXIMUM_IDENTIFIER_LENGTH);
 
   void add_field(const char *label,

=== modified file 'drizzled/plugin/xa_resource_manager.cc'
--- drizzled/plugin/xa_resource_manager.cc	2010-04-16 05:36:53 +0000
+++ drizzled/plugin/xa_resource_manager.cc	2010-08-15 23:41:09 +0000
@@ -48,7 +48,7 @@
 
 int XaResourceManager::commitOrRollbackXID(XID *xid, bool commit)
 {
-  vector<int> results;
+  vector<int> results(xa_resource_managers.size());
   
   if (commit)
     transform(xa_resource_managers.begin(), xa_resource_managers.end(), results.begin(),

=== modified file 'drizzled/plugin/xa_resource_manager.h'
--- drizzled/plugin/xa_resource_manager.h	2010-03-03 20:21:57 +0000
+++ drizzled/plugin/xa_resource_manager.h	2010-08-15 23:41:09 +0000
@@ -21,10 +21,14 @@
 #ifndef DRIZZLED_PLUGIN_XA_RESOURCE_MANAGER_H
 #define DRIZZLED_PLUGIN_XA_RESOURCE_MANAGER_H
 
+#include <cstddef>
+
 namespace drizzled
 {
 
 class XID;
+typedef struct st_hash HASH;
+class Session;
 
 namespace plugin
 {

=== modified file 'drizzled/table_proto_write.cc'
--- drizzled/table_proto_write.cc	2010-08-05 22:57:47 +0000
+++ drizzled/table_proto_write.cc	2010-08-15 23:41:09 +0000
@@ -60,7 +60,7 @@
   }
 
   assert(strcmp(table_proto.engine().name().c_str(),
-		create_info->db_type->getName().c_str())==0);
+                create_info->db_type->getName().c_str())==0);
 
   int field_number= 0;
   bool use_existing_fields= table_proto.field_size() > 0;
@@ -161,7 +161,7 @@
 
           enumeration_options->add_field_value(src);
         }
-	enumeration_options->set_collation_id(field_arg->charset->number);
+        enumeration_options->set_collation_id(field_arg->charset->number);
         enumeration_options->set_collation(field_arg->charset->name);
         break;
       }
@@ -188,17 +188,17 @@
     {
       uint32_t tmp_len;
       tmp_len= system_charset_info->cset->charpos(system_charset_info,
-						  field_arg->comment.str,
-						  field_arg->comment.str +
-						  field_arg->comment.length,
-						  COLUMN_COMMENT_MAXLEN);
+                                                  field_arg->comment.str,
+                                                  field_arg->comment.str +
+                                                  field_arg->comment.length,
+                                                  COLUMN_COMMENT_MAXLEN);
 
       if (tmp_len < field_arg->comment.length)
       {
-	my_error(ER_WRONG_STRING_LENGTH, MYF(0),
-		 field_arg->comment.str,"COLUMN COMMENT",
-		 (uint32_t) COLUMN_COMMENT_MAXLEN);
-	return(1);
+        my_error(ER_WRONG_STRING_LENGTH, MYF(0),
+                 field_arg->comment.str,"COLUMN COMMENT",
+                 (uint32_t) COLUMN_COMMENT_MAXLEN);
+        return(1);
       }
 
       if (! use_existing_fields)
@@ -244,83 +244,46 @@
  
       if (field_arg->def->is_null())
       {
-	field_options->set_default_null(true);
+        field_options->set_default_null(true);
       }
       else
       {
-	String d;
-	String *default_value= field_arg->def->val_str(&d);
-
-	assert(default_value);
-
-	if ((field_arg->sql_type==DRIZZLE_TYPE_VARCHAR
-	   || field_arg->sql_type==DRIZZLE_TYPE_BLOB)
-	   && ((field_arg->length / field_arg->charset->mbmaxlen)
-	   < default_value->length()))
-	{
-	  my_error(ER_INVALID_DEFAULT, MYF(0), field_arg->field_name);
-	  return 1;
-	}
-
-        if (field_arg->sql_type == DRIZZLE_TYPE_DATE
-            || field_arg->sql_type == DRIZZLE_TYPE_DATETIME
-            || field_arg->sql_type == DRIZZLE_TYPE_TIMESTAMP)
-        {
-          DRIZZLE_TIME ltime;
-
-          if (field_arg->def->get_date(&ltime, TIME_FUZZY_DATE))
-          {
-            my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR),
-                     default_value->c_str());
-            return 1;
-          }
-
-          /* We now do the casting down to the appropriate type.
-
-             Yes, this implicit casting is balls.
-             It was previously done on reading the proto back in,
-             but we really shouldn't store the bogus things in the proto,
-             and instead do the casting behaviour here.
-
-             the timestamp errors are taken care of elsewhere.
-          */
-
-          if (field_arg->sql_type == DRIZZLE_TYPE_DATETIME)
-          {
-            Item *typecast= new Item_datetime_typecast(field_arg->def);
-            typecast->quick_fix_field();
-            typecast->val_str(default_value);
-          }
-          else if (field_arg->sql_type == DRIZZLE_TYPE_DATE)
-          {
-            Item *typecast= new Item_date_typecast(field_arg->def);
-            typecast->quick_fix_field();
-            typecast->val_str(default_value);
-          }
-        }
-
-	if ((field_arg->sql_type==DRIZZLE_TYPE_VARCHAR
-	    && field_arg->charset==&my_charset_bin)
-	   || (field_arg->sql_type==DRIZZLE_TYPE_BLOB
-	    && field_arg->charset==&my_charset_bin))
-	{
-	  string bin_default;
-	  bin_default.assign(default_value->c_ptr(),
-			     default_value->length());
-	  field_options->set_default_bin_value(bin_default);
-	}
-	else
-	{
-	  field_options->set_default_value(default_value->c_ptr());
-	}
+        String d;
+        String *default_value= field_arg->def->val_str(&d);
+
+        assert(default_value);
+
+        if ((field_arg->sql_type==DRIZZLE_TYPE_VARCHAR
+           || field_arg->sql_type==DRIZZLE_TYPE_BLOB)
+           && ((field_arg->length / field_arg->charset->mbmaxlen)
+           < default_value->length()))
+        {
+          my_error(ER_INVALID_DEFAULT, MYF(0), field_arg->field_name);
+          return 1;
+        }
+
+        if ((field_arg->sql_type==DRIZZLE_TYPE_VARCHAR
+            && field_arg->charset==&my_charset_bin)
+           || (field_arg->sql_type==DRIZZLE_TYPE_BLOB
+            && field_arg->charset==&my_charset_bin))
+        {
+          string bin_default;
+          bin_default.assign(default_value->c_ptr(),
+                             default_value->length());
+          field_options->set_default_bin_value(bin_default);
+        }
+        else
+        {
+          field_options->set_default_value(default_value->c_ptr());
+        }
       }
     }
 
     assert(field_arg->unireg_check == Field::NONE
-	   || field_arg->unireg_check == Field::NEXT_NUMBER
-	   || field_arg->unireg_check == Field::TIMESTAMP_DN_FIELD
-	   || field_arg->unireg_check == Field::TIMESTAMP_UN_FIELD
-	   || field_arg->unireg_check == Field::TIMESTAMP_DNUN_FIELD);
+           || field_arg->unireg_check == Field::NEXT_NUMBER
+           || field_arg->unireg_check == Field::TIMESTAMP_DN_FIELD
+           || field_arg->unireg_check == Field::TIMESTAMP_UN_FIELD
+           || field_arg->unireg_check == Field::TIMESTAMP_DNUN_FIELD);
 
   }
 
@@ -353,7 +316,7 @@
   if (create_info->default_table_charset)
   {
     table_options->set_collation_id(
-			       create_info->default_table_charset->number);
+                               create_info->default_table_charset->number);
     table_options->set_collation(create_info->default_table_charset->name);
   }
 
@@ -428,17 +391,17 @@
     {
       uint32_t tmp_len;
       tmp_len= system_charset_info->cset->charpos(system_charset_info,
-						  key_info[i].comment.str,
-						  key_info[i].comment.str +
-						  key_info[i].comment.length,
-						  TABLE_COMMENT_MAXLEN);
+                                                  key_info[i].comment.str,
+                                                  key_info[i].comment.str +
+                                                  key_info[i].comment.length,
+                                                  TABLE_COMMENT_MAXLEN);
 
       if (tmp_len < key_info[i].comment.length)
       {
-	my_error(ER_WRONG_STRING_LENGTH, MYF(0),
-		 key_info[i].comment.str,"Index COMMENT",
-		 (uint32_t) TABLE_COMMENT_MAXLEN);
-	return(1);
+        my_error(ER_WRONG_STRING_LENGTH, MYF(0),
+                 key_info[i].comment.str,"Index COMMENT",
+                 (uint32_t) TABLE_COMMENT_MAXLEN);
+        return(1);
       }
 
       idx->set_comment(key_info[i].comment.str);
@@ -512,14 +475,14 @@
 
   SYNOPSIS
     rea_create_table()
-    session			Thread handler
-    path		Name of file (including database, without .frm)
-    db			Data base name
-    table_name		Table name
-    create_info		create info parameters
-    create_fields	Fields to create
-    keys		number of keys to create
-    key_info		Keys to create
+    session                        Thread handler
+    path                Name of file (including database, without .frm)
+    db                        Data base name
+    table_name                Table name
+    create_info                create info parameters
+    create_fields        Fields to create
+    keys                number of keys to create
+    key_info                Keys to create
 
   RETURN
     0  ok

=== modified file 'drizzled/table_share.cc'
--- drizzled/table_share.cc	2010-08-07 17:38:08 +0000
+++ drizzled/table_share.cc	2010-08-15 23:41:09 +0000
@@ -256,7 +256,7 @@
 
     return NULL;
   }
-  share->ref_count++;				// Mark in use
+  share->ref_count++;// Mark in use
   
   plugin::EventObserver::registerTableEvents(*share);
   
@@ -1399,14 +1399,14 @@
 
         for (int valnr= 0; valnr < fo.field_value_size(); valnr++)
         {
-          if (fo.field_value(valnr).length() > field_length)
-          {
-            field_length= charset->cset->numchars(charset,
-                                                  fo.field_value(valnr).c_str(),
-                                                  fo.field_value(valnr).c_str()
-                                                  + fo.field_value(valnr).length())
-              * charset->mbmaxlen;
-          }
+          uint32_t length;
+          length= charset->cset->numchars(charset,
+                                          fo.field_value(valnr).c_str(),
+                                          fo.field_value(valnr).c_str()
+                                          + fo.field_value(valnr).length())
+                                          * charset->mbmaxlen;
+          if (length > field_length)
+            field_length= length;
         }
       }
       break;
@@ -1565,6 +1565,7 @@
         }
       }
 
+      keyinfo->extra_length= 0;
       for (uint32_t i= 0 ; i < keyinfo->key_parts ; key_part++,i++)
       {
         Field *local_field;
@@ -1756,10 +1757,8 @@
 int TableShare::open_table_def(Session& session, TableIdentifier &identifier)
 {
   int local_error;
-  bool error_given;
 
   local_error= 1;
-  error_given= 0;
 
   message::Table table;
 
@@ -1775,19 +1774,17 @@
     else
     {
       if (not table.IsInitialized())
-      {
         local_error= 4;
-      }
     }
-    goto err_not_open;
-  }
-
-  local_error= parse_table_proto(session, table);
-
-  setTableCategory(TABLE_CATEGORY_USER);
-
-err_not_open:
-  if (local_error && !error_given)
+  }
+  else
+  {
+    local_error= parse_table_proto(session, table);
+
+    setTableCategory(TABLE_CATEGORY_USER);
+  }
+
+  if (local_error)
   {
     error= local_error;
     open_table_error(error, (open_errno= errno), 0);

=== modified file 'drizzled/table_share.h'
--- drizzled/table_share.h	2010-08-06 00:16:27 +0000
+++ drizzled/table_share.h	2010-08-15 23:41:09 +0000
@@ -31,6 +31,7 @@
 #include <boost/unordered_map.hpp>
 
 #include "drizzled/typelib.h"
+#include "drizzled/identifier.h"
 #include "drizzled/memory/root.h"
 #include "drizzled/message/table.pb.h"
 #include "drizzled/util/string.h"
@@ -183,7 +184,7 @@
 
 private:
   std::vector<std::string> _keynames;
-
+protected:
   void addKeyName(std::string arg)
   {
     std::transform(arg.begin(), arg.end(),

=== added file 'unittests/generator.cc'
--- unittests/generator.cc	1970-01-01 00:00:00 +0000
+++ unittests/generator.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,61 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/drizzled.h>
+#include <drizzled/item.h>
+#include <drizzled/plugin/listen.h>
+#include <drizzled/session.h>
+#include <drizzled/sql_lex.h>
+
+#include "generator.h"
+
+using namespace drizzled;
+
+Session *Generator::SessionGenerator::make_fake_session()
+{
+  Session *fake_session;
+  
+  plugin::Client *fake_client;
+  fake_client= plugin::Listen::getNullClient();
+  fake_session= new Session(fake_client);
+  fake_session->thread_stack= (char*) &fake_session;
+  init_thread_environment();
+  fake_session->initGlobals();
+
+  return fake_session;
+}
+
+void Generator::SelectLexGenerator::make_Select_Lex_empty_for_print(Select_Lex *select_lex)
+{
+  select_lex->options= 0;
+  select_lex->set_braces(false);
+  select_lex->table_list.elements= NULL;
+  select_lex->where= NULL;
+  select_lex->group_list.elements= NULL;
+  select_lex->olap= CUBE_TYPE;
+  select_lex->having= NULL;
+  select_lex->join= NULL;
+  select_lex->order_list.elements= NULL;
+  select_lex->explicit_limit= NULL;
+  select_lex->cond_value= Item::COND_UNDEF;
+  select_lex->having_value= Item::COND_UNDEF;
+}

=== added file 'unittests/generator.h'
--- unittests/generator.h	1970-01-01 00:00:00 +0000
+++ unittests/generator.h	2010-08-15 23:41:09 +0000
@@ -0,0 +1,48 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#ifndef UNITTESTS_GENERATOR_H
+#define UNITTESTS_GENERATOR_H
+
+#include "drizzled/message/table.pb.h"
+
+namespace drizzled
+{
+  class Session;
+  class Select_Lex;
+}
+
+class Generator
+{
+public:
+  class SessionGenerator
+  {
+  public:
+    static drizzled::Session *make_fake_session();
+  };
+
+  class SelectLexGenerator
+  {
+  public:
+    static void make_Select_Lex_empty_for_print(drizzled::Select_Lex *select_lex);
+  };
+};
+
+#endif

=== modified file 'unittests/include.am'
--- unittests/include.am	2010-07-07 06:52:54 +0000
+++ unittests/include.am	2010-08-15 23:41:09 +0000
@@ -8,32 +8,57 @@
 
 noinst_HEADERS += \
 		  unittests/plugin/plugin_stubs.h \
+		  unittests/stubs.h \
 		  unittests/temporal_generator.h
 
 unit: unittests/unittests
 	unittests/unittests
 
 unittests_unittests_SOURCES = \
-			      unittests/atomics_test.cc \
-			      unittests/calendar_test.cc \
-			      unittests/date_test.cc \
-			      unittests/date_time_test.cc \
-			      unittests/generators.cc \
-			      unittests/main.cc \
-			      unittests/micro_timestamp_test.cc \
-			      unittests/nano_timestamp_test.cc \
-			      unittests/option_context.cc \
-			      unittests/plugin/authentication_test.cc \
-			      unittests/plugin/client_test.cc \
-			      unittests/plugin/error_message_test.cc \
-			      unittests/pthread_atomics_test.cc \
-			      unittests/table_identifier.cc \
-			      unittests/temporal_format_test.cc \
-			      unittests/temporal_generator.cc \
-			      unittests/temporal_interval_test.cc \
-			      unittests/time_test.cc \
-			      unittests/timestamp_test.cc \
-			      unittests/utf8_test.cc
+			     unittests/atomics_test.cc \
+			     unittests/calendar_test.cc \
+					 unittests/date_test.cc \
+					 unittests/date_time_test.cc \
+					 unittests/generator.cc \
+					 unittests/generators.cc \
+			     unittests/main.cc \
+					 unittests/micro_timestamp_test.cc \
+					 unittests/nano_timestamp_test.cc \
+					 unittests/option_context.cc \
+					 unittests/plugin/authentication_test.cc \
+					 unittests/plugin/authorization_test.cc \
+					 unittests/plugin/client_test.cc \
+					 unittests/plugin/error_message_test.cc \
+					 unittests/plugin/event_observer_test.cc \
+					 unittests/plugin/function_test.cc \
+					 unittests/plugin/listen_test.cc \
+					 unittests/plugin/listen_tcp_test.cc \
+					 unittests/plugin/logging_test.cc \
+					 unittests/plugin/query_cache_test.cc \
+					 unittests/plugin/query_rewrite_test.cc \
+					 unittests/plugin/scheduler_test.cc \
+					 unittests/plugin/schema_engine_test.cc \
+					 unittests/plugin/storage_engine_test.cc \
+					 unittests/plugin/table_function_test.cc \
+					 unittests/plugin/transactional_storage_engine_test.cc \
+					 unittests/plugin/transaction_applier_test.cc \
+					 unittests/plugin/transaction_replicator_test.cc \
+					 unittests/plugin/xa_resource_manager_test.cc \
+					 unittests/plugin/xa_storage_engine_test.cc \
+			     unittests/pthread_atomics_test.cc \
+					 unittests/stubs.cc \
+					 unittests/table_identifier.cc \
+					 unittests/table_identifier_test.cc \
+					 unittests/table_list_test.cc \
+					 unittests/table_proto_write_test.cc \
+					 unittests/table_share_test.cc \
+					 unittests/temporal_format_test.cc \
+					 unittests/temporal_generator.cc \
+					 unittests/temporal_interval_test.cc \
+					 unittests/time_test.cc \
+					 unittests/timestamp_test.cc \
+					 unittests/utf8_test.cc
+
 
 unittests_unittests_LDADD= \
   $(filter-out drizzled/main.$(OBJEXT), ${am_drizzled_drizzled_OBJECTS}) \

=== modified file 'unittests/plugin/authentication_test.cc'
--- unittests/plugin/authentication_test.cc	2010-06-10 20:26:28 +0000
+++ unittests/plugin/authentication_test.cc	2010-08-15 23:41:09 +0000
@@ -27,16 +27,10 @@
 #include <string>
 
 #include "plugin_stubs.h"
+#include "../stubs.h"
 
 using namespace drizzled;
 
-static void error_handler_func_stub(uint32_t my_err, const char *str, myf MyFlags)
-{
-  (void)my_err;
-  (void)str;
-  (void)MyFlags;
-}
-
 class AuthenticationTest : public ::testing::Test
 {
 public:
@@ -52,7 +46,7 @@
   
   virtual void SetUp ()
   {
-    error_handler_hook = error_handler_func_stub;
+    error_handler_hook= error_handler_func_stub;
   }
 
   void addOnePlugin()
@@ -81,7 +75,7 @@
 
 TEST_F(AuthenticationTest, isAuthenticated_noPluginsLoaded_shouldReturn_True)
 {
-  bool authenticated = plugin::Authentication::isAuthenticated(sctx, passwd);
+  bool authenticated= plugin::Authentication::isAuthenticated(sctx, passwd);
 
   ASSERT_TRUE(authenticated);
 }
@@ -90,7 +84,7 @@
 {
 
   addOnePlugin();
-  bool authenticated = plugin::Authentication::isAuthenticated(sctx, passwd);
+  bool authenticated= plugin::Authentication::isAuthenticated(sctx, passwd);
   removeOnePlugin();
 
   ASSERT_FALSE(authenticated);
@@ -102,7 +96,7 @@
   stub1.set_authenticate_return(true);
   
   addOnePlugin();
-  bool authenticated = plugin::Authentication::isAuthenticated(sctx, passwd);
+  bool authenticated= plugin::Authentication::isAuthenticated(sctx, passwd);
   removeOnePlugin();
   
   ASSERT_TRUE(authenticated);
@@ -112,7 +106,7 @@
 {
 
   addTwoPlugins();
-  bool authenticated = plugin::Authentication::isAuthenticated(sctx, passwd);
+  bool authenticated= plugin::Authentication::isAuthenticated(sctx, passwd);
   removeTwoPlugins();
   
   ASSERT_FALSE(authenticated);
@@ -123,7 +117,7 @@
   stub2.set_authenticate_return(true);
   
   addTwoPlugins();
-  bool authenticated = plugin::Authentication::isAuthenticated(sctx, passwd);
+  bool authenticated= plugin::Authentication::isAuthenticated(sctx, passwd);
   removeTwoPlugins();
   
   ASSERT_TRUE(authenticated);

=== added file 'unittests/plugin/authorization_test.cc'
--- unittests/plugin/authorization_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/authorization_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,155 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/plugin/authorization.h>
+#include <gtest/gtest.h>
+
+#include "plugin_stubs.h"
+#include "../generator.h"
+
+using namespace drizzled;
+
+class AuthorizationTest : public ::testing::Test
+{
+protected:
+  AuthorizationStub plugin1, plugin2;
+  SecurityContext user_ctx;
+  SchemaIdentifier schema_identifier;
+  TableIdentifier *table_identifier;
+  Session *fake_session;
+  bool result;
+  SchemaIdentifiers schema_identifier_list;
+public:
+  AuthorizationTest()
+  : plugin1("AuthorizationStub1"),
+    plugin2("AuthorizationStub2"),
+    schema_identifier("stubArg")
+  {}
+
+  virtual void SetUp()
+  {
+    plugin::Authorization::addPlugin(&plugin1);
+    plugin::Authorization::addPlugin(&plugin2);
+
+    table_identifier= new TableIdentifier("SchemaNameStub",
+                             "TableNameStub",
+                             "PathStub");
+    fake_session= Generator::SessionGenerator::make_fake_session();
+  }
+  
+  virtual void TearDown()
+  {
+    delete table_identifier;
+    
+    plugin::Authorization::removePlugin(&plugin1);
+    plugin::Authorization::removePlugin(&plugin2);
+
+    schema_identifier_list.clear();
+  }
+
+  void populate_schema_identifier_list_with_3_ids()
+  {
+    schema_identifier_list.push_back(SchemaIdentifier("StubArg1"));
+    schema_identifier_list.push_back(SchemaIdentifier("StubArg2"));
+    schema_identifier_list.push_back(SchemaIdentifier("StubArg3"));
+  }
+};
+
+TEST_F(AuthorizationTest, isAuthorized_schema_twoPluginsAdded_bothAuthorizing_shouldReturn_True)
+{
+  result= plugin::Authorization::isAuthorized(user_ctx, schema_identifier, false);
+
+  ASSERT_TRUE(result);
+}
+
+TEST_F(AuthorizationTest, isAuthorized_schema_twoPluginsAdded_oneNotAuthorizing_shouldReturn_False)
+{
+  plugin2.setRestrictSchemaReturnCount(1);
+  
+  result= plugin::Authorization::isAuthorized(user_ctx, schema_identifier, false);
+  
+  ASSERT_FALSE(result);
+}
+
+
+TEST_F(AuthorizationTest, isAuthorized_table_twoPluginsAdded_bothAuthorizing_shouldReturn_True)
+{
+  result= plugin::Authorization::isAuthorized(user_ctx, *table_identifier, false);
+  
+  ASSERT_TRUE(result);
+}
+
+TEST_F(AuthorizationTest, isAuthorized_table_twoPluginsAdded_oneNotAuthorizing_shouldReturn_False)
+{
+  plugin2.setRestrictTableReturn(true);
+  
+  result= plugin::Authorization::isAuthorized(user_ctx, *table_identifier, false);
+  
+  ASSERT_FALSE(result);
+}
+
+
+TEST_F(AuthorizationTest, isAuthorized_process_twoPluginsAdded_bothAuthorizing_shouldReturn_True)
+{
+  result= plugin::Authorization::isAuthorized(user_ctx, fake_session, false);
+  
+  ASSERT_TRUE(result);
+}
+
+TEST_F(AuthorizationTest, isAuthorized_process_twoPluginsAdded_oneNotAuthorizing_shouldReturn_False)
+{
+  plugin2.setRestrictProcessReturn(true);
+  
+  result= plugin::Authorization::isAuthorized(user_ctx, fake_session, false);
+  
+  ASSERT_FALSE(result);
+}
+
+TEST_F(AuthorizationTest, pruneSchemaNames_allSchemasAuthorized_shouldLeaveListUnchanged)
+{
+  populate_schema_identifier_list_with_3_ids();
+
+  plugin::Authorization::pruneSchemaNames(user_ctx, schema_identifier_list);
+
+  ASSERT_EQ(3, schema_identifier_list.size());
+}
+
+TEST_F(AuthorizationTest, pruneSchemaNames_notAllSchemasAuthorized_shouldPruneListAppropiately)
+{
+  populate_schema_identifier_list_with_3_ids();
+  plugin2.setRestrictSchemaReturnCount(2);
+  
+  plugin::Authorization::pruneSchemaNames(user_ctx, schema_identifier_list);
+  
+  ASSERT_EQ(1, schema_identifier_list.size());
+}
+
+TEST_F(AuthorizationTest, pruneSchemaNames_AllSchemasNotAuthorized_shouldClearList)
+{
+  populate_schema_identifier_list_with_3_ids();
+  plugin2.setRestrictSchemaReturnCount(3);
+  
+  plugin::Authorization::pruneSchemaNames(user_ctx, schema_identifier_list);
+  
+  ASSERT_EQ(0, schema_identifier_list.size());
+}
+

=== modified file 'unittests/plugin/error_message_test.cc'
--- unittests/plugin/error_message_test.cc	2010-06-09 21:37:15 +0000
+++ unittests/plugin/error_message_test.cc	2010-08-15 23:41:09 +0000
@@ -27,3 +27,50 @@
 
 using namespace drizzled;
 
+class ErrorMessageTest : public ::testing::Test
+{
+protected:
+  bool result;
+  ErrorMessageStub plugin1, plugin2;
+public:
+  ErrorMessageTest()
+    : plugin1("ErrorMessageStub1"),
+      plugin2("ErrorMessageStub2")
+  {}
+
+  virtual void SetUp()
+  {
+    plugin::ErrorMessage::addPlugin(&plugin1);
+    plugin::ErrorMessage::addPlugin(&plugin2);
+  }
+
+  virtual void TearDown()
+  {
+    plugin::ErrorMessage::removePlugin(&plugin1);
+    plugin::ErrorMessage::removePlugin(&plugin2);
+  }
+};
+
+TEST_F(ErrorMessageTest, vprintf_twoPLuginsAdded_shouldReturn_False)
+{
+  result= plugin::ErrorMessage::vprintf(NULL, 0, "ErrorMessage", NULL);
+
+  ASSERT_FALSE(result);
+}
+
+TEST_F(ErrorMessageTest, vprintf_twoPLuginsAdded_oneFails_shouldReturn_True)
+{
+  plugin2.setErrmsgReturn(true);
+  
+  result= plugin::ErrorMessage::vprintf(NULL, 0, "ErrorMessage", NULL);
+  
+  ASSERT_TRUE(result);
+}
+
+TEST_F(ErrorMessageTest, vprintf_twoPLuginsAdded_shouldCall_errmsg_onBoth)
+{
+  plugin::ErrorMessage::vprintf(NULL, 0, "ErrorMessage", NULL);
+
+  ASSERT_TRUE(plugin1.getErrmsgCalled());
+  ASSERT_TRUE(plugin2.getErrmsgCalled());
+}

=== added file 'unittests/plugin/event_observer_test.cc'
--- unittests/plugin/event_observer_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/event_observer_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,306 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/plugin/event_observer.h>
+#include <drizzled/session.h>
+#include <gtest/gtest.h>
+
+#include "plugin_stubs.h"
+#include "../generator.h"
+
+using namespace drizzled;
+using namespace std;
+
+class EventObserverTest
+{
+  public:
+    bool observer1Called, observer2Called;
+    EventObserverStub observer1;
+    EventObserverStub observer2;
+    Session *fake_session;
+    string db;
+    TableShare *table_share;
+    TableIdentifier *id;
+    Table table;
+    
+    
+    EventObserverTest() :
+      observer1("EventObserverStub1"),
+      observer2("EventObserverStub2"),
+      db("")
+    {
+
+      fake_session= Generator::SessionGenerator::make_fake_session();
+      id= new TableIdentifier("SchemaNamestub",
+                                  "TableNameStub",
+                                  "PathStub");
+      table_share= new TableShare(*id);
+      table.s= table_share;
+
+      plugin::EventObserver::addPlugin(&observer1);
+      plugin::EventObserver::addPlugin(&observer2);
+    }
+
+    ~EventObserverTest()
+    {
+      plugin::EventObserver::removePlugin(&observer1);
+      plugin::EventObserver::removePlugin(&observer2);
+
+      //TODO: if we delete this the next make_fake_session call will fail
+      //delete fake_session;
+      delete table_share;
+      delete id;
+    }
+    
+};
+
+class EventObserverRegisterTest : public EventObserverTest, public ::testing::Test
+{  
+};
+
+TEST_F(EventObserverRegisterTest, registerTableEvents_twoPluginsAdded_shouldCall_registerTableEventsDo_onBoth)
+{
+  plugin::EventObserver::registerTableEvents(*table_share);
+
+  observer1Called= observer1.getRegisterTableEventsDoCalled();
+  observer2Called= observer2.getRegisterTableEventsDoCalled();
+
+  EXPECT_TRUE(observer1Called);
+  EXPECT_TRUE(observer2Called);
+}
+
+TEST_F(EventObserverRegisterTest, registerSchemaEvents_twoPluginsAdded_shouldCall_registerSchemaEventsDo_onBoth)
+{
+
+  plugin::EventObserver::registerSchemaEvents(*fake_session, db);
+  
+  observer1Called= observer1.getRegisterSchemaEventsDoCalled();
+  observer2Called= observer2.getRegisterSchemaEventsDoCalled();
+  
+  EXPECT_TRUE(observer1Called);
+  EXPECT_TRUE(observer2Called);
+}
+
+TEST_F(EventObserverRegisterTest, registerSessionEvents_twoPluginsAdded_shouldCall_registerSessionEventsDo_onBoth)
+{
+  plugin::EventObserver::registerSessionEvents(*fake_session);
+  
+  observer1Called= observer1.getRegisterSessionEventsDoCalled();
+  observer2Called= observer2.getRegisterSessionEventsDoCalled();
+  
+  EXPECT_TRUE(observer1Called);
+  EXPECT_TRUE(observer2Called);
+}
+
+class EventObserverEventTest : public ::testing::TestWithParam<bool>, public EventObserverTest
+{
+  public:
+    bool expected;
+    EventObserverEventTest()
+    {
+      expected= GetParam();
+      observer1.setRegisterAll(expected);
+      observer2.setRegisterAll(expected);
+    }
+};
+
+testing::internal::ParamGenerator<bool> gtest_twoPluginsAddedWithEventsRegistered_shouldCall_observeEventDo_onBothEventObserverEventTest_EvalGenerator_();
+INSTANTIATE_TEST_CASE_P(twoPluginsAddedWithEventsRegistered_shouldCall_observeEventDo_onBoth,
+                        EventObserverEventTest,
+                        ::testing::Values(true));
+
+testing::internal::ParamGenerator<bool> gtest_twoPluginsAddedWith_No_EventsRegistered_shouldNotCall_observeEventDo_onAnyEventObserverEventTest_EvalGenerator_();
+INSTANTIATE_TEST_CASE_P(twoPluginsAddedWith_No_EventsRegistered_shouldNotCall_observeEventDo_onAny,
+                        EventObserverEventTest,
+                        ::testing::Values(false));                        
+
+TEST_P(EventObserverEventTest, beforeDropTable)
+{
+  plugin::EventObserver::registerSchemaEvents(*fake_session, db);
+
+  plugin::EventObserver::beforeDropTable(*fake_session, *id);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, afterDropTable)
+{
+  plugin::EventObserver::registerSchemaEvents(*fake_session, db);
+  
+  plugin::EventObserver::afterDropTable(*fake_session, *id, 0);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, beforeRenameTable)
+{
+  plugin::EventObserver::registerSchemaEvents(*fake_session, db);
+  
+  plugin::EventObserver::beforeRenameTable(*fake_session, *id, *id);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, afterRenameTable)
+{
+  plugin::EventObserver::registerSchemaEvents(*fake_session, db);
+  
+  plugin::EventObserver::afterRenameTable(*fake_session, *id, *id, 0);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+
+
+TEST_P(EventObserverEventTest, beforeInsertRecord)
+{
+  plugin::EventObserver::registerTableEvents(*table_share);
+  
+  plugin::EventObserver::beforeInsertRecord(table, NULL);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, afterInsertRecord)
+{
+  plugin::EventObserver::registerTableEvents(*table_share);
+  
+  plugin::EventObserver::afterInsertRecord(table, NULL, 0);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, beforeDeleteRecord)
+{
+  plugin::EventObserver::registerTableEvents(*table_share);
+  
+  plugin::EventObserver::beforeDeleteRecord(table, NULL);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, afterDeleteRecord)
+{
+  plugin::EventObserver::registerTableEvents(*table_share);
+  
+  plugin::EventObserver::afterDeleteRecord(table, NULL, 0);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, beforeUpdateRecord)
+{
+  plugin::EventObserver::registerTableEvents(*table_share);
+  
+  plugin::EventObserver::beforeUpdateRecord(table, NULL, NULL);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, afterUpdateRecord)
+{
+  plugin::EventObserver::registerTableEvents(*table_share);
+  
+  plugin::EventObserver::afterUpdateRecord(table, NULL, NULL, 0);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+
+
+TEST_P(EventObserverEventTest, beforeCreateDatabase)
+{
+  plugin::EventObserver::registerSessionEvents(*fake_session);
+  
+  plugin::EventObserver::beforeCreateDatabase(*fake_session, db);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, afterCreateDatabase)
+{
+  plugin::EventObserver::registerSessionEvents(*fake_session);
+  
+  plugin::EventObserver::afterCreateDatabase(*fake_session, db, 0);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, beforeDropDatabase)
+{
+  plugin::EventObserver::registerSessionEvents(*fake_session);
+  
+  plugin::EventObserver::beforeDropDatabase(*fake_session, db);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}
+
+TEST_P(EventObserverEventTest, afterDropDatabase)
+{
+  plugin::EventObserver::registerSessionEvents(*fake_session);
+  
+  plugin::EventObserver::afterDropDatabase(*fake_session, db, 0);
+  observer1Called= observer1.getObserveEventDoCalled();
+  observer2Called= observer2.getObserveEventDoCalled();
+  
+  EXPECT_EQ(expected, observer1Called);
+  EXPECT_EQ(expected, observer2Called);
+}

=== added file 'unittests/plugin/function_test.cc'
--- unittests/plugin/function_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/function_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,84 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <cstring>
+#include <drizzled/plugin/function.h>
+#include <gtest/gtest.h>
+
+#include "plugin_stubs.h"
+
+using namespace drizzled;
+
+TEST(FunctionTest, addPlugin_shouldReturn_False)
+{
+  bool result;
+  FunctionStub *function= new FunctionStub("Function");
+
+  result= plugin::Function::addPlugin(function);
+
+  plugin::Function::removePlugin(function);
+  delete function;
+  
+  ASSERT_FALSE(result);
+}
+
+TEST(FunctionTest, addPlugin_addSecondPluginWithIdenticalName_shouldReturn_True)
+{
+  bool result;
+  FunctionStub *function= new FunctionStub("Function");
+  FunctionStub *function2= new FunctionStub("Function");
+
+  plugin::Function::addPlugin(function);
+  result= plugin::Function::addPlugin(function2);
+
+  plugin::Function::removePlugin(function);
+  delete function;
+  delete function2;
+  
+  ASSERT_TRUE(result);
+}
+
+TEST(FunctionTest, get_addedFunctionPlugin_shouldReturn_pointerToPlugin)
+{
+  const plugin::Function *function_ptr;
+  const char name[]= "Function";
+  FunctionStub *function= new FunctionStub(name);
+  plugin::Function::addPlugin(function);
+
+  function_ptr= plugin::Function::get(name, strlen(name));
+  
+  plugin::Function::removePlugin(function);
+  delete function;
+  
+  ASSERT_EQ(function, function_ptr);
+}
+
+TEST(FunctionTest, get_notAddedFunctionPlugin_shouldReturn_NULL)
+{
+  const plugin::Function *function_ptr;
+  const char name[]= "Function";
+
+  function_ptr= plugin::Function::get(name, strlen(name));
+  
+  ASSERT_EQ(NULL, function_ptr);
+}
+ 
\ No newline at end of file

=== added file 'unittests/plugin/listen_tcp_test.cc'
--- unittests/plugin/listen_tcp_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/listen_tcp_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,1 @@
+ 

=== added file 'unittests/plugin/listen_test.cc'
--- unittests/plugin/listen_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/listen_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,86 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/plugin/listen.h>
+#include <gtest/gtest.h>
+#include <unistd.h>
+
+#include "plugin_stubs.h"
+
+using namespace drizzled;
+
+TEST(ListenTest, setup_onePluginAdded_noFileDescriptorsRegistered_shouldReturn_True)
+{
+  bool result;
+  ListenStub pluginStub("ListenStub");
+  plugin::Listen::addPlugin(&pluginStub);
+
+  result= plugin::Listen::setup();
+
+  ASSERT_TRUE(result);
+
+  plugin::Listen::removePlugin(&pluginStub);
+}
+
+TEST(ListenTest, setup_onePluginAdded_oneFileDescriptorRegistered_shouldReturn_False)
+{
+  bool result;
+  ListenStub pluginStub("ListenStub");
+  pluginStub.setFileDescriptorToSet(111);/* some rubbish number, not an actual file descriptor*/
+  plugin::Listen::addPlugin(&pluginStub);
+  
+  result= plugin::Listen::setup();
+  
+  ASSERT_FALSE(result);
+
+  plugin::Listen::removePlugin(&pluginStub);
+  plugin::Listen::shutdown();
+  plugin::Listen::getClient();
+}
+
+TEST(ListenTest, getClient_onePluginAdded_oneFileDescriptorRegisteredAndWrittenTo_shouldReturn_setClientPointer)
+{
+  ListenStub pluginStub("ListenStub");
+  int sample_pipe[2];
+  ssize_t bytes;
+  plugin::Client *returnedClient;
+  int ret;
+
+  /* the necessary setup */
+  ret= pipe(sample_pipe);
+  pluginStub.setFileDescriptorToSet(sample_pipe[0]);
+  pluginStub.setClientPointerToReturn((plugin::Client *) 123456);
+  plugin::Listen::addPlugin(&pluginStub);
+  plugin::Listen::setup();
+
+  /* need to write first becasue the internal reads are blocking */
+  bytes= write(sample_pipe[1], "\0", 1);
+  ASSERT_EQ(1, bytes);
+  returnedClient= plugin::Listen::getClient();
+
+  ASSERT_EQ(123456, (size_t) returnedClient);
+
+  plugin::Listen::removePlugin(&pluginStub);
+  plugin::Listen::shutdown();
+  plugin::Listen::getClient();
+}
+

=== added file 'unittests/plugin/logging_test.cc'
--- unittests/plugin/logging_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/logging_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,91 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Pawel Blokus
+ *
+ *  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; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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
+ */
+
+#include "config.h"
+
+#include <drizzled/plugin/logging.h>
+#include <gtest/gtest.h>
+
+#include "plugin_stubs.h"
+#include "../generator.h"
+
+using namespace drizzled;
+
+class LoggingTest : public ::testing::Test
+{
+protected:
+  LoggingStub plugin1, plugin2;
+public:
+  LoggingTest()
+    : plugin1("LoggingStub1"),
+      plugin2("LoggingStub2")
+  {}
+
+  virtual void SetUp()
+  {
+    plugin::Logging::addPlugin(&plugin1);
+    plugin::Logging::addPlugin(&plugin2);
+  }
+
+  virtual void TearDown()
+  {
+    plugin::Logging::removePlugin(&plugin1);
+    plugin::Logging::removePlugin(&plugin2);
+  }
+};
+
+TEST_F(LoggingTest, preDo_twoPluginsAdded_shouldCall_pre_only_OnBothPlugins)
+{
+  plugin::Logging::preDo(NULL);
+
+  EXPECT_TRUE(plugin1.getPreCalled());
+  EXPECT_FALSE(plugin1.getPostCalled());
+  EXPECT_FALSE(plugin1.getPostEndCalled());
+
+  EXPECT_TRUE(plugin2.getPreCalled());
+  EXPECT_FALSE(plugin2.getPostCalled());
+  EXPECT_FALSE(plugin2.getPostEndCalled());
+}
+
+TEST_F(LoggingTest, postDo_twoPluginsAdded_shouldCall_post_only_OnBothPlugins)
+{
+  plugin::Logging::postDo(NULL);
+  
+  EXPECT_FALSE(plugin1.getPreCalled());
+  EXPECT_TRUE(plugin1.getPostCalled());
+  EXPECT_FALSE(plugin1.getPostEndCalled());
+  
+  EXPECT_FALSE(plugin2.getPreCalled());
+  EXPECT_TRUE(plugin2.getPostCalled());
+  EXPECT_FALSE(plugin2.getPostEndCalled());
+}
+
+TEST_F(LoggingTest, postEndDo_twoPluginsAdded_shouldCall_postEnd_only_OnBothPlugins)
+{
+  plugin::Logging::postEndDo(NULL);
+  
+  EXPECT_FALSE(plugin1.getPreCalled());
+  EXPECT_FALSE(plugin1.getPostCalled());
+  EXPECT_TRUE(plugin1.getPostEndCalled());
+  
+  EXPECT_FALSE(plugin2.getPreCalled());
+  EXPECT_FALSE(plugin2.getPostCalled());
+  EXPECT_TRUE(plugin2.getPostEndCalled());
+}

=== modified file 'unittests/plugin/plugin_stubs.h'
--- unittests/plugin/plugin_stubs.h	2010-06-10 20:26:28 +0000
+++ unittests/plugin/plugin_stubs.h	2010-08-15 23:41:09 +0000
@@ -26,11 +26,22 @@
 
 #include <cstring>
 #include <drizzled/plugin/authentication.h>
-#include <drizzled/plugin/client.h>
+#include <drizzled/plugin/authorization.h>
 #include <drizzled/plugin/error_message.h>
+#include <drizzled/plugin/event_observer.h>
+#include <drizzled/plugin/function.h>
+#include <drizzled/plugin/listen.h>
+#include <drizzled/plugin/logging.h>
+#include <drizzled/plugin/null_client.h>
+#include <drizzled/plugin/query_cache.h>
+#include <drizzled/plugin/query_rewrite.h>
+#include <drizzled/plugin/scheduler.h>
+#include <drizzled/plugin/storage_engine.h>
+#include <drizzled/plugin/transactional_storage_engine.h>
+#include <drizzled/plugin/xa_resource_manager.h>
 #include <string>
- 
-class ClientStub : public drizzled::plugin::Client
+
+class ClientStub : public drizzled::plugin::NullClient
 {
 protected:
   bool store_ret_val;
@@ -53,94 +64,6 @@
     last_call_char_ptr= ptr;
   }
 
-  virtual ~ClientStub() {}
-
-  /**
-  * Get attached session from the client object.
-  * @retval Session object that is attached, NULL if none.
-  */
-  virtual drizzled::Session *getSession(void)
-  {
-    return Client::getSession();
-  }
-
-  /**
-  * Attach session to the client object.
-  * @param[in] session_arg Session object to attach, or NULL to clear.
-  */
-  virtual void setSession(drizzled::Session *session_arg)
-  {
-    Client::setSession(session_arg);
-  }
-
-  /**
-  * Get file descriptor associated with client object.
-  * @retval File descriptor that is attached, -1 if none.
-  */
-  virtual int getFileDescriptor(void) { return 0; };
-
-  /**
-  * Check to see if the client is currently connected.
-  * @retval Boolean value representing connected state.
-  */
-  virtual bool isConnected(void) { return false; };
-
-  /**
-  * Check to see if the client is actively reading.
-  * @retval Boolean value representing reading state.
-  */
-  virtual bool isReading(void) { return false; };
-
-  /**
-  * Check to see if the client is actively writing.
-  * @retval Boolean value representing writing state.
-  */
-  virtual bool isWriting(void)  { return false; };
-
-  /**
-  * Flush all data that has been buffered with store() methods.
-  * @retval Boolean indicating success or failure.
-  */
-  virtual bool flush(void)  { return false; };
-
-  /**
-  * Close the client object.
-  */
-  virtual void close(void) {};
-
-  /**
-  * Perform handshake and authorize client if needed.
-  */
-  virtual bool authenticate(void) { return false; };
-
-  /**
-  * Read command from client.
-  */
-  virtual bool readCommand(char **packet, uint32_t *packet_length)
-  {
-    (void)packet;
-    (void)packet_length;
-    return false;
-  };
-
-  /* Send responses. */
-  virtual void sendOK(void) {};
-  virtual void sendEOF(void) {};
-  virtual void sendError(uint32_t sql_errno, const char *err)
-  {
-    (void)sql_errno;
-    (void)err;
-  };
-
-  /**
-  * Send field list for result set.
-  */
-  virtual bool sendFields(drizzled::List<drizzled::Item> *list)
-  {
-    (void)list;
-    return false;
-  };
-
   /* Send result fields in various forms. */
   virtual bool store(drizzled::Field *from)
   {
@@ -192,18 +115,20 @@
   {
     return Client::store(from);
   }
-
-  /* Try to remove these. */
-  virtual bool haveMoreData(void) { return false; };
-  virtual bool haveError(void) { return false; };
-  virtual bool wasAborted(void) { return false;};
 };
 
 class ErrorMessageStub : public drizzled::plugin::ErrorMessage
 {
-
+  bool errmsgCalled, errmsgReturn;
 public:
-  ErrorMessageStub() : ErrorMessage("ErrorMessageStub") {}
+  ErrorMessageStub(std::string name_arg)
+    : ErrorMessage(name_arg),
+      errmsgCalled(false),
+      errmsgReturn(false)
+  {}
+
+  void setErrmsgReturn(bool ret) { errmsgReturn= ret; };
+  bool getErrmsgCalled() { return errmsgCalled; };
 
   virtual bool errmsg(drizzled::Session *session, int priority, const char *format, va_list ap)
   {
@@ -211,7 +136,8 @@
     (void)priority;
     (void)format;
     (void)ap;
-    return false;
+    errmsgCalled= true;
+    return errmsgReturn;
   }
 };
 
@@ -228,7 +154,7 @@
 
   void set_authenticate_return(bool value)
   {
-    authenticate_return = value;
+    authenticate_return= value;
   }
 
   virtual bool authenticate(const drizzled::SecurityContext &sctx, const std::string &passwd)
@@ -239,4 +165,531 @@
   };
 };
 
+class SchedulerStub : public drizzled::plugin::Scheduler
+{
+  public:
+    SchedulerStub(std::string name_arg)
+    : Scheduler(name_arg)
+    {}
+
+    /**
+    * Add a session to the scheduler. When the scheduler is ready to run the
+    * session, it should call session->run().
+    */
+    virtual bool addSession(drizzled::Session *) { return true; }
+};
+
+class EventObserverStub : public drizzled::plugin::EventObserver
+{
+private:
+  bool registerTableEventsDoCalled;
+  bool registerSchemaEventsDoCalled;
+  bool registerSessionEventsDoCalled;
+  bool observeEventDoCalled;
+  bool registerAll;
+public:
+  EventObserverStub(std::string name_arg)
+    : EventObserver(name_arg),
+    registerTableEventsDoCalled(false),
+    registerSchemaEventsDoCalled(false),
+    registerSessionEventsDoCalled(false),
+    observeEventDoCalled(false),
+    registerAll(false)
+  {}
+
+  bool getRegisterTableEventsDoCalled() { return registerTableEventsDoCalled; };
+  bool getRegisterSchemaEventsDoCalled() { return registerSchemaEventsDoCalled; };
+  bool getRegisterSessionEventsDoCalled() { return registerSessionEventsDoCalled; };
+  bool getObserveEventDoCalled() { return observeEventDoCalled; };
+
+  void setRegisterAll(bool reg) { registerAll= reg; };
+
+  virtual bool observeEventDo(drizzled::plugin::EventData &)
+  {
+    observeEventDoCalled= true;
+    return false;
+  };
+  virtual void registerTableEventsDo(drizzled::TableShare &, drizzled::plugin::EventObserverList &observers)
+  {
+    if (registerAll)
+    {
+      registerEvent(observers, BEFORE_INSERT_RECORD);
+      registerEvent(observers, AFTER_INSERT_RECORD);
+      registerEvent(observers, BEFORE_UPDATE_RECORD);
+      registerEvent(observers, AFTER_UPDATE_RECORD);
+      registerEvent(observers, BEFORE_DELETE_RECORD);
+      registerEvent(observers, AFTER_DELETE_RECORD);
+    }
+    registerTableEventsDoCalled= true;
+  }
+  virtual void registerSchemaEventsDo(const std::string &/*db*/, drizzled::plugin::EventObserverList &observers)
+  {
+    if (registerAll)
+    {
+      registerEvent(observers, BEFORE_DROP_TABLE);
+      registerEvent(observers, AFTER_DROP_TABLE);
+      registerEvent(observers, BEFORE_RENAME_TABLE);
+      registerEvent(observers, AFTER_RENAME_TABLE);
+    }
+    registerSchemaEventsDoCalled= true;
+  }
+  virtual void registerSessionEventsDo(drizzled::Session &, drizzled::plugin::EventObserverList &observers)
+  {
+    if (registerAll)
+    {
+      registerEvent(observers, BEFORE_CREATE_DATABASE);
+      registerEvent(observers, AFTER_CREATE_DATABASE);
+      registerEvent(observers, BEFORE_DROP_DATABASE);
+      registerEvent(observers, AFTER_DROP_DATABASE);
+    }
+    registerSessionEventsDoCalled= true;
+  }
+};
+
+class FunctionStub : public drizzled::plugin::Function
+{
+public:
+  FunctionStub(std::string in_name)
+    : Function(in_name)
+  {}
+  
+  virtual result_type operator()(argument_type root) const
+  {
+    (void)root;
+    return result_type();
+  }
+};
+
+class ListenStub : public drizzled::plugin::Listen
+{
+  int fileDescriptorToSet;
+  drizzled::plugin::Client *clientPointerToReturn;
+public:
+  ListenStub(std::string name_arg) :
+    Listen(name_arg),
+    fileDescriptorToSet(0),
+    clientPointerToReturn(NULL)
+  {}
+
+  void setFileDescriptorToSet(int file_descriptor) { fileDescriptorToSet= file_descriptor; };
+  void setClientPointerToReturn(drizzled::plugin::Client *pointer)
+  {
+    clientPointerToReturn= pointer;
+  };
+    
+  virtual bool getFileDescriptors(std::vector<int> &fds)
+  {
+    if (fileDescriptorToSet != 0)
+      fds.push_back(fileDescriptorToSet);
+    return false;
+  };
+  virtual drizzled::plugin::Client *getClient(int fd)
+  {
+    (void)fd;
+    return clientPointerToReturn;
+  };
+};
+
+class LoggingStub : public drizzled::plugin::Logging
+{
+  bool preCalled, postCalled, postEndCalled;
+public:
+  LoggingStub(std::string name_arg)
+    : Logging(name_arg),
+      preCalled(false),
+      postCalled(false),
+      postEndCalled(false)
+  {}
+
+  bool getPreCalled() { return preCalled; };
+  bool getPostCalled() { return postCalled; };
+  bool getPostEndCalled() { return postEndCalled; };
+  
+  virtual bool pre(drizzled::Session *)
+  {
+    preCalled= true;
+    return false;
+  }
+  virtual bool post(drizzled::Session *)
+  {
+    postCalled= true;
+    return false;
+  }
+  virtual bool postEnd(drizzled::Session*)
+  {
+    postEndCalled= true;
+    return false;
+  }
+};
+
+class QueryCacheStub : public drizzled::plugin::QueryCache
+{
+  bool tryFetchAndSendCalled, setCalled, invalidateTableCalled, invalidateDbCalled, flushCalled;
+public:
+  QueryCacheStub(std::string name_arg)
+    : QueryCache(name_arg),
+      tryFetchAndSendCalled(false),
+      setCalled(false),
+      invalidateTableCalled(false),
+      invalidateDbCalled(false),
+      flushCalled(false)
+  {}
+
+  bool getTryFetchAndSendCalled() { return tryFetchAndSendCalled; };
+  bool getSetCalled() { return setCalled; };
+  bool getInvalidateTableCalled() { return invalidateTableCalled; };
+  bool getInvalidateDbCalled() { return invalidateDbCalled; };
+  bool getFlushCalled() { return flushCalled; };
+
+  virtual bool tryFetchAndSend(drizzled::Session *session, bool is_transactional)
+  {
+    (void)session;
+    (void)is_transactional;
+    tryFetchAndSendCalled= true;
+    return false;
+  }
+
+  virtual bool set(drizzled::Session *session, bool is_transactional)
+  {
+    (void)session;
+    (void)is_transactional;
+    setCalled= true;
+    return false;
+  }
+  virtual bool invalidateTable(drizzled::Session *session, bool is_transactional)
+  {
+    (void)session;
+    (void)is_transactional;
+    invalidateTableCalled= true;
+    return false;
+  }
+  virtual bool invalidateDb(drizzled::Session *session, const char *db_name, bool is_transactional)
+  {
+    (void)session;
+    (void)db_name;
+    (void)is_transactional;
+    invalidateDbCalled= true;
+    return false;
+  }
+  virtual bool flush(drizzled::Session *session)
+  {
+    (void)session;
+    flushCalled= true;
+    return false;
+  }
+};
+
+class QueryRewriterStub : public drizzled::plugin::QueryRewriter
+{
+  bool rewriteCalled;
+public:
+  QueryRewriterStub(std::string name_arg)
+  : QueryRewriter(name_arg),
+    rewriteCalled(false)
+  {}
+
+  bool getRewriteCalled() { return rewriteCalled; };
+  
+  virtual void rewrite(const std::string &schema, std::string &to_rewrite)
+  {
+    (void)schema;
+    (void)to_rewrite;
+    rewriteCalled= true;
+  }
+
+};
+
+class AuthorizationStub : public drizzled::plugin::Authorization
+{
+  int restrictSchemaReturnCount;/** This many first schemas will be restricted */
+  bool restrictTableReturn, restrictProcessReturn;
+public:
+  AuthorizationStub(std::string name_arg)
+  : Authorization(name_arg),
+  restrictSchemaReturnCount(0),
+    restrictTableReturn(false),
+    restrictProcessReturn(false)
+  {}
+
+  void setRestrictSchemaReturnCount(int ret) { restrictSchemaReturnCount= ret; };
+  void setRestrictTableReturn(bool ret) { restrictTableReturn= ret; };
+  void setRestrictProcessReturn(bool ret) { restrictProcessReturn= ret; };
+  
+  virtual bool restrictSchema(const drizzled::SecurityContext &user_ctx,
+                              drizzled::SchemaIdentifier &schema)
+  {
+    (void)user_ctx;
+    (void)schema;
+    return restrictSchemaReturnCount-- > 0;
+  }
+  virtual bool restrictTable(const drizzled::SecurityContext &user_ctx,
+                             drizzled::TableIdentifier &table)
+  {
+    (void)user_ctx;
+    (void)table;
+    return restrictTableReturn;
+  }
+  virtual bool restrictProcess(const drizzled::SecurityContext &user_ctx,
+                               const drizzled::SecurityContext &session_ctx)
+  {
+    (void)user_ctx;
+    (void)session_ctx;
+    return restrictProcessReturn;
+  }
+
+};
+
+class StorageEngineStub : public drizzled::plugin::StorageEngine
+{
+  bool doGetSchemaIdentifiersCalled, doGetSchemaDefinitionCalled, doCreateSchemaCalled;
+  bool doAlterSchemaCalled, doDropSchemaCalled, closeConnectionCalled, flushLogsCalled;
+  bool doRenameTableCalled, doGetTableDefinitionCalled, doDropTableCalled, doCanCreateTableCalled;
+  bool doDoesTableExistCalled;
+  bool dropSchemaReturn, alterSchemaReturn, doesTableExistReturn;
+  int doGetTableDefinitionReturn;
+  std::string engineNameToSet;
+  drizzled::message::Table *tableMessageToSet;
+public:
+  StorageEngineStub(std::string name_arg,
+      const std::bitset<drizzled::HTON_BIT_SIZE> &flags_arg= drizzled::HTON_HAS_SCHEMA_DICTIONARY)
+  : drizzled::plugin::StorageEngine(name_arg, flags_arg),
+    doGetSchemaIdentifiersCalled(false),
+    doGetSchemaDefinitionCalled(false),
+    doCreateSchemaCalled(false),
+    doAlterSchemaCalled(false),
+    doDropSchemaCalled(false),
+    closeConnectionCalled (false),
+    flushLogsCalled(false),
+    doRenameTableCalled(false),
+    doGetTableDefinitionCalled(false),
+    doDropTableCalled(false),
+    doCanCreateTableCalled(false),
+    doDoesTableExistCalled(false),
+    dropSchemaReturn(false),
+    alterSchemaReturn(false),
+    doesTableExistReturn(false),
+    doGetTableDefinitionReturn(ENOENT),
+    tableMessageToSet(NULL)
+  {}
+
+  bool getDoGetSchemaIdentifiersCalled() { return doGetSchemaIdentifiersCalled; }
+  bool getDoGetSchemaDefinitionCalled() { return doGetSchemaDefinitionCalled; }
+  bool getDoCreateSchemaCalled() { return doCreateSchemaCalled; }
+  bool getDoAlterSchemaCalled() { return doAlterSchemaCalled; }
+  bool getDoDropSchemaCalled() { return doDropSchemaCalled; }
+  bool getCloseConnectionCalled() { return closeConnectionCalled; }
+  bool getFlushLogsCalled() { return flushLogsCalled; }
+  bool getDoRenameTable() { return doRenameTableCalled; }
+  bool getDoGetTableDefinitionCalled() { return doGetTableDefinitionCalled; }
+  bool getDoDropTableCalled() { return doDropTableCalled; }
+  bool getDoCanCreateTableCalled() { return doCanCreateTableCalled; }
+  bool getDoDoesTableExistCalled() { return doDoesTableExistCalled; }
+
+  void setDropSchemaReturn(bool val) { dropSchemaReturn= val; }
+  void setAlterSchemaReturn(bool val) { alterSchemaReturn= val; }
+  void setEngineNameToSet(const std::string &nameToSet) { engineNameToSet= nameToSet; }
+  void setDoGetTableDefinitionReturn(int ret) { doGetTableDefinitionReturn= ret; }
+  void setDoesTableExistReturn(bool ret) { doesTableExistReturn= ret; }
+  void setTableMessageToSet(drizzled::message::Table *message) { tableMessageToSet= message; }
+  
+  /* parameter names are intentionally ommited, so we don't get parameter not used warnings */
+  virtual drizzled::Cursor *create(drizzled::TableShare &)
+  {
+    return NULL;
+  };
+  virtual int doCreateTable(drizzled::Session &, drizzled::Table &,
+                            const drizzled::TableIdentifier &,
+                            drizzled::message::Table &) { return 0; }
+  virtual int doRenameTable(drizzled::Session &, const drizzled::TableIdentifier &,
+                            const drizzled::TableIdentifier &)
+  {
+    doRenameTableCalled= true;
+    return 0;
+  }
+  virtual void doGetTableNames(drizzled::CachedDirectory &, const drizzled::SchemaIdentifier &,
+                               drizzled::plugin::TableNameList &) {}
+  virtual void doGetTableIdentifiers(drizzled::CachedDirectory &,
+                                     const drizzled::SchemaIdentifier &,
+                                     drizzled::TableIdentifiers &) {}
+  virtual int doDropTable(drizzled::Session &, const drizzled::TableIdentifier &)
+  {
+    doDropTableCalled= true;
+    return 0;
+  };
+  virtual const char **bas_ext() const { return NULL; }
+
+
+  virtual void doGetSchemaIdentifiers(drizzled::SchemaIdentifiers&)
+  {
+    doGetSchemaIdentifiersCalled= true;
+  }
+
+  virtual bool doGetSchemaDefinition(const drizzled::SchemaIdentifier&, drizzled::message::Schema&)
+  {
+    doGetSchemaDefinitionCalled= true;
+    return false;
+  }
+
+  virtual bool doCreateSchema(const drizzled::message::Schema&)
+  {
+    doCreateSchemaCalled= true;
+    return false;
+  }
+
+  virtual bool doAlterSchema(const drizzled::message::Schema&)
+  {
+    doAlterSchemaCalled= true;
+    return alterSchemaReturn;
+  }
+
+  virtual bool doDropSchema(const drizzled::SchemaIdentifier&)
+  {
+    doDropSchemaCalled= true;
+    return dropSchemaReturn;
+  }
+
+  virtual int close_connection(drizzled::Session  *)
+  {
+    closeConnectionCalled= true;
+    return 0;
+  }
+
+  virtual bool flush_logs()
+  {
+    flushLogsCalled= true;
+    return false;
+  }
+
+  virtual int doGetTableDefinition(drizzled::Session &session,
+                                   const drizzled::TableIdentifier &identifier,
+                                   drizzled::message::Table &table_message)
+  {
+    (void)session;
+    (void)identifier;
+
+    if (tableMessageToSet != NULL)
+      table_message= *tableMessageToSet;
+    else if (!engineNameToSet.empty())
+      table_message.mutable_engine()->set_name(engineNameToSet.c_str());
+
+    doGetTableDefinitionCalled= true;
+    return doGetTableDefinitionReturn;
+  }
+
+  virtual bool doCanCreateTable(const drizzled::TableIdentifier &)
+  {
+    doCanCreateTableCalled= true;
+    return true;
+  }
+
+  virtual bool doDoesTableExist(drizzled::Session&, const drizzled::TableIdentifier &)
+  {
+    doDoesTableExistCalled= true;
+    return doesTableExistReturn;
+  }
+
+};
+
+class TransactionalStorageEngineStub : public drizzled::plugin::TransactionalStorageEngine
+{
+  bool startTransactionCalled, doReleaseTemporaryLatchesCalled;
+public:
+  TransactionalStorageEngineStub(std::string name_arg)
+    : drizzled::plugin::TransactionalStorageEngine(name_arg, 0),
+      startTransactionCalled(false),
+      doReleaseTemporaryLatchesCalled(false)
+  {}
+
+  bool getStartTransactionCalled() { return startTransactionCalled; };
+  bool getDoReleaseTemporaryLatchesCalled() { return doReleaseTemporaryLatchesCalled; };
+
+  /* parameter names are intentionally ommited, so we don't get parameter not used warnings */
+  virtual drizzled::Cursor *create(drizzled::TableShare &)
+  {
+    return NULL;
+  };
+  virtual int doCreateTable(drizzled::Session &, drizzled::Table &,
+                            const drizzled::TableIdentifier &,
+                            drizzled::message::Table &) { return 0; }
+  virtual int doRenameTable(drizzled::Session &, const drizzled::TableIdentifier &,
+                            const drizzled::TableIdentifier &) { return 0; }
+  virtual void doGetTableNames(drizzled::CachedDirectory &, const drizzled::SchemaIdentifier &,
+                               drizzled::plugin::TableNameList &) {}
+  virtual void doGetTableIdentifiers(drizzled::CachedDirectory &,
+                                     const drizzled::SchemaIdentifier &,
+                                     drizzled::TableIdentifiers &) {}
+  virtual int doDropTable(drizzled::Session &, const drizzled::TableIdentifier &) { return 0; };
+  virtual const char **bas_ext() const { return NULL; }
+
+  
+  virtual int startTransaction(drizzled::Session *session,
+                               drizzled::start_transaction_option_t options)
+  {
+    (void)session;
+    (void)options;
+    startTransactionCalled= true;
+    return 0;
+  }
+
+  virtual int doReleaseTemporaryLatches(drizzled::Session *session)
+  {
+    (void)session;
+    doReleaseTemporaryLatchesCalled= true;
+    return 0;
+  }
+
+  /* parameter names are intentionally ommited, so we don't get parameter not used warnings */
+  virtual int doSetSavepoint(drizzled::Session *, drizzled::NamedSavepoint &) { return 0;}
+  virtual int doRollbackToSavepoint(drizzled::Session *, drizzled::NamedSavepoint &) { return 0; }
+  virtual int doReleaseSavepoint(drizzled::Session *, drizzled::NamedSavepoint &) { return 0; }
+  virtual int doCommit(drizzled::Session *, bool) { return 0; }
+  virtual int doRollback(drizzled::Session *, bool ) { return 0; }
+
+};
+
+class XaResourceManagerStub : public drizzled::plugin::XaResourceManager
+{
+  bool doXaRollbackXidCalled, doXaCommitXidCalled, xaRecoverCalled;
+  int commitRollbackReturn;
+
+  virtual int doXaCommit(drizzled::Session *, bool) { return 0; }
+  virtual int doXaRollback(drizzled::Session *, bool) { return 0; }
+  virtual int doXaPrepare(drizzled::Session *, bool) { return 0; }
+
+  virtual int doXaRollbackXid(drizzled::XID *xid)
+  {
+    (void)xid;
+    doXaRollbackXidCalled= true;
+    return commitRollbackReturn;
+  }
+  
+  virtual int doXaCommitXid(drizzled::XID *xid)
+  {
+    (void)xid;
+    doXaCommitXidCalled= true;
+    return commitRollbackReturn;
+  }
+  
+  virtual int doXaRecover(drizzled::XID *append_to, size_t len)
+  {
+    (void)append_to;
+    (void)len;
+    xaRecoverCalled= true;
+    return 0;
+  }
+public:
+  XaResourceManagerStub()
+    : doXaRollbackXidCalled(false),
+    doXaCommitXidCalled(false),
+    xaRecoverCalled(false),
+    commitRollbackReturn(0)
+  {}
+  
+  bool getDoXaRollbackXidCalled() { return doXaRollbackXidCalled; }
+  bool getDoXaCommitXidCalled() { return doXaCommitXidCalled; }
+  bool getXaRecoverCalled() { return xaRecoverCalled; }
+
+  void setCommitRollbackReturn(int value) { commitRollbackReturn= value; }
+};
+
 #endif /* UNITTESTS_STUB_PLUGIN_STUBS_H */

=== added file 'unittests/plugin/query_cache_test.cc'
--- unittests/plugin/query_cache_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/query_cache_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,138 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/plugin/query_cache.h>
+#include <gtest/gtest.h>
+
+#include "plugin_stubs.h"
+
+using namespace drizzled;
+
+
+class QueryCacheTest : public ::testing::Test
+{
+  protected:
+    QueryCacheStub plugin1, plugin2;
+  public:
+    QueryCacheTest()
+    : plugin1("QueryCacheStub1"),
+    plugin2("QueryCacheStub2")
+    {}
+    
+    virtual void SetUp()
+    {
+      plugin::QueryCache::addPlugin(&plugin1);
+      plugin::QueryCache::addPlugin(&plugin2);
+    }
+    
+    virtual void TearDown()
+    {
+      plugin::QueryCache::removePlugin(&plugin1);
+      plugin::QueryCache::removePlugin(&plugin2);
+    }
+};
+
+TEST_F(QueryCacheTest, tryFetchAndSendDo_twoPluginAdded_shouldCall_tryFetchAndSend_only_onBoth)
+{
+  plugin::QueryCache::tryFetchAndSendDo(NULL, false);
+  
+  EXPECT_TRUE(plugin1.getTryFetchAndSendCalled());
+  EXPECT_FALSE(plugin1.getSetCalled());
+  EXPECT_FALSE(plugin1.getInvalidateTableCalled());
+  EXPECT_FALSE(plugin1.getInvalidateDbCalled());
+  EXPECT_FALSE(plugin1.getFlushCalled());
+  
+  EXPECT_TRUE(plugin2.getTryFetchAndSendCalled());
+  EXPECT_FALSE(plugin2.getSetCalled());
+  EXPECT_FALSE(plugin2.getInvalidateTableCalled());
+  EXPECT_FALSE(plugin2.getInvalidateDbCalled());
+  EXPECT_FALSE(plugin2.getFlushCalled());
+}
+
+TEST_F(QueryCacheTest, setDo_twoPluginAdded_shouldCall_set_only_onBoth)
+{
+  plugin::QueryCache::setDo(NULL, false);
+  
+  EXPECT_FALSE(plugin1.getTryFetchAndSendCalled());
+  EXPECT_TRUE(plugin1.getSetCalled());
+  EXPECT_FALSE(plugin1.getInvalidateTableCalled());
+  EXPECT_FALSE(plugin1.getInvalidateDbCalled());
+  EXPECT_FALSE(plugin1.getFlushCalled());
+  
+  EXPECT_FALSE(plugin2.getTryFetchAndSendCalled());
+  EXPECT_TRUE(plugin2.getSetCalled());
+  EXPECT_FALSE(plugin2.getInvalidateTableCalled());
+  EXPECT_FALSE(plugin2.getInvalidateDbCalled());
+  EXPECT_FALSE(plugin2.getFlushCalled());
+}
+
+TEST_F(QueryCacheTest, invalidateTableDo_twoPluginAdded_shouldCall_invalidateTable_only_onBoth)
+{
+  plugin::QueryCache::invalidateTableDo(NULL, false);
+  
+  EXPECT_FALSE(plugin1.getTryFetchAndSendCalled());
+  EXPECT_FALSE(plugin1.getSetCalled());
+  EXPECT_TRUE(plugin1.getInvalidateTableCalled());
+  EXPECT_FALSE(plugin1.getInvalidateDbCalled());
+  EXPECT_FALSE(plugin1.getFlushCalled());
+  
+  EXPECT_FALSE(plugin2.getTryFetchAndSendCalled());
+  EXPECT_FALSE(plugin2.getSetCalled());
+  EXPECT_TRUE(plugin2.getInvalidateTableCalled());
+  EXPECT_FALSE(plugin2.getInvalidateDbCalled());
+  EXPECT_FALSE(plugin2.getFlushCalled());
+}
+
+TEST_F(QueryCacheTest, invalidateDbDo_twoPluginAdded_shouldCall_invalidateDb_only_onBoth)
+{
+  plugin::QueryCache::invalidateDbDo(NULL, NULL, false);
+  
+  EXPECT_FALSE(plugin1.getTryFetchAndSendCalled());
+  EXPECT_FALSE(plugin1.getSetCalled());
+  EXPECT_FALSE(plugin1.getInvalidateTableCalled());
+  EXPECT_TRUE(plugin1.getInvalidateDbCalled());
+  EXPECT_FALSE(plugin1.getFlushCalled());
+  
+  EXPECT_FALSE(plugin2.getTryFetchAndSendCalled());
+  EXPECT_FALSE(plugin2.getSetCalled());
+  EXPECT_FALSE(plugin2.getInvalidateTableCalled());
+  EXPECT_TRUE(plugin2.getInvalidateDbCalled());
+  EXPECT_FALSE(plugin2.getFlushCalled());
+}
+
+TEST_F(QueryCacheTest, flushDo_twoPluginAdded_shouldCall_flush_only_onBoth)
+{
+  plugin::QueryCache::flushDo(NULL);
+  
+  EXPECT_FALSE(plugin1.getTryFetchAndSendCalled());
+  EXPECT_FALSE(plugin1.getSetCalled());
+  EXPECT_FALSE(plugin1.getInvalidateTableCalled());
+  EXPECT_FALSE(plugin1.getInvalidateDbCalled());
+  EXPECT_TRUE(plugin1.getFlushCalled());
+  
+  EXPECT_FALSE(plugin2.getTryFetchAndSendCalled());
+  EXPECT_FALSE(plugin2.getSetCalled());
+  EXPECT_FALSE(plugin2.getInvalidateTableCalled());
+  EXPECT_FALSE(plugin2.getInvalidateDbCalled());
+  EXPECT_TRUE(plugin2.getFlushCalled());
+}
+

=== added file 'unittests/plugin/query_rewrite_test.cc'
--- unittests/plugin/query_rewrite_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/query_rewrite_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,47 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/plugin/query_rewrite.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "plugin_stubs.h"
+
+using namespace drizzled;
+using namespace std;
+
+TEST(QueryRewriteTest, rewriteQuery_twoPluginsAdded_shouldCall_rewrite_onBoth)
+{
+  QueryRewriterStub plugin1("QueryCacheStub1");
+  QueryRewriterStub plugin2("QueryCacheStub2");
+  plugin::QueryRewriter::addPlugin(&plugin1);
+  plugin::QueryRewriter::addPlugin(&plugin2);
+  string stubString;
+
+  plugin::QueryRewriter::rewriteQuery(stubString, stubString);
+
+  EXPECT_TRUE(plugin1.getRewriteCalled());
+  EXPECT_TRUE(plugin2.getRewriteCalled());
+  
+  plugin::QueryRewriter::removePlugin(&plugin1);
+  plugin::QueryRewriter::removePlugin(&plugin2);
+}

=== added file 'unittests/plugin/scheduler_test.cc'
--- unittests/plugin/scheduler_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/scheduler_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,103 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/plugin/scheduler.h>
+#include <gtest/gtest.h>
+
+#include "plugin_stubs.h"
+
+using namespace drizzled;
+
+class SchedulerTest : public ::testing::Test
+{
+public:
+  bool result;
+  SchedulerStub sched1;
+  SchedulerStub sched2;
+
+  SchedulerTest() : sched1("SchedulerStub1"), sched2("SchedulerStub2") {}
+
+  virtual void SetUp()
+  {
+    plugin::Scheduler::addPlugin(&sched1);
+    plugin::Scheduler::addPlugin(&sched2);
+  }
+
+  virtual void TearDown()
+  {
+    plugin::Scheduler::removePlugin(&sched1);
+    plugin::Scheduler::removePlugin(&sched2);
+  }
+
+};
+
+
+TEST(SchedulerAddPluginTest, addPlugin_shouldReturn_False)
+{
+  bool result;
+  SchedulerStub sched1("SchedulerStub1");
+  
+  result= plugin::Scheduler::addPlugin(&sched1);
+
+  ASSERT_FALSE(result);
+
+  plugin::Scheduler::removePlugin(&sched1);
+}
+
+TEST_F(SchedulerTest, addPlugin_registerTwoSchedulersWithIdenticalName_shouldReturn_True)
+{
+  SchedulerStub sched3("SchedulerStub1");
+
+  result= plugin::Scheduler::addPlugin(&sched3);
+
+  ASSERT_TRUE(result);
+}
+
+TEST_F(SchedulerTest, setPlugin_twoPluginsAdded_setPluginShouldBeActivated)
+{
+  result= plugin::Scheduler::setPlugin("SchedulerStub2");
+
+  ASSERT_FALSE(result);
+  ASSERT_TRUE(sched2.isActive());
+}
+
+TEST_F(SchedulerTest, setPlugin_twoPluginsAdded_previoslySetPluginShouldBeDeactivated)
+{
+
+
+  plugin::Scheduler::setPlugin("SchedulerStub1");
+
+  result= plugin::Scheduler::setPlugin("SchedulerStub2");
+
+  ASSERT_FALSE(result);
+  ASSERT_FALSE(sched1.isActive());
+}
+
+TEST_F(SchedulerTest, setPlugin_twoPluginsAdded_useWrongName_shouldReturn_True)
+{
+  plugin::Scheduler::addPlugin(&sched1);
+  plugin::Scheduler::addPlugin(&sched2);
+  
+  result= plugin::Scheduler::setPlugin("WrongName");
+  
+  ASSERT_TRUE(result);
+}

=== added file 'unittests/plugin/schema_engine_test.cc'
--- unittests/plugin/schema_engine_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/schema_engine_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,152 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/plugin/storage_engine.h>
+#include <drizzled/table.h>
+#include <gtest/gtest.h>
+
+#include "../generator.h"
+#include "plugin_stubs.h"
+
+using namespace drizzled;
+
+class SchemaEngineTest : public ::testing::Test
+{
+protected:
+  StorageEngineStub plugin1, plugin2;
+  Session *fake_session;
+  SchemaIdentifier schema_identifier;
+  bool result;
+  message::Schema proto;
+  
+public:
+  SchemaEngineTest()
+  : plugin1("StorageEngineStub1"),
+    plugin2("StorageEngineStub2"),
+    schema_identifier("stubArg")
+  {}
+
+  virtual void SetUp()
+  {
+    fake_session= Generator::SessionGenerator::make_fake_session();
+    plugin::StorageEngine::addPlugin(&plugin1);
+    plugin::StorageEngine::addPlugin(&plugin2);
+  }
+
+  virtual void TearDown()
+  {
+    plugin::StorageEngine::removePlugin(&plugin1);
+    plugin::StorageEngine::removePlugin(&plugin2);
+  }
+};
+
+TEST_F(SchemaEngineTest, getIdentifiers_twoPluginsAdded_ShouldCall_doGetSchemaIdentifiers_onBoth)
+{
+  SchemaIdentifiers shema_id_list;
+  plugin::StorageEngine::getIdentifiers(*fake_session, shema_id_list);
+
+  ASSERT_TRUE(plugin1.getDoGetSchemaIdentifiersCalled());
+  ASSERT_TRUE(plugin2.getDoGetSchemaIdentifiersCalled());
+}
+
+TEST_F(SchemaEngineTest, getSchemaDefinition_TableIdentifier_twoPluginsAdded_ShouldCall_doGetSchemaDefinition_onBoth)
+{
+  TableIdentifier identifier("SchemaNameStub",
+                             "TableNameStub",
+                             "PathStub");
+  TableShare table_share(identifier);
+  plugin::StorageEngine::getSchemaDefinition(identifier, proto);
+  
+  ASSERT_TRUE(plugin1.getDoGetSchemaDefinitionCalled());
+  ASSERT_TRUE(plugin2.getDoGetSchemaDefinitionCalled());
+}
+
+TEST_F(SchemaEngineTest, getSchemaDefinition_SchemaIdentifier_twoPluginsAdded_ShouldCall_doGetSchemaDefinition_onBoth)
+{
+  plugin::StorageEngine::getSchemaDefinition(schema_identifier, proto);
+  
+  ASSERT_TRUE(plugin1.getDoGetSchemaDefinitionCalled());
+  ASSERT_TRUE(plugin2.getDoGetSchemaDefinitionCalled());
+}
+
+TEST_F(SchemaEngineTest, createSchema_twoPluginsAdded_ShouldCall_doCreateSchemaCalled_onBoth)
+{
+  plugin::StorageEngine::createSchema(proto);
+  
+  ASSERT_TRUE(plugin1.getDoCreateSchemaCalled());
+  ASSERT_TRUE(plugin2.getDoCreateSchemaCalled());
+}
+
+TEST_F(SchemaEngineTest, dropSchema_twoPluginsAdded_ShouldCall_doDropSchemaCalled_onBoth)
+{
+  plugin::StorageEngine::dropSchema(schema_identifier);
+  
+  ASSERT_TRUE(plugin1.getDoDropSchemaCalled());
+  ASSERT_TRUE(plugin2.getDoDropSchemaCalled());
+}
+
+TEST_F(SchemaEngineTest, dropSchema_twoPluginsAdded_bothReturningFalse_shouldReturn_False)
+{
+  result= plugin::StorageEngine::dropSchema(schema_identifier);
+
+  ASSERT_FALSE(result);
+}
+
+TEST_F(SchemaEngineTest, dropSchema_twoPluginsAdded_oneReturningTrue_shouldReturn_True)
+{
+  plugin1.setDropSchemaReturn(true);
+  result= plugin::StorageEngine::dropSchema(schema_identifier);
+  
+  ASSERT_TRUE(result);
+}
+
+
+TEST_F(SchemaEngineTest, alterSchema_twoPluginsAdded_ShouldCall_doAlterSchemaCalled_onBoth)
+{
+  plugin::StorageEngine::alterSchema(proto);
+  
+  ASSERT_TRUE(plugin1.getDoAlterSchemaCalled());
+  ASSERT_TRUE(plugin2.getDoAlterSchemaCalled());
+}
+
+TEST_F(SchemaEngineTest, alterSchema_SchemaIdentifier_twoPluginsAdded_bothReturningFalse_shouldReturn_False)
+{
+  result= plugin::StorageEngine::alterSchema(proto);
+  
+  ASSERT_FALSE(result);
+}
+
+TEST_F(SchemaEngineTest, alterSchema_twoPluginsAdded_oneReturningTrue_shouldReturn_True)
+{
+  plugin1.setAlterSchemaReturn(true);
+  result= plugin::StorageEngine::alterSchema(proto);
+  
+  ASSERT_TRUE(result);
+}
+
+TEST_F(SchemaEngineTest, getSchemaCollation_twoPluginsAdded_bothDoingNothing_shouldReturn_default_charset_info)
+{
+  const CHARSET_INFO *charset_info;
+  charset_info=  plugin::StorageEngine::getSchemaCollation(schema_identifier);
+  
+  ASSERT_EQ(charset_info, default_charset_info);
+}

=== added file 'unittests/plugin/storage_engine_test.cc'
--- unittests/plugin/storage_engine_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/storage_engine_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,215 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/error.h>
+#include <drizzled/plugin/storage_engine.h>
+#include <drizzled/table.h>
+#include <gtest/gtest.h>
+
+#include "../generator.h"
+#include "plugin_stubs.h"
+#include "../stubs.h"
+
+using namespace drizzled;
+using namespace std;
+
+class StorageEngineTest : public ::testing::Test
+{
+  protected:
+    StorageEngineStub plugin1, plugin2;
+    Session *fake_session;
+    SchemaIdentifier schema_identifier;
+    TableIdentifier table_id_stub;
+    bool result;
+    
+  public:
+    StorageEngineTest()
+    : plugin1("StorageEngineStub1", HTON_HAS_CHECKSUM),
+    plugin2("StorageEngineStub2"),
+    schema_identifier("stubArg"),
+    table_id_stub("Arg1Stub", "Arg2Stub", "Arg3Stub")
+    {}
+    
+    virtual void SetUp()
+    {
+      error_handler_hook= error_handler_func_stub;
+      fake_session= Generator::SessionGenerator::make_fake_session();
+      plugin::StorageEngine::addPlugin(&plugin1);
+      plugin::StorageEngine::addPlugin(&plugin2);
+    }
+    
+    virtual void TearDown()
+    {
+      plugin::StorageEngine::removePlugin(&plugin1);
+      plugin::StorageEngine::removePlugin(&plugin2);
+    }
+}; 
+
+TEST_F(StorageEngineTest, check_flag_CheckingSetFlag_ShouldReturn_True)
+{
+    result= plugin1.check_flag(HTON_BIT_HAS_CHECKSUM);
+    EXPECT_TRUE(result);
+}
+
+TEST_F(StorageEngineTest, check_flag_CheckingUnsetFlag_ShouldReturn_False)
+{
+  result= plugin1.check_flag(HTON_BIT_NO_AUTO_INCREMENT);
+  EXPECT_FALSE(result);
+}
+
+TEST_F(StorageEngineTest, findByName_findExistingName_shouldReturn_Pointer)
+{
+  plugin::StorageEngine *found;
+  string name_to_find= "StorageEngineStub2";
+
+  found= plugin::StorageEngine::findByName(name_to_find);
+
+  ASSERT_EQ(&plugin2, found);
+}
+
+TEST_F(StorageEngineTest, findByName_findNonExistingName_shouldReturn_NULL)
+{
+  plugin::StorageEngine *found;
+  string name_to_find= "NonExisting";
+  
+  found= plugin::StorageEngine::findByName(name_to_find);
+  
+  ASSERT_EQ(NULL, found);
+}
+
+TEST_F(StorageEngineTest, findByName_withSessionArg_findExistingName_shouldReturn_Pointer)
+{
+  plugin::StorageEngine *found;
+  string name_to_find= "StorageEngineStub1";
+  
+  found= plugin::StorageEngine::findByName(*fake_session, name_to_find);
+  
+  ASSERT_EQ(&plugin1, found);
+}
+
+TEST_F(StorageEngineTest, findByName_withSessionArg_findNonExistingName_shouldReturn_NULL)
+{
+  plugin::StorageEngine *found;
+  string name_to_find= "NonExisting";
+  
+  found= plugin::StorageEngine::findByName(*fake_session, name_to_find);
+  
+  ASSERT_EQ(NULL, found);
+}
+
+TEST_F(StorageEngineTest, DISABLED_closeConnection_twoPluginsAdded_shouldCall_close_connection_onBoth)
+{
+  plugin::StorageEngine::closeConnection(fake_session);
+
+  ASSERT_TRUE(plugin1.getCloseConnectionCalled());
+  ASSERT_TRUE(plugin2.getCloseConnectionCalled());
+}
+
+TEST_F(StorageEngineTest, flushLogs_twoPluginsAdded_shouldCall_flush_logs_onBoth)
+{
+  plugin::StorageEngine::flushLogs(NULL);
+  
+  ASSERT_TRUE(plugin1.getFlushLogsCalled());
+  ASSERT_TRUE(plugin2.getFlushLogsCalled());
+}
+
+TEST_F(StorageEngineTest, getTableDefinition_twoPluginsAdded_shouldCall_doGetTableDefinition_onBoth)
+{
+  message::Table proto;
+  plugin::StorageEngine::getTableDefinition(*fake_session, table_id_stub, proto, 0);
+
+  ASSERT_TRUE(plugin1.getDoGetTableDefinitionCalled());
+  ASSERT_TRUE(plugin2.getDoGetTableDefinitionCalled());
+}
+
+TEST_F(StorageEngineTest, dropTable_twoPluginsAdded_shouldCall_doDropTableCalled_onPluginAssociatedWithIdentifier)
+{
+  int error;
+
+  plugin1.setEngineNameToSet("StorageEngineStub1");//this is served to an internally performed search
+  error= plugin::StorageEngine::dropTable(*fake_session, table_id_stub);
+
+  ASSERT_EQ(0, error);
+  ASSERT_TRUE(plugin1.getDoDropTableCalled());
+}
+
+TEST_F(StorageEngineTest, dropTable_EngineForTableCantBeFound_shouldReturn_ER_CORRUPT_TABLE_DEFINITION)
+{
+  int error;
+  
+  
+  plugin1.setEngineNameToSet("NonExisting");//this is served to an internally performed search
+  error= plugin::StorageEngine::dropTable(*fake_session, table_id_stub);
+  
+  ASSERT_EQ(ER_CORRUPT_TABLE_DEFINITION, error);
+}
+
+TEST_F(StorageEngineTest, dropTable_NonExistingTable_shouldReturn_ER_CORRUPT_TABLE_DEFINITION)
+{
+  int error;
+
+  plugin1.setDoGetTableDefinitionReturn(ER_CORRUPT_TABLE_DEFINITION);
+  error= plugin::StorageEngine::dropTable(*fake_session, table_id_stub);
+  
+  ASSERT_EQ(ER_CORRUPT_TABLE_DEFINITION, error);
+}
+
+TEST_F(StorageEngineTest, dropTable_nonExistingTable_shouldReturn_ER_CORRUPT_TABLE_DEFINITION)
+{
+  int error;
+
+  plugin1.setEngineNameToSet("NonExisting");//this is served to an internally performed search
+  error= plugin::StorageEngine::dropTable(*fake_session, table_id_stub);
+  
+  ASSERT_EQ(ER_CORRUPT_TABLE_DEFINITION, error);
+}
+
+TEST_F(StorageEngineTest, canCreateTable_twoPluginsAdded_shouldCall_doCanCreateTable_onBoth)
+{
+  plugin::StorageEngine::canCreateTable(table_id_stub);
+  
+  ASSERT_TRUE(plugin1.getDoCanCreateTableCalled());
+  ASSERT_TRUE(plugin2.getDoCanCreateTableCalled());
+}
+
+TEST_F(StorageEngineTest, doesTableExist_twoPluginsAdded_shouldCall_doDoesTableExist_onBoth)
+{
+  plugin::StorageEngine::doesTableExist(*fake_session, table_id_stub);
+
+  ASSERT_TRUE(plugin1.getDoDoesTableExistCalled());
+  ASSERT_TRUE(plugin2.getDoDoesTableExistCalled());
+}
+
+TEST_F(StorageEngineTest, doesTableExist_twoPluginsAdded_bothReturningFalse_should_returnFalse)
+{
+  result= plugin::StorageEngine::doesTableExist(*fake_session, table_id_stub);
+
+  ASSERT_FALSE(result);
+}
+
+TEST_F(StorageEngineTest, doesTableExist_twoPluginsAdded_oneReturningTrue_should_returnTrue)
+{
+  plugin2.setDoesTableExistReturn(true);
+  plugin::StorageEngine::doesTableExist(*fake_session, table_id_stub);
+
+  ASSERT_TRUE(result);
+}

=== added file 'unittests/plugin/table_function_test.cc'
--- unittests/plugin/table_function_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/table_function_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,242 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/field/int64_t.h>
+#include <drizzled/field/varstring.h>
+#include <drizzled/global_charset_info.h>
+#include <drizzled/plugin/table_function.h>
+#include <drizzled/session.h>
+#include <drizzled/sql_string.h>
+#include <drizzled/table.h>
+#include <drizzled/table_share.h>
+#include <gtest/gtest.h>
+#include <string>
+
+#include "drizzled/message/table.pb.h"
+#include "../generator.h"
+
+using namespace drizzled;
+using namespace std;
+
+class TableFunctionTest : public ::testing::Test
+{
+protected:
+  plugin::TableFunction plugin;
+  message::Table proto;
+public:
+  TableFunctionTest()
+    : plugin("SchemaArgStub", "TableArgStub")
+  {}
+};
+
+TEST_F(TableFunctionTest, getIdentifierTableName_shouldReturn_lowerCase_table_arg)
+{
+  string table_name= plugin.getIdentifierTableName();
+
+  ASSERT_EQ("tableargstub", table_name);
+}
+
+TEST_F(TableFunctionTest, getSchemaHome_shouldReturn_lowerCase_schema_arg)
+{
+  string schema_name= plugin.getSchemaHome();
+  
+  ASSERT_EQ("schemaargstub", schema_name);
+}
+
+TEST_F(TableFunctionTest, getPath_shouldReturn_joined_schema_arg_and_table_arg)
+{
+  string path= plugin.getPath();
+  
+  ASSERT_EQ("schemaargstub/tableargstub", path);
+}
+
+TEST_F(TableFunctionTest, add_field_shouldAddFieldToProto)
+{
+  drizzled::message::Table::Field *field;
+
+  plugin.add_field("FieldLabel", plugin::TableFunction::BOOLEAN, true);
+  plugin.define(proto);
+  field= proto.mutable_field(0);
+  
+  ASSERT_EQ(1, proto.field_size());
+}
+
+TEST_F(TableFunctionTest, add_field_type_BOOLEAN_shouldSetProtoFieldsProperly)
+{
+  drizzled::message::Table::Field *field;
+  
+  plugin.add_field("FieldLabel", plugin::TableFunction::BOOLEAN, 0, true);
+  plugin.define(proto);
+  field= proto.mutable_field(0);
+  
+  EXPECT_EQ("FieldLabel", field->name());
+  EXPECT_EQ(drizzled::message::Table::Field::VARCHAR, field->type());
+  EXPECT_EQ(false, field->options().default_null());
+  EXPECT_EQ(false, field->constraints().is_nullable());
+  EXPECT_EQ(5, field->string_options().length());
+}
+
+TEST_F(TableFunctionTest, add_field_type_STRING_shouldSetProtoFieldsProperly)
+{
+  drizzled::message::Table::Field *field;
+  
+  plugin.add_field("FieldLabel", plugin::TableFunction::STRING, 10, true);
+  plugin.define(proto);
+  field= proto.mutable_field(0);
+  
+  EXPECT_EQ("FieldLabel", field->name());
+  EXPECT_EQ(drizzled::message::Table::Field::VARCHAR, field->type());
+  EXPECT_EQ(true, field->options().default_null());
+  EXPECT_EQ(true, field->constraints().is_nullable());
+  EXPECT_EQ(10, field->string_options().length());
+}
+
+TEST_F(TableFunctionTest, add_field_type_VARBINARY_shouldSetProtoFieldsProperly)
+{
+  drizzled::message::Table::Field *field;
+  
+  plugin.add_field("FieldLabel", plugin::TableFunction::VARBINARY, 10, true);
+  plugin.define(proto);
+  field= proto.mutable_field(0);
+  
+  EXPECT_EQ("FieldLabel", field->name());
+  EXPECT_EQ(drizzled::message::Table::Field::VARCHAR, field->type());
+  EXPECT_EQ(true, field->options().default_null());
+  EXPECT_EQ(true, field->constraints().is_nullable());
+  EXPECT_EQ(10, field->string_options().length());
+  EXPECT_EQ(my_charset_bin.csname, field->string_options().collation());
+  EXPECT_EQ(my_charset_bin.number, field->string_options().collation_id());
+}
+
+TEST_F(TableFunctionTest, add_field_type_NUMBER_shouldSetProtoFieldsProperly)
+{
+  drizzled::message::Table::Field *field;
+  
+  plugin.add_field("FieldLabel", plugin::TableFunction::NUMBER, 10, true);
+  plugin.define(proto);
+  field= proto.mutable_field(0);
+  
+  EXPECT_EQ("FieldLabel", field->name());
+  EXPECT_EQ(drizzled::message::Table::Field::BIGINT, field->type());
+  EXPECT_EQ(false, field->options().default_null());
+  EXPECT_EQ(false, field->constraints().is_nullable());
+}
+
+class TableFunctionGeneratorTest : public ::testing::Test
+{
+protected:
+  unsigned char buf[100];
+  unsigned char buf2[100];
+  TableShare table_share;
+  Table table;
+  Session *fake_session;
+  Field_int64_t field_int64_t;
+  Field_varstring field_varstring;
+  Field *field_ptr[2];
+  plugin::TableFunction::Generator generator;
+  String string_buf;
+public:
+  TableFunctionGeneratorTest()
+  : table_share(message::Table::STANDARD),
+    field_int64_t(buf, 0, NULL, 0, Field::NONE, "FieldName", 0, true),
+    field_varstring(buf2, 100, 1, NULL, 0, "FieldName", &table_share, default_charset_info),
+    generator(&field_ptr[0])
+  {
+    fake_session= Generator::SessionGenerator::make_fake_session();
+    table.resetTable(fake_session, &table_share, 0);
+    field_int64_t.init(&table);
+    field_varstring.init(&table);
+    system_charset_info= default_charset_info;
+    generator.sub_populate(0);
+  }
+};
+
+TEST_F(TableFunctionGeneratorTest, push_uint64_t_FieldShouldGetPopulated)
+{
+  field_ptr[0]= &field_int64_t;
+
+  generator.push((uint64_t)20);
+
+  ASSERT_EQ(20, field_ptr[0]->val_int());
+}
+
+TEST_F(TableFunctionGeneratorTest, push_int64_t_FieldShouldGetPopulated)
+{
+  field_ptr[0]= &field_int64_t;
+
+  generator.push((int64_t)20);
+  
+  ASSERT_EQ(20, field_ptr[0]->val_int());
+}
+
+TEST_F(TableFunctionGeneratorTest, push_cstring_FieldShouldGetPopulated)
+{
+  field_ptr[0]= &field_varstring;
+  char pushed_string[]= {"Pushed String"};
+
+  generator.push(pushed_string);
+  
+  ASSERT_STREQ(pushed_string, field_ptr[0]->val_str(&string_buf)->c_str());
+}
+
+TEST_F(TableFunctionGeneratorTest, push_string_FieldShouldGetPopulated)
+{
+  field_ptr[0]= &field_varstring;
+  string pushed_string("Pushed String");
+
+  generator.push(pushed_string);
+  
+  ASSERT_STREQ(pushed_string.c_str(), field_ptr[0]->val_str(&string_buf)->c_str());
+}
+
+TEST_F(TableFunctionGeneratorTest, push_bool_true_FieldShouldGetPopulated)
+{
+  field_ptr[0]= &field_varstring;
+  string true_string("YES");
+  
+  generator.push(true);
+  
+  ASSERT_STREQ(true_string.c_str(), field_ptr[0]->val_str(&string_buf)->c_str());
+}
+
+TEST_F(TableFunctionGeneratorTest, push_bool_false_FieldShouldGetPopulated)
+{
+  field_ptr[0]= &field_varstring;
+  string true_string("NO");
+  
+  generator.push(false);
+  
+  ASSERT_STREQ(true_string.c_str(), field_ptr[0]->val_str(&string_buf)->c_str());
+}
+
+TEST_F(TableFunctionGeneratorTest, push_twoValues_bothFieldsShouldGetPopulated)
+{
+  field_ptr[0]= &field_int64_t;
+  field_ptr[1]= &field_varstring;
+  char pushed_string[]= {"Pushed String"};
+
+  generator.push((uint64_t)20);
+  generator.push(pushed_string);
+  
+  ASSERT_EQ(20, field_ptr[0]->val_int());
+  ASSERT_STREQ(pushed_string, field_ptr[1]->val_str(&string_buf)->c_str());
+}

=== added file 'unittests/plugin/transaction_applier_test.cc'
--- unittests/plugin/transaction_applier_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/transaction_applier_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,1 @@
+ 

=== added file 'unittests/plugin/transaction_replicator_test.cc'
--- unittests/plugin/transaction_replicator_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/transaction_replicator_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,1 @@
+ 

=== added file 'unittests/plugin/transactional_storage_engine_test.cc'
--- unittests/plugin/transactional_storage_engine_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/transactional_storage_engine_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,68 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Pawel Blokus
+ *
+ *  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; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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
+ */
+ 
+#include "config.h"
+
+#include <drizzled/plugin/transactional_storage_engine.h>
+#include <gtest/gtest.h>
+
+#include "plugin_stubs.h"
+
+using namespace drizzled;
+
+class TransactionalStorageEngineTest : public ::testing::Test
+{
+protected:
+  TransactionalStorageEngineStub plugin1, plugin2;
+public:
+  TransactionalStorageEngineTest()
+    : plugin1("TransactionalStorageEngineStub1"),
+      plugin2("TransactionalStorageEngineStub2")
+  {}
+
+  virtual void SetUp()
+  {
+    plugin::TransactionalStorageEngine::addPlugin(&plugin1);
+    plugin::TransactionalStorageEngine::addPlugin(&plugin2);
+  }
+
+  virtual void TearDown()
+  {
+    plugin::TransactionalStorageEngine::removePlugin(&plugin1);
+    plugin::TransactionalStorageEngine::removePlugin(&plugin2);
+  }
+  
+};
+
+TEST_F(TransactionalStorageEngineTest, notifyStartTransaction_twoPluginsAdded_shouldCall_startTransaction_onBoth)
+{
+  plugin::TransactionalStorageEngine::notifyStartTransaction(NULL, START_TRANS_NO_OPTIONS);
+
+  EXPECT_TRUE(plugin1.getStartTransactionCalled());
+  EXPECT_TRUE(plugin2.getStartTransactionCalled());
+}
+
+TEST_F(TransactionalStorageEngineTest, releaseTemporaryLatches_twoPluginsAdded_shouldCall_doReleaseTemporaryLatches_onBoth)
+{
+  plugin::TransactionalStorageEngine::releaseTemporaryLatches(NULL);
+
+  EXPECT_TRUE(plugin1.getDoReleaseTemporaryLatchesCalled());
+  EXPECT_TRUE(plugin2.getDoReleaseTemporaryLatchesCalled()); 
+}
\ No newline at end of file

=== added file 'unittests/plugin/xa_resource_manager_test.cc'
--- unittests/plugin/xa_resource_manager_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/xa_resource_manager_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,97 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/plugin/xa_resource_manager.h>
+#include <gtest/gtest.h>
+
+#include "plugin_stubs.h"
+
+using namespace drizzled;
+
+class XaResourceManagerTest : public ::testing::Test
+{
+protected:
+  XaResourceManagerStub plugin1, plugin2;
+  XID xid;
+  int returned;
+public:
+
+  virtual void SetUp()
+  {
+    plugin::XaResourceManager::addPlugin(&plugin1);
+    plugin::XaResourceManager::addPlugin(&plugin2);
+  }
+
+  virtual void TearDown()
+  {
+    plugin::XaResourceManager::removePlugin(&plugin1);
+    plugin::XaResourceManager::removePlugin(&plugin2);
+  }
+};
+
+TEST_F(XaResourceManagerTest, commitOrRollbackXID_commit_pluginsReturning_0_shouldReturn_0)
+{
+  returned= plugin::XaResourceManager::commitOrRollbackXID(&xid, true);
+  
+  ASSERT_EQ(0, returned);
+}
+
+TEST_F(XaResourceManagerTest, commitOrRollbackXID_commit_pluginsReturning_1_shouldReturn_1)
+{
+  plugin1.setCommitRollbackReturn(1);
+  plugin2.setCommitRollbackReturn(1);
+  returned= plugin::XaResourceManager::commitOrRollbackXID(&xid, true);
+  
+  ASSERT_EQ(1, returned);
+}
+
+TEST_F(XaResourceManagerTest, commitOrRollbackXID_commit_onlyOnePluginReturning_0_shouldReturn_0)
+{
+  plugin1.setCommitRollbackReturn(1);
+  returned= plugin::XaResourceManager::commitOrRollbackXID(&xid, true);
+  
+  ASSERT_EQ(0, returned);
+}
+
+TEST_F(XaResourceManagerTest, commitOrRollbackXID_commit_twoPluginsAdded_doXaCommit_shouldBeCalledOnBoth)
+{
+  plugin::XaResourceManager::commitOrRollbackXID(&xid, true);
+  
+  ASSERT_TRUE(plugin1.getDoXaCommitXidCalled());
+  ASSERT_TRUE(plugin2.getDoXaCommitXidCalled());
+}
+
+TEST_F(XaResourceManagerTest, commitOrRollbackXID_rollback_twoPluginsAdded_doXaRollback_shouldBeCalledOnBoth)
+{
+  plugin::XaResourceManager::commitOrRollbackXID(&xid, false);
+  
+  ASSERT_TRUE(plugin1.getDoXaRollbackXidCalled());
+  ASSERT_TRUE(plugin2.getDoXaRollbackXidCalled());
+}
+
+TEST_F(XaResourceManagerTest, recoverAllXids_twoPluginsAdded_doXaRecover_shouldBeCalledOnBoth)
+{
+  plugin::XaResourceManager::recoverAllXids(NULL);
+
+  ASSERT_TRUE(plugin1.getXaRecoverCalled());
+  ASSERT_TRUE(plugin2.getXaRecoverCalled());
+}

=== added file 'unittests/plugin/xa_storage_engine_test.cc'
--- unittests/plugin/xa_storage_engine_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/plugin/xa_storage_engine_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,1 @@
+ 

=== added file 'unittests/stubs.cc'
--- unittests/stubs.cc	1970-01-01 00:00:00 +0000
+++ unittests/stubs.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,31 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "stubs.h"
+
+
+using namespace drizzled;
+
+void error_handler_func_stub(uint32_t my_err, const char *str, drizzled::myf MyFlags)
+{
+  (void)my_err;
+  (void)str;
+  (void)MyFlags;
+}
\ No newline at end of file

=== added file 'unittests/stubs.h'
--- unittests/stubs.h	1970-01-01 00:00:00 +0000
+++ unittests/stubs.h	2010-08-15 23:41:09 +0000
@@ -0,0 +1,46 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#ifndef UNITTESTS_STUBS_H
+#define UNITTESTS_STUBS_H
+
+#include "config.h"
+
+#include <drizzled/definitions.h>
+#include <drizzled/table.h>
+#include <string>
+
+void error_handler_func_stub(uint32_t my_err, const char *str, drizzled::myf MyFlags);
+
+class TableShareStub : public drizzled::TableShare
+{
+  public:
+    TableShareStub(drizzled::message::Table::TableType type=
+    drizzled::message::Table::STANDARD)
+    : drizzled::TableShare(type)
+    {}
+    
+    void addKeyName(std::string arg)
+    {
+      drizzled::TableShare::addKeyName(arg);
+    }
+};
+
+#endif
\ No newline at end of file

=== added file 'unittests/table_identifier_test.cc'
--- unittests/table_identifier_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/table_identifier_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,415 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <gtest/gtest.h>
+
+#include <drizzled/data_home.h>
+#include <drizzled/definitions.h>
+#include <drizzled/set_var.h>
+#include <drizzled/table.h>
+#include <drizzled/message/table.pb.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+using namespace drizzled;
+using namespace std;
+
+TEST(TableIdentifierTest, operator_ostream_type_STANDARD)
+{
+  size_t hash;
+  string expected = "TableIdentifier:(DatabaseArg, TableNameArg, standard, databasearg/tablenamearg, ";
+  ostringstream oss(ostringstream::out);
+  istringstream iss(istringstream::in);
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+
+  oss << table_identifier;
+
+  EXPECT_EQ(expected, oss.str().substr(0, expected.size()));
+  EXPECT_EQ(')', oss.str().c_str()[oss.str().size() - 1]);
+  iss.str(oss.str().substr(expected.size(), oss.str().size() - expected.size() - 1));
+  iss >> hash;
+  EXPECT_FALSE(iss.fail());
+}
+
+TEST(TableIdentifierTest, operator_ostream_with_pathArg)
+{
+  size_t hash;
+  string expected = "TableIdentifier:(DatabaseArg, TableNameArg, temporary, PathArg, ";
+  ostringstream oss(ostringstream::out);
+  istringstream iss(istringstream::in);
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", "PathArg");
+  
+  oss << table_identifier;
+  
+  EXPECT_EQ(expected, oss.str().substr(0, expected.size()));
+  EXPECT_EQ(')', oss.str().c_str()[oss.str().size() - 1]);
+  iss.str(oss.str().substr(expected.size(), oss.str().size() - expected.size() - 1));
+  iss >> hash;
+  EXPECT_FALSE(iss.fail());
+}
+
+TEST(TableIdentifierTest, operator_equal_comparingEqualTableIdentifiers_shouldReturn_True)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+
+  ASSERT_EQ(table_identifier1, table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_equal_comparingTableIdentifiers_WithDifferentTypes_shouldReturn_False)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "TableNameArg", message::Table::TEMPORARY);
+  
+  ASSERT_FALSE(table_identifier1 == table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_equal_comparingTableIdentifiers_WithDifferentTableNames_shouldReturn_False)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "OtherTableNameArg", message::Table::STANDARD);
+  
+  ASSERT_FALSE(table_identifier1 == table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_equal_comparingTableIdentifiers_WithDifferentDatabases_shouldReturn_False)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DifferentDatabaseArg", "TableNameArg", message::Table::STANDARD);
+  
+  ASSERT_FALSE(table_identifier1 == table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_lessThan_comparingEqualTableIdentifiers_shouldReturn_False)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  
+  ASSERT_FALSE(table_identifier1 < table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_lessThan_comparingWithTableIdentifier_WithSmallerDatabaseArg_shouldReturn_False)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("AAADatabaseArg", "TableNameArg", message::Table::STANDARD);
+  
+  ASSERT_FALSE(table_identifier1 < table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_lessThan_comparingWithTableIdentifier_WithBiggerDatabaseArg_shouldReturn_True)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("ZZZDatabaseArg", "TableNameArg", message::Table::STANDARD);
+  
+  ASSERT_TRUE(table_identifier1 < table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_lessThan_comparingWithTableIdentifier_WithSmallerTableNameArg_shouldReturn_False)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "AAATableNameArg", message::Table::STANDARD);
+  
+  ASSERT_FALSE(table_identifier1 < table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_lessThan_comparingWithTableIdentifier_WithBiggerTableNameArg_shouldReturn_True)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "ZZZTableNameArg", message::Table::STANDARD);
+  
+  ASSERT_TRUE(table_identifier1 < table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_lessThan_comparingWithTableIdentifier_WithSmallerTypeArg_shouldReturn_False)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::TEMPORARY);
+  TableIdentifier table_identifier2("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  
+  ASSERT_FALSE(table_identifier1 < table_identifier2);
+}
+
+TEST(TableIdentifierTest, operator_lessThan_comparingWithTableIdentifier_WithBiggerTypeArg_shouldReturn_True)
+{
+  ostringstream oss(ostringstream::out);
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "TableNameArg", message::Table::TEMPORARY);
+  
+  ASSERT_TRUE(table_identifier1 < table_identifier2);
+}
+
+TEST(TableIdentifierTest, filename_to_tablename_fromTemporaryTableFileName_shouldJustCopy)
+{
+  char from[]= TMP_FILE_PREFIX"Filename";
+  char to[sizeof(from) / sizeof(from[0])];
+  to[sizeof(from) / sizeof(from[0]) - 1]= '\0';
+  
+  TableIdentifier::filename_to_tablename(from, to, sizeof(to) / sizeof(to[0]) - 1);
+
+  ASSERT_STREQ(from, to);
+}
+
+TEST(TableIdentifierTest, filename_to_tablename_fromTemporaryTableFileName_LengthNotSufficent_shouldCopyAndTrim)
+{
+  char from[]= TMP_FILE_PREFIX"Filename";
+  char to[TMP_FILE_PREFIX_LENGTH + 3];
+  to[TMP_FILE_PREFIX_LENGTH + 2]= '\0';
+  
+  TableIdentifier::filename_to_tablename(from, to, TMP_FILE_PREFIX_LENGTH + 2);
+  
+  ASSERT_STREQ(TMP_FILE_PREFIX"Fi", to);
+}
+
+TEST(TableIdentifierTest, filename_to_tablename_fromNormalTableFileName_shouldJustCopy)
+{
+  char from[]= "Filename";
+  char to[sizeof(from) / sizeof(from[0])];
+  to[sizeof(from) / sizeof(from[0]) - 1]= '\0';
+  
+  TableIdentifier::filename_to_tablename(from, to, sizeof(to) / sizeof(to[0]) - 1);
+  
+  ASSERT_STREQ(from, to);
+}
+
+TEST(TableIdentifierTest, filename_to_tablename_fromNormalTableFileName_LengthNotSufficent_shouldCopyAndTrim)
+{
+  char from[]= "Filename";
+  char to[3];
+  to[2]= '\0';
+  
+  TableIdentifier::filename_to_tablename(from, to, 2);
+  
+  ASSERT_STREQ("Fi", to);
+}
+
+TEST(TableIdentifierTest, filename_to_tablename_fromNormalTableFileName_WithEscapedChars_shouldJustCopy)
+{
+  char from[]= "Filen@21ame@26";
+  char expected[]= "Filen!ame&";
+  char to[sizeof(expected) / sizeof(expected[0])];
+  to[sizeof(expected) / sizeof(expected[0]) - 1]= '\0';
+  
+  TableIdentifier::filename_to_tablename(from, to, sizeof(to) / sizeof(to[0]) - 1);
+  
+  ASSERT_STREQ(expected, to);
+}
+
+TEST(TableIdentifierTest, filename_to_tablename_fromNormalTableFileName_WithEscapedChars_LengthNotSufficent_shouldCopyAndTrim)
+{
+  char from[]= "Filen@21ame@26";
+  char to[7];
+  to[6]= '\0';
+  
+  TableIdentifier::filename_to_tablename(from, to, 6);
+  
+  ASSERT_STREQ("Filen!", to);
+}
+
+static char home_stub[]= "homestub/";
+static char tmpdir_stub[]= "tmpdirstub";
+
+class TableIdentifierGlobalDirsSetTest : public ::testing::Test
+{
+protected:
+  string old_tmpdir;
+  char *old_data_home;
+public:
+  virtual void SetUp()
+  {
+    old_data_home= data_home;
+    data_home= home_stub;
+
+    old_tmpdir= drizzle_tmpdir;
+    drizzle_tmpdir= tmpdir_stub;
+  }
+
+  virtual void TearDown()
+  {
+    data_home= old_data_home;
+    drizzle_tmpdir= old_tmpdir;
+  }
+};
+
+TEST_F(TableIdentifierGlobalDirsSetTest, build_table_filename_date_home_set)
+{
+  char my_home_stub[]= "homestub";
+  data_home= my_home_stub;
+  string path;
+  int len;
+
+  len= TableIdentifier::build_table_filename(path, "DatabaseArg", "TableNameArg", false);
+
+  EXPECT_EQ(strlen("homestub/databasearg/tablenamearg"), len);
+  EXPECT_EQ("homestub/databasearg/tablenamearg", path);
+}
+
+TEST_F(TableIdentifierGlobalDirsSetTest, build_table_filename_data_home_has_FN_ROOTDIR_alreadyInItself)
+{
+  string path;
+  int len;
+  
+  len= TableIdentifier::build_table_filename(path, "DatabaseArg", "TableNameArg", false);
+
+  EXPECT_EQ(strlen("homestub/databasearg/tablenamearg"), len);
+  EXPECT_EQ("homestub/databasearg/tablenamearg", path);
+}
+
+TEST_F(TableIdentifierGlobalDirsSetTest, build_table_filename_ArgsHaveSpecialChars_whichShouldBeEscaped)
+{
+  string path;
+  int len;
+  
+  len= TableIdentifier::build_table_filename(path, "Database%Arg", "Tab!!leNameArg", false);
+  
+  EXPECT_EQ(strlen("homestub/database@25arg/tab@21@21lenamearg"), len);
+  EXPECT_EQ("homestub/database@25arg/tab@21@21lenamearg", path);
+}
+
+TEST_F(TableIdentifierGlobalDirsSetTest, build_table_filename_isTemp_TableNameArgShouldBeLeftUnchanged)
+{
+  string path;
+  int len;
+  
+  len= TableIdentifier::build_table_filename(path, "Database%Arg", "Tab!!leNameArg", true);
+  
+  EXPECT_EQ(strlen("homestub/database@25arg/Tab!!leNameArg"), len);
+  EXPECT_EQ("homestub/database@25arg/Tab!!leNameArg", path);
+}
+
+TEST_F(TableIdentifierGlobalDirsSetTest, getPath_type_STANDARD)
+{
+  string path;
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  
+  path= table_identifier.getPath();
+  EXPECT_EQ("homestub/databasearg/tablenamearg", path);
+}
+
+TEST_F(TableIdentifierGlobalDirsSetTest, getPath_type_INTERNAL)
+{
+  string path;
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::INTERNAL);
+  
+  path= table_identifier.getPath();
+  EXPECT_EQ("homestub/databasearg/tablenamearg", path);
+}
+
+TEST_F(TableIdentifierGlobalDirsSetTest, getPath_type_TEMPORARY_ShouldHaveProperPrefix)
+{
+  string path;
+  string expected_prefix= "tmpdirstub/"TMP_FILE_PREFIX;
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::TEMPORARY);
+  
+  path= table_identifier.getPath();
+  EXPECT_EQ(expected_prefix, path.substr(0, expected_prefix.size()));
+  drizzle_tmpdir= "";
+}
+
+TEST_F(TableIdentifierGlobalDirsSetTest, getPath_type_TEMPORARY_ShouldProduceUniqueNames)
+{
+  string path1, path2;
+  TableIdentifier table_identifier1("DatabaseArg", "TableNameArg1", message::Table::TEMPORARY);
+  TableIdentifier table_identifier2("DatabaseArg", "TableNameArg2", message::Table::TEMPORARY);
+  
+  path1= table_identifier1.getPath();
+  path2= table_identifier2.getPath();
+  EXPECT_NE(path1, path2);
+}
+
+TEST(TableIdentifierTest, getPath_type_FUNCTION)
+{
+  string path;
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::FUNCTION);
+  
+  path= table_identifier.getPath();
+  EXPECT_EQ("DatabaseArg.TableNameArg", path);
+}
+
+TEST(TableIdentifierTest, compare_identicalValues_shouldReturn_True)
+{
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+
+  ASSERT_TRUE(table_identifier == table_identifier2);
+}
+
+TEST(TableIdentifierTest, compare_differentDatabaseValue_shouldReturn_False)
+{
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DifferentDatabaseArg", "TableNameArg", message::Table::STANDARD);
+
+  ASSERT_FALSE(table_identifier == table_identifier2);
+}
+
+TEST(TableIdentifierTest, compare_differentTableNameValue_shouldReturn_False)
+{
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  TableIdentifier table_identifier2("DatabaseArg", "DifferentTableNameArg", message::Table::STANDARD);
+  
+  ASSERT_FALSE(table_identifier == table_identifier2);
+}
+
+TEST(TableIdentifierTest, getSQLPath_type_FUNCTION)
+{
+  string path;
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::FUNCTION);
+  
+  path= table_identifier.getSQLPath();
+  EXPECT_EQ("databasearg.TableNameArg", path);
+}
+
+TEST(TableIdentifierTest, getSQLPath_type_STANDARD)
+{
+  string path;
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::STANDARD);
+  
+  path= table_identifier.getSQLPath();
+  EXPECT_EQ("databasearg.TableNameArg", path);
+}
+
+TEST(TableIdentifierTest, getSQLPath_type_INTERNAL)
+{
+  string path;
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::INTERNAL);
+  
+  path= table_identifier.getSQLPath();
+  EXPECT_EQ("temporary.TableNameArg", path);
+}
+
+TEST(TableIdentifierTest, getSQLPath_type_TEMPORARY)
+{
+  string path;
+  TableIdentifier table_identifier("DatabaseArg", "TableNameArg", message::Table::TEMPORARY);
+  
+  path= table_identifier.getSQLPath();
+  EXPECT_EQ("databasearg.#TableNameArg", path);
+}

=== added file 'unittests/table_list_test.cc'
--- unittests/table_list_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/table_list_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,404 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <gtest/gtest.h>
+
+#include <drizzled/error.h>
+#include <drizzled/global_charset_info.h>
+#include <drizzled/nested_join.h>
+#include <drizzled/session.h>
+#include <drizzled/sql_string.h>
+#include <drizzled/table.h>
+#include <drizzled/table_share.h>
+#include <drizzled/table_list.h>
+
+#include "generator.h"
+#include "stubs.h"
+
+using namespace drizzled;
+
+class TableListTest : public ::testing::Test
+{
+protected:
+  TableList table_list_lvl0, table_list_lvl1_1, table_list_lvl1_2, table_list_lvl2_1, table_list_lvl2_2,;
+  nested_join_st nested_join_lvl0, nested_join_lvl1;
+  TableList *table_list_ptr;
+  Session *fake_session;
+  Table table;
+  TableShareStub table_share;
+  List<Index_hint> index_hints;
+  int retval;
+public:
+
+  virtual void SetUp()
+  {
+    error_handler_hook= error_handler_func_stub;
+    
+    table_list_lvl0.index_hints= &index_hints;
+    
+    fake_session= Generator::SessionGenerator::make_fake_session();
+    nested_join_lvl0.join_list.push_front(&table_list_lvl1_1);
+    nested_join_lvl0.join_list.push_front(&table_list_lvl1_2);
+
+    table_list_lvl1_1.setJoinList(&nested_join_lvl0.join_list);
+    table_list_lvl1_2.setJoinList(&nested_join_lvl0.join_list);
+    
+    nested_join_lvl1.join_list.push_front(&table_list_lvl2_1);
+    nested_join_lvl1.join_list.push_front(&table_list_lvl2_2);
+
+    table_list_lvl2_1.setJoinList(&nested_join_lvl1.join_list);
+    table_list_lvl2_2.setJoinList(&nested_join_lvl1.join_list);
+
+    table_alias_charset= default_charset_info;
+    system_charset_info= default_charset_info;
+
+    table.s= &table_share;
+  }
+
+  void constructRightChildPath()
+  {
+    table_list_lvl0.setNestedJoin(&nested_join_lvl0);
+    table_list_lvl1_2.setNestedJoin(&nested_join_lvl1);
+  }
+
+  void constructLeftChildPath()
+  {
+    table_list_lvl0.setNestedJoin(&nested_join_lvl0);
+    table_list_lvl1_1.setNestedJoin(&nested_join_lvl1);
+  }
+
+  void setRightJoin()
+  {
+    table_list_lvl1_1.outer_join= JOIN_TYPE_RIGHT;
+    table_list_lvl1_2.outer_join= JOIN_TYPE_RIGHT;
+    table_list_lvl2_1.outer_join= JOIN_TYPE_RIGHT;
+    table_list_lvl2_2.outer_join= JOIN_TYPE_RIGHT;
+  }
+
+  void addIndexHint(Index_hint *hint)
+  {
+    index_hints.push_back(hint);
+    if (hint->key_name.str)
+      table_share.addKeyName(hint->key_name.str);
+  }
+
+  virtual void TearDown()
+  {
+    table_alias_charset= NULL;
+    system_charset_info= NULL;
+    //delete fake_session;TODO: this causes problems
+  }
+};
+
+TEST_F(TableListTest, last_leaf_for_name_resolution_IsALeafItself_shouldReturnItself)
+{
+  table_list_ptr= table_list_lvl0.last_leaf_for_name_resolution();
+
+  ASSERT_EQ(&table_list_lvl0, table_list_ptr);
+}
+
+TEST_F(TableListTest, last_leaf_for_name_resolution)
+{
+  constructRightChildPath();
+  table_list_ptr= table_list_lvl0.last_leaf_for_name_resolution();
+  
+  ASSERT_EQ(&table_list_lvl2_2, table_list_ptr);
+}
+
+TEST_F(TableListTest, first_leaf_for_name_resolution)
+{
+  constructLeftChildPath();
+  table_list_ptr= table_list_lvl0.first_leaf_for_name_resolution();
+  
+  ASSERT_EQ(&table_list_lvl2_1, table_list_ptr);
+}
+
+TEST_F(TableListTest, last_leaf_for_name_resolution_RightJoin)
+{
+  constructLeftChildPath();
+  setRightJoin();
+  table_list_ptr= table_list_lvl0.last_leaf_for_name_resolution();
+  
+  ASSERT_EQ(&table_list_lvl2_1, table_list_ptr);
+}
+
+TEST_F(TableListTest, first_leaf_for_name_resolution_RightJoin)
+{
+  constructRightChildPath();
+  setRightJoin();
+  table_list_ptr= table_list_lvl0.first_leaf_for_name_resolution();
+  
+  ASSERT_EQ(&table_list_lvl2_2, table_list_ptr);
+}
+
+TEST_F(TableListTest, print_NormalTable)
+{
+  char table_name_stub[]= "TableNameStub";
+  char db_stub[]= "DBStub";
+  char alias_stub[]= "AliasStub";
+  String expected("`DBStub`.`TableNameStub` `aliasstub`", default_charset_info);
+  String printed;
+  
+  table_list_lvl0.table_name= table_name_stub;
+  table_list_lvl0.table_name_length= sizeof(table_name_stub) - 1;
+  table_list_lvl0.db= db_stub;
+  table_list_lvl0.db_length= sizeof(db_stub) - 1;
+  table_list_lvl0.alias= alias_stub;
+
+  table_list_lvl0.print(NULL, &printed, QT_ORDINARY);
+
+  EXPECT_TRUE(printed == expected);
+}
+
+TEST_F(TableListTest, print_WithIndexHints_ShouldPrintIndexHintToo)
+{
+  char table_name_stub[]= "";
+  char index_hint_name_stub[]= "IndexHintNameStub";
+  Index_hint index_hint_stub(INDEX_HINT_IGNORE, 0, index_hint_name_stub, sizeof(index_hint_name_stub) - 1);
+  char alias_stub[]= "AliasStub";
+  String expected("``.`` `aliasstub` IGN (`IndexHintNameStub`)", default_charset_info);
+  String printed;
+  addIndexHint(&index_hint_stub);
+
+  table_list_lvl0.table_name= table_name_stub;
+  table_list_lvl0.table_name_length= sizeof(table_name_stub) - 1;
+  table_list_lvl0.alias= alias_stub;
+  
+  table_list_lvl0.print(NULL, &printed, QT_ORDINARY);
+  
+  EXPECT_TRUE(printed == expected);
+}
+
+TEST_F(TableListTest, print_NestedJoin_ShouldReplaceNestedJoinsWithTheirChildrenPrinted)
+{
+  char table_name_stub[]= "";
+  String expected("(``.`` `aliasstub1_1` join (``.`` `aliasstub2_1` join ``.`` `aliasstub2_2`))", default_charset_info);
+  String printed;
+
+  table_list_lvl1_1.table_name= table_name_stub;
+  table_list_lvl1_1.table_name_length= sizeof(table_name_stub) - 1;
+  table_list_lvl1_1.alias= "AliasStub1_1";
+
+  table_list_lvl2_1.table_name= table_name_stub;
+  table_list_lvl2_1.table_name_length= sizeof(table_name_stub) - 1;
+  table_list_lvl2_1.alias= "AliasStub2_1";
+  
+  table_list_lvl2_2.table_name= table_name_stub;
+  table_list_lvl2_2.table_name_length= sizeof(table_name_stub) - 1;
+  table_list_lvl2_2.alias= "AliasStub2_2";
+  
+  constructRightChildPath();
+  
+  table_list_lvl0.print(fake_session, &printed, QT_ORDINARY);
+  
+  EXPECT_TRUE(printed == expected);
+}
+
+class Select_Lex_Unit_Stub : public Select_Lex_Unit
+{
+public:
+  void setSlave(Select_Lex *select_lex_node)
+  {
+    slave= select_lex_node;
+  }
+};
+
+class Select_Lex_Stub : public Select_Lex
+{
+  public:
+    Select_Lex_Stub()
+    {
+      next= NULL;
+    }
+    void setMaster(Select_Lex_Node *select_lex_master)
+    {
+      master= select_lex_master;
+    }
+};
+
+TEST_F(TableListTest, print_DerivedTable)
+{
+  char table_name_stub[]= "";
+  char alias_stub[]= "AliasStub";
+  String expected("(select ) `aliasstub`", default_charset_info);
+  String printed;
+  Select_Lex_Unit_Stub select_lex_unit;
+  Select_Lex_Stub select_lex_node1;
+  Generator::SelectLexGenerator::make_Select_Lex_empty_for_print(&select_lex_node1);
+  select_lex_unit.setSlave(&select_lex_node1);
+  select_lex_unit.session= fake_session;
+  select_lex_unit.item= NULL;
+  select_lex_node1.setMaster(&select_lex_unit);
+
+  table_list_lvl0.derived= &select_lex_unit;
+  table_list_lvl0.table_name= table_name_stub;
+  table_list_lvl0.table_name_length= sizeof(table_name_stub) - 1;
+  table_list_lvl0.alias= alias_stub;
+
+  table_list_lvl0.print(fake_session, &printed, QT_ORDINARY);
+  
+  EXPECT_TRUE(printed == expected);
+}
+
+
+TEST_F(TableListTest, process_index_hints_UseIndexIsEmpty_shouldReset_keys_in_use)
+{
+  Index_hint join_index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_JOIN, NULL, 0);
+  addIndexHint(&join_index_hint_stub);
+  Index_hint group_index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_GROUP, NULL, 0);
+  addIndexHint(&group_index_hint_stub);
+  Index_hint order_index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_ORDER, NULL, 0);
+  addIndexHint(&order_index_hint_stub);
+  table.keys_in_use_for_query.set(4);
+  table.keys_in_use_for_group_by.set(4);
+  table.keys_in_use_for_order_by.set(4);
+  
+  table_list_lvl0.process_index_hints(&table);
+  
+  EXPECT_FALSE(table.keys_in_use_for_query[4]);
+  EXPECT_FALSE(table.keys_in_use_for_group_by[4]);
+  EXPECT_FALSE(table.keys_in_use_for_order_by[4]);
+}
+
+TEST_F(TableListTest, process_index_hints_UseNonExistingKey_ShouldReturn_1)
+{
+  char index_hint_name_stub[]= "IndexHintNameStub";
+  Index_hint index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_JOIN, index_hint_name_stub, sizeof(index_hint_name_stub) - 1);
+  index_hints.push_back(&index_hint_stub);
+
+  retval= table_list_lvl0.process_index_hints(&table);
+  
+  ASSERT_EQ(1, retval);
+}
+
+TEST_F(TableListTest, process_index_hints_UseBoth_UseIndex_And_ForceIndex_shouldReturn_1)
+{
+  char index_hint_name_stub[]= "IndexHintNameStub";
+  Index_hint use_index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_JOIN, index_hint_name_stub, sizeof(index_hint_name_stub) - 1);
+  index_hints.push_back(&use_index_hint_stub);
+  Index_hint force_index_hint_stub(INDEX_HINT_FORCE, INDEX_HINT_MASK_JOIN, index_hint_name_stub, sizeof(index_hint_name_stub) - 1);
+  index_hints.push_back(&force_index_hint_stub);
+  
+  retval= table_list_lvl0.process_index_hints(&table);
+  
+  ASSERT_EQ(1, retval);
+}
+
+TEST_F(TableListTest, process_index_hints_UseIndex_ShouldSet_keys_in_use_Properly)
+{
+  char index_hint_name_stub1[]= "IndexHintNameStub1";
+  char index_hint_name_stub2[]= "IndexHintNameStub2";
+  char index_hint_name_stub3[]= "IndexHintNameStub3";
+  Index_hint join_index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_JOIN, index_hint_name_stub1, sizeof(index_hint_name_stub1) - 1);
+  addIndexHint(&join_index_hint_stub);
+  Index_hint group_index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_GROUP, index_hint_name_stub2, sizeof(index_hint_name_stub2) - 1);
+  addIndexHint(&group_index_hint_stub);
+  Index_hint order_index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_ORDER, index_hint_name_stub3, sizeof(index_hint_name_stub3) - 1);
+  addIndexHint(&order_index_hint_stub);
+  table_share.keys_in_use.set(0);
+  table_share.keys_in_use.set(1);
+  table_share.keys_in_use.set(2);
+
+  table_list_lvl0.process_index_hints(&table);
+  
+  EXPECT_TRUE(table.keys_in_use_for_query[0]);
+  EXPECT_TRUE(table.keys_in_use_for_group_by[1]);
+  EXPECT_TRUE(table.keys_in_use_for_order_by[2]);
+}
+
+TEST_F(TableListTest, process_index_hints_ForceIndex_ShouldSet_keys_in_use_Properly)
+{
+  char index_hint_name_stub1[]= "IndexHintNameStub1";
+  char index_hint_name_stub2[]= "IndexHintNameStub2";
+  char index_hint_name_stub3[]= "IndexHintNameStub3";
+  Index_hint join_index_hint_stub(INDEX_HINT_FORCE, INDEX_HINT_MASK_JOIN, index_hint_name_stub1, sizeof(index_hint_name_stub1) - 1);
+  addIndexHint(&join_index_hint_stub);
+  Index_hint group_index_hint_stub(INDEX_HINT_FORCE, INDEX_HINT_MASK_GROUP, index_hint_name_stub2, sizeof(index_hint_name_stub2) - 1);
+  addIndexHint(&group_index_hint_stub);
+  Index_hint order_index_hint_stub(INDEX_HINT_FORCE, INDEX_HINT_MASK_ORDER, index_hint_name_stub3, sizeof(index_hint_name_stub3) - 1);
+  addIndexHint(&order_index_hint_stub);
+  table_share.keys_in_use.set(0);
+  table_share.keys_in_use.set(1);
+  table_share.keys_in_use.set(2);
+  
+  table_list_lvl0.process_index_hints(&table);
+
+  EXPECT_TRUE(table.force_index);
+  EXPECT_TRUE(table.keys_in_use_for_query[0]);
+  EXPECT_TRUE(table.keys_in_use_for_group_by[1]);
+  EXPECT_TRUE(table.keys_in_use_for_order_by[2]);
+}
+
+TEST_F(TableListTest, process_index_hints_IgnoreIndex_ShouldReset_keys_in_use_Properly)
+{
+  char index_hint_name_stub1[]= "IndexHintNameStub1";
+  char index_hint_name_stub2[]= "IndexHintNameStub2";
+  char index_hint_name_stub3[]= "IndexHintNameStub3";
+  Index_hint join_index_hint_stub(INDEX_HINT_IGNORE, INDEX_HINT_MASK_JOIN, index_hint_name_stub1, sizeof(index_hint_name_stub1) - 1);
+  addIndexHint(&join_index_hint_stub);
+  Index_hint group_index_hint_stub(INDEX_HINT_IGNORE, INDEX_HINT_MASK_GROUP, index_hint_name_stub2, sizeof(index_hint_name_stub2) - 1);
+  addIndexHint(&group_index_hint_stub);
+  Index_hint order_index_hint_stub(INDEX_HINT_IGNORE, INDEX_HINT_MASK_ORDER, index_hint_name_stub3, sizeof(index_hint_name_stub3) - 1);
+  addIndexHint(&order_index_hint_stub);
+  table_share.keys_in_use.set(0);
+  table_share.keys_in_use.set(1);
+  table_share.keys_in_use.set(2);
+  table_share.keys_in_use.set(4);
+
+  
+  table_list_lvl0.process_index_hints(&table);
+  
+  EXPECT_FALSE(table.keys_in_use_for_query[0]);
+  EXPECT_FALSE(table.keys_in_use_for_group_by[1]);
+  EXPECT_FALSE(table.keys_in_use_for_order_by[2]);
+  EXPECT_TRUE(table.keys_in_use_for_query[4]);
+  EXPECT_TRUE(table.keys_in_use_for_group_by[4]);
+  EXPECT_TRUE(table.keys_in_use_for_order_by[4]);
+}
+
+TEST_F(TableListTest, process_index_hints_IgnoreIndex_ShouldReset_covering_keys_Too)
+{
+  char index_hint_name_stub[]= "IndexHintNameStub";
+  
+  Index_hint join_index_hint_stub(INDEX_HINT_IGNORE, INDEX_HINT_MASK_JOIN, index_hint_name_stub, sizeof(index_hint_name_stub) - 1);
+  addIndexHint(&join_index_hint_stub);
+  table_share.keys_in_use.set(0);
+  table_share.keys_in_use.set(5);
+  table.covering_keys.set(0);
+  table.covering_keys.set(5);
+  
+  table_list_lvl0.process_index_hints(&table);
+  
+  EXPECT_FALSE(table.covering_keys[0]);
+  EXPECT_TRUE(table.covering_keys[5]);
+}
+
+TEST_F(TableListTest, process_index_hints_ProperInput_shouldReturn_0)
+{
+  char index_hint_name_stub[]= "IndexHintNameStub";
+  Index_hint use_index_hint_stub(INDEX_HINT_USE, INDEX_HINT_MASK_JOIN, index_hint_name_stub, sizeof(index_hint_name_stub) - 1);
+  addIndexHint(&use_index_hint_stub);
+
+  retval= table_list_lvl0.process_index_hints(&table);
+  
+  ASSERT_EQ(0, retval);
+}

=== added file 'unittests/table_proto_write_test.cc'
=== added file 'unittests/table_share_test.cc'
--- unittests/table_share_test.cc	1970-01-01 00:00:00 +0000
+++ unittests/table_share_test.cc	2010-08-15 23:41:09 +0000
@@ -0,0 +1,872 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+*
+*  Copyright (C) 2010 Pawel Blokus
+*
+*  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; either version 2 of the License, or
+*  (at your option) any later version.
+*
+*  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
+*/
+
+#include "config.h"
+
+#include <drizzled/definitions.h>
+#include <drizzled/error.h>
+#include <drizzled/field/enum.h>
+#include <drizzled/field/null.h>
+#include <drizzled/global_charset_info.h>
+#include <drizzled/message/table.pb.h>
+#include <drizzled/sql_base.h>
+#include <drizzled/table.h>
+#include <gtest/gtest.h>
+#include <sstream>
+#include <stdlib.h>
+#include <string>
+
+#include "generator.h"
+#include "plugin/plugin_stubs.h"
+#include "stubs.h"
+
+using namespace drizzled;
+using namespace std;
+
+class TableShareTest : public ::testing::Test
+{
+protected:
+  TableShareStub table_share;
+  bool retval;
+  int retval_int;
+  TableShare *returned_share;
+  uint32_t position;
+  string str;
+  StorageEngineStub storage_engine;
+  TableIdentifier table_id;
+  Session *fake_session;
+  message::Table table_proto;
+  int error_num;
+public:
+
+  TableShareTest()
+  : storage_engine("StorageEngineStub"),
+  table_id("SchemaNameArg", "TableNameArg", "PathArg")
+  {}
+
+  void prepareFilledIndexProto(bool with_key_parts= false, bool unique= true, int key_length= 6,
+                               bool is_primary= false)
+  {
+    message::Table::Index *index= table_proto.add_indexes();
+    message::Table::Index::IndexPart *index_part;
+    message::Table::Index::Options *index_options= index->mutable_options();
+
+    if (with_key_parts)
+    {
+      index_part= index->add_index_part();
+      index_part->set_fieldnr(0);
+      index_part->set_compare_length(5);
+      index_part= index->add_index_part();
+      index_part->set_fieldnr(1);
+      index_part->set_compare_length(5);
+      prepareTableVarcharFieldProto();
+      prepareTableVarcharFieldProto();
+    }
+
+    index->set_name("KeyName");
+    index->set_is_primary(is_primary);
+    index->set_is_unique(unique);
+    index->set_type(message::Table_Index_IndexType_BTREE);
+    index->set_key_length(key_length);
+    
+    index_options->set_pack_key(true);
+    index_options->set_var_length_key(true);
+    index_options->set_null_part_key(true);
+    index_options->set_binary_pack_key(true);
+    index_options->set_has_partial_segments(true);
+    index_options->set_auto_generated_key(true);
+    index_options->set_key_block_size(5);
+  }
+
+  void prepareIndexComment()
+  {
+    table_proto.mutable_indexes(0)->set_comment("Comment");
+  }
+
+  void prepareTableOptionsProto()
+  {
+    message::Table::TableOptions *table_options= table_proto.mutable_options();
+    table_options->set_collation_id(default_charset_info->number);
+    table_options->set_pack_record(true);
+    table_options->set_block_size(10);
+  }
+
+  void prepareTableTimestampFieldProto(const char *default_expression= NULL,
+                                       const char *update_expression= NULL)
+  {
+    message::Table::Field *field= table_proto.add_field();
+
+    field->set_type(message::Table_Field_FieldType_TIMESTAMP);
+    field->set_name("TimestampField");
+    if (default_expression != NULL)
+      field->mutable_options()->set_default_expression(default_expression);
+    if (update_expression != NULL)
+      field->mutable_options()->set_update_expression(update_expression);
+  }
+
+  void prepareTableVarcharFieldProto()
+  {
+    message::Table::Field *field= table_proto.add_field();
+    message::Table::Field::StringFieldOptions *field_options= field->mutable_string_options();
+
+    field->set_type(message::Table_Field_FieldType_VARCHAR);
+    field->set_name("VarcharField");
+    field_options->set_length(20);
+  }
+
+  void prepareTableDecimalFieldProto(bool autoincrement= false, int scale= 10, int precision= 10)
+  {
+    message::Table::Field *field= table_proto.add_field();
+    message::Table::Field::NumericFieldOptions *field_options= field->mutable_numeric_options();
+
+    field->set_type(message::Table_Field_FieldType_DECIMAL);
+    field->set_name("DecimalField");
+    field_options->set_is_autoincrement(autoincrement);
+    field_options->set_scale(scale);
+    field_options->set_precision(precision);
+    field->mutable_constraints()->set_is_nullable(false);
+  }
+
+  void prepareTableIntegerFieldProto(bool autoincrement= false)
+  {
+    message::Table::Field *field= table_proto.add_field();
+    message::Table::Field::NumericFieldOptions *field_options= field->mutable_numeric_options();
+
+    field->set_type(message::Table_Field_FieldType_INTEGER);
+    field->set_name("IntegerField");
+    field_options->set_is_autoincrement(autoincrement);
+    field->mutable_constraints()->set_is_nullable(false);
+  }
+
+  void prepareTableEnumFieldProto(bool with_comment= false, const char *default_value= NULL,
+                                  const string field_name= "", bool is_nullable= true)
+  {
+    message::Table::Field *field= table_proto.add_field();
+    message::Table::Field::EnumerationValues *field_options= field->mutable_enumeration_values();
+
+    field->set_type(message::Table_Field_FieldType_ENUM);
+    field->set_name("EnumField");
+    field_options->add_field_value("Value0");
+    field_options->add_field_value("Value1");
+    field_options->add_field_value("LongerValue2");
+    field->mutable_constraints()->set_is_nullable(is_nullable);
+    if (field_name != "")
+      field->set_name(field_name);
+    if (with_comment)
+      field->set_comment("FieldComment");
+    if (default_value != NULL)
+      field->mutable_options()->set_default_value(default_value);
+  }
+
+  void prepareTableEnumFieldProto(int number)
+  {
+    std::stringstream sin;
+    for (int i= 0; i < number; ++i)
+    {
+      sin.str("FieldName");
+      sin.seekp(9);
+      sin << i;
+      prepareTableEnumFieldProto(false, NULL, sin.str());
+    }
+  }
+  
+  void prepareTableProto()
+  {
+    table_proto.mutable_engine()->set_name("StorageEngineStub");
+    table_proto.set_name("TableName");
+    table_proto.set_schema("TableSchema");
+    table_proto.set_type(message::Table::STANDARD);
+    table_proto.set_creation_timestamp(100);
+    table_proto.set_update_timestamp(100);
+    
+    prepareTableOptionsProto();
+  }
+  
+  virtual void SetUp()
+  {
+    TableShare::cacheStart();
+    system_charset_info= default_charset_info;
+    error_handler_hook= error_handler_func_stub;
+    fake_session= Generator::SessionGenerator::make_fake_session();
+    plugin::StorageEngine::addPlugin(&storage_engine);
+    prepareTableProto();
+  }
+
+  virtual void TearDown()
+  {
+    system_charset_info= NULL;
+    plugin::StorageEngine::removePlugin(&storage_engine);
+  }
+};
+
+TEST_F(TableShareTest, doesKeyNameExist_cstring_NonExistingKey_shouldReturn_False)
+{
+  retval= table_share.doesKeyNameExist("KeyName", 7, position);
+
+  EXPECT_FALSE(retval);
+}
+
+TEST_F(TableShareTest, doesKeyNameExist_cstring_ExistingKey_shouldReturn_True)
+{
+  table_share.addKeyName("KeyName");
+  
+  retval= table_share.doesKeyNameExist("KeyName", 7, position);
+  
+  EXPECT_TRUE(retval);
+}
+
+TEST_F(TableShareTest, doesKeyNameExist_cstring_ExistingKey_shouldReturn_ProperPosition)
+{
+  table_share.addKeyName("KeyName1");
+  table_share.addKeyName("KeyName2");
+  
+  table_share.doesKeyNameExist("KeyName2", 8, position);
+  
+  EXPECT_EQ(1, position);
+}
+
+TEST_F(TableShareTest, doesKeyNameExist_string_NonExistingKey_shouldReturn_False)
+{
+  retval= table_share.doesKeyNameExist("KeyName", position);
+  
+  EXPECT_FALSE(retval);
+}
+
+TEST_F(TableShareTest, doesKeyNameExist_string_ExistingKey_shouldReturn_True)
+{
+  table_share.addKeyName("KeyName");
+  
+  retval= table_share.doesKeyNameExist("KeyName", position);
+  
+  EXPECT_TRUE(retval);
+}
+
+TEST_F(TableShareTest, doesKeyNameExist_string_ExistingKey_shouldReturn_ProperPosition)
+{
+  table_share.addKeyName("KeyName1");
+  table_share.addKeyName("KeyName2");
+  
+  table_share.doesKeyNameExist("KeyName2", position);
+  
+  EXPECT_EQ(1, position);
+}
+
+
+TEST_F(TableShareTest, operator_outputStream)
+{
+  char key[]= "SchemaNameArg\0TableNameArg";
+  char path[]= "PathArg";
+  TableShare table_share_from_id(table_id, TableIdentifier::Key(key, key + sizeof(key)/sizeof(*key)));
+  table_share_from_id.setPath(path, sizeof(path)/sizeof(path[0]));
+  message::Table *proto= new message::Table();
+  
+  ostringstream oss (ostringstream::out);
+  string expected("TableShare:(SchemaNameArg, TableNameArg, STANDARD, PathArg)");
+  table_share_from_id.setTableProto(proto);
+  proto->set_type(message::Table::STANDARD);
+
+  oss << table_share_from_id;
+
+  EXPECT_EQ(expected, oss.str());
+}
+
+TEST_F(TableShareTest, open_table_def_storageEngineReturnsError_ShouldFailAnd_Return_1)
+{
+  storage_engine.setDoGetTableDefinitionReturn(ENOENT);
+
+  retval_int= table_share.open_table_def(*fake_session, table_id);
+
+  EXPECT_EQ(1, retval_int);
+}
+
+TEST_F(TableShareTest, parse_table_proto_ValidInput_shouldReturn_0)
+{
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+
+  EXPECT_EQ(0, retval_int);
+}
+
+TEST_F(TableShareTest, parse_table_proto_ShouldCopyRelevant_TableOptions)
+{
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(default_charset_info, table_share.table_charset);
+  EXPECT_EQ(HA_OPTION_PACK_RECORD, table_share.db_create_options);
+  EXPECT_EQ(HA_OPTION_PACK_RECORD, table_share.db_options_in_use);
+  EXPECT_EQ(10, table_share.block_size);
+}
+
+TEST_F(TableShareTest, parse_table_proto_table_charsetNotSet_ShouldReturn_ER_CORRUPT_TABLE_DEFINITION)
+{
+  table_proto.mutable_options()->set_collation_id(-1);
+
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+
+  ASSERT_EQ(ER_CORRUPT_TABLE_DEFINITION, retval_int);
+}
+
+TEST_F(TableShareTest, parse_table_proto_Index_ShouldCopy_Parameters)
+{
+  prepareFilledIndexProto();
+  
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(HA_KEY_ALG_BTREE, table_share.getKeyInfo(0).algorithm);
+  EXPECT_EQ(6, table_share.getKeyInfo(0).key_length);
+  EXPECT_STREQ("KeyName", table_share.getKeyInfo(0).name);
+}
+
+TEST_F(TableShareTest, parse_table_proto_IndexesWithKeyParts)
+{
+  prepareFilledIndexProto(true);
+  prepareFilledIndexProto(true);
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(2, table_share.keys);
+  EXPECT_EQ(2 * 2, table_share.key_parts);
+  EXPECT_EQ(2, table_share.getKeyInfo(0).key_parts);
+  EXPECT_EQ(2, table_share.getKeyInfo(1).key_parts);
+}
+
+TEST_F(TableShareTest, parse_table_proto_IndexFlags)
+{
+  prepareFilledIndexProto();
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_NOSAME);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_PACK_KEY);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_VAR_LENGTH_PART);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_NULL_PART_KEY);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_BINARY_PACK_KEY);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_KEY_HAS_PART_KEY_SEG);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_GENERATED_KEY);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_USES_BLOCK_SIZE);
+  EXPECT_EQ(5, table_share.getKeyInfo(0).block_size);
+}
+
+TEST_F(TableShareTest, parse_table_proto_Index_KeyInfo_ValuesFromKeyParts)
+{
+  prepareFilledIndexProto(true);
+  table_proto.mutable_field(0)->mutable_constraints()->set_is_nullable(true);
+  
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_NULL_PART_KEY);
+  EXPECT_EQ(2 * (HA_KEY_NULL_LENGTH + HA_KEY_BLOB_LENGTH), table_share.getKeyInfo(0).extra_length);
+  EXPECT_EQ(6 + 2 *(HA_KEY_NULL_LENGTH + HA_KEY_BLOB_LENGTH), table_share.getKeyInfo(0).key_length);
+  EXPECT_EQ(2, table_share.getKeyInfo(0).usable_key_parts);
+}
+
+TEST_F(TableShareTest, parse_table_proto_Index_Field_ValuesFromKeyParts)
+{
+  prepareFilledIndexProto(true);
+  table_proto.mutable_field(0)->mutable_constraints()->set_is_nullable(true);
+  
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_TRUE(table_share.getFields().at(0)->flags & MULTIPLE_KEY_FLAG);
+  EXPECT_TRUE(table_share.getFields().at(0)->key_start.test(0));
+  EXPECT_TRUE(table_share.getFields().at(0)->flags & PART_KEY_FLAG);
+}
+
+TEST_F(TableShareTest, parse_table_proto_Index_Field_ValuesFromKeyParts_PrimaryKey)
+{
+  prepareFilledIndexProto();
+  table_proto.mutable_indexes(0)->add_index_part()->set_fieldnr(0);
+  table_proto.mutable_indexes(0)->mutable_index_part(0)->set_compare_length(4);
+  prepareTableIntegerFieldProto(true);
+
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_TRUE(table_share.getFields().at(0)->flags & PRI_KEY_FLAG);
+}
+
+TEST_F(TableShareTest, parse_table_proto_NoIndexComment_ShouldSetStringTo_NULL)
+{
+  prepareFilledIndexProto();
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  ASSERT_EQ(0, table_share.getKeyInfo(0).comment.length);
+  ASSERT_EQ(NULL, table_share.getKeyInfo(0).comment.str);
+}
+
+TEST_F(TableShareTest, parse_table_proto_IndexHasComment_ShouldSetString)
+{
+  prepareFilledIndexProto();
+  prepareIndexComment();
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_TRUE(table_share.getKeyInfo(0).flags & HA_USES_COMMENT);
+  ASSERT_EQ(strlen("Comment"), table_share.getKeyInfo(0).comment.length);
+  ASSERT_STREQ("Comment", table_share.getKeyInfo(0).comment.str);
+}
+
+TEST_F(TableShareTest, parse_table_proto_KeyName_ShouldBeAdded)
+{
+  prepareFilledIndexProto();
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_TRUE(table_share.doesKeyNameExist("KeyName", position));
+}
+
+TEST_F(TableShareTest, parse_table_proto_IndexKeyParts_ShouldCompute_offset)
+{
+  prepareFilledIndexProto(true);
+  table_proto.mutable_field(0)->mutable_constraints()->set_is_nullable(true);
+
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(1, table_share.getKeyInfo(0).key_part[0].offset);
+  EXPECT_EQ(20 * default_charset_info->mbmaxlen + 2, table_share.getKeyInfo(0).key_part[1].offset);
+}
+
+TEST_F(TableShareTest, parse_table_proto_IndexKeyParts_ShouldCopyParametersTo_KeyPartInfo)
+{
+  prepareFilledIndexProto(true);
+  table_proto.mutable_field(0)->mutable_constraints()->set_is_nullable(true);
+
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(HA_KEYTYPE_VARTEXT1, table_share.getKeyInfo(0).key_part[0].type);
+  EXPECT_EQ(1, table_share.getKeyInfo(0).key_part[0].null_bit);
+  EXPECT_EQ(0, table_share.getKeyInfo(0).key_part[0].null_offset);
+  EXPECT_EQ(5 * default_charset_info->mbmaxlen + HA_KEY_NULL_LENGTH + HA_KEY_BLOB_LENGTH,
+            table_share.getKeyInfo(0).key_part[0].store_length);
+  EXPECT_TRUE(table_share.getKeyInfo(0).key_part[0].key_part_flag & HA_VAR_LENGTH_PART);
+  EXPECT_TRUE(table_share.getKeyInfo(0).key_part[0].key_part_flag & HA_PART_KEY_SEG);
+}
+
+TEST_F(TableShareTest, parse_table_proto_multipleFields_ShouldSet_fields_toFieldNumber)
+{
+  prepareTableEnumFieldProto(3);
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(3, table_share.fields);
+}
+
+TEST_F(TableShareTest, parse_table_proto_multipleFields_ShouldSet_null_fields)
+{
+  prepareTableEnumFieldProto(3);
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(3, table_share.null_fields);
+}
+
+TEST_F(TableShareTest, parse_table_proto_singleField_ShouldSet_RecordLength_and_stored_rec_length)
+{
+  prepareTableEnumFieldProto();
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(2, table_share.getRecordLength());
+  EXPECT_EQ(2, table_share.stored_rec_length);
+}
+
+TEST_F(TableShareTest, parse_table_proto_multipleFields_ShouldSet_RecordLength_and_stored_rec_length)
+{
+  prepareTableEnumFieldProto(3);
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(4, table_share.getRecordLength());
+  EXPECT_EQ(4, table_share.stored_rec_length);
+}
+
+TEST_F(TableShareTest, parse_table_proto_noFields_fields_ShouldHaveSize_1)
+{
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  ASSERT_EQ(1, table_share.getFields().size());
+  ASSERT_EQ(NULL, table_share.getFields().at(0));
+}
+
+TEST_F(TableShareTest, parse_table_proto_multipleFields_ShouldSet_fields)
+{
+  prepareTableEnumFieldProto(3);
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  ASSERT_EQ(4, table_share.getFields().size());
+  ASSERT_EQ(NULL, table_share.getFields().at(3));
+}
+
+TEST_F(TableShareTest, parse_table_proto_singleEnumField_ShouldSet_TYPELIB)
+{
+  prepareTableEnumFieldProto();
+  TYPELIB *typelib;
+  
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  typelib= ((Field_enum*)table_share.getFields().at(0))->typelib;
+
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(3, typelib->count);
+  EXPECT_STREQ("Value0", typelib->type_names[0]);
+  EXPECT_STREQ("Value1", typelib->type_names[1]);
+  EXPECT_STREQ("LongerValue2", typelib->type_names[2]);
+  EXPECT_EQ(strlen("Value0"), typelib->type_lengths[0]);
+  EXPECT_EQ(strlen("Value1"), typelib->type_lengths[1]);
+  EXPECT_EQ(strlen("LongerValue2"), typelib->type_lengths[2]);
+}
+
+TEST_F(TableShareTest, parse_table_proto_FieldWithComment)
+{
+  prepareTableEnumFieldProto(true);
+
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(strlen("FieldComment"), table_share.getFields().at(0)->comment.length);
+  EXPECT_STREQ("FieldComment", table_share.getFields().at(0)->comment.str);
+}
+
+TEST_F(TableShareTest, parse_table_proto_FieldWithDefaultValue)
+{
+  String string_buf;
+  Table table;
+  Field *field;
+  prepareTableEnumFieldProto(false, "Value1");
+  
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  table.resetTable(fake_session, &table_share, 0);
+  field= table_share.getFields().at(0);
+  field->setTable(&table);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_STREQ("Value1", field->val_str(&string_buf)->c_str());
+}
+
+TEST_F(TableShareTest, parse_table_proto_FieldWith_Invalid_DefaultValue_shouldReturn_1)
+{
+  String string_buf;
+  prepareTableEnumFieldProto(false, "InvalidValue");
+  
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(1, retval_int);
+}
+
+TEST_F(TableShareTest, parse_table_proto_singleEnumField_ShouldCompute_field_length_fromLongestValue)
+{
+  prepareTableEnumFieldProto();
+  
+  retval_int= table_share.parse_table_proto(*fake_session, table_proto);
+  
+  ASSERT_EQ(0, retval_int);
+  EXPECT_EQ(strlen("LongerValue2") * default_charset_info->mbmaxlen,
+            table_share.getFields().at(0)->field_length);
+}
+
+TEST_F(TableShareTest, parse_table_proto_singleField_noDefaultValue_ShouldSet_NO_DEFAULT_VALUE_FLAG)
+{
+  prepareTableEnumFieldProto(false, NULL, "", false);
+  table_share.resizeDefaultValues(1);
+  *(table_share.getDefaultValues())= 0;
+  table_proto.mutable_options()->set_pack_record(true);
+