Merge lp:~3v1n0/nux/text-entry-virtual-clipboard into lp:nux

[Marco Trevisan (Treviño)]

TextEntry: make the clipboard functions virtual to be implemented by clients

Added virtual methods for clipboard management, so that clients could override the code.

Added a lot of tests to check the events behavior.

UNBLOCK

[Brandon Schaefer (brandontschaefer)]

All test pass, and look good. +1

review: Approve

[Thomi Richards (thomir)]

Why do we have this in the code?

195 + // TODO

We shouldn't be merging unfinished code. If it's intentionally left empty, please add a comment to that effect. Otherwise, looks great.

review: Needs Fixing (quality)

[Thomi Richards (thomir)]

Apparently bschafer and Trevino *promise* me that this will actually get done, and not be left in the code forever, like some unwanted relative that keeps showing up every christmas time but no one can understand them and no one really knows how they're related to the family...

Where was I? Oh yeah, Approved.

review: Approve (quality)

[lp:~3v1n0/nux/text-entry-virtual-clipboard]

656. By Marco Trevisan (Treviño) on 2012-07-03

InputMethodIBus: fix IsHotkeyEvent for key-up events

657. By Marco Trevisan (Treviño) on 2012-07-03

TextEntry: make IBus to be the first to eat events, also ignore keyup ones

Only ibus can need keyup events, so we just send them to it.

=== modified file 'Nux/InputMethodIBus.cpp'
--- Nux/InputMethodIBus.cpp	2012-07-03 13:57:17 +0000
+++ Nux/InputMethodIBus.cpp	2012-07-03 23:03:18 +0000
@@ -122,6 +122,7 @@
         NULL,
         reinterpret_cast<GAsyncReadyCallback>(ProcessKeyEventDone),
         new ProcessKeyEventData(this, event));
+
       return true;
     }
     return false;
@@ -372,7 +373,8 @@
   void IBusIMEContext::ProcessKeyEventDone(IBusInputContext *context, GAsyncResult* res, ProcessKeyEventData *data)
   {
     //nuxDebugMsg("***IBusIMEContext::ProcessKeyEventDone***");
-      nuxAssert(data->context->context_ == context);
+      std::unique_ptr<ProcessKeyEventData> key_ev(data);
+      nuxAssert(key_ev->context->context_ == context);
 
       GError *error = NULL;
       gboolean processed = ibus_input_context_process_key_event_async_finish (
@@ -380,22 +382,20 @@
                             res,
                             &error);
 
-      if (error != NULL)
+      if (error)
       {
         g_warning ("Process Key Event failed: %s.", error->message);
         g_error_free (error);
       }
 
-      if (processed == FALSE)
+      if (!processed)
       {
-        data->context->text_entry_->ProcessKeyEvent(data->event.type(),
-                                                    data->event.key_sym(),
-                                                    data->event.flags() | IBUS_IGNORED_MASK,
-                                                    data->event.character().c_str(),
-                                                    0);
+        key_ev->context->text_entry_->ProcessKeyEvent(key_ev->event.type(),
+                                                      key_ev->event.key_sym(),
+                                                      key_ev->event.flags() | IBUS_IGNORED_MASK,
+                                                      key_ev->event.character().c_str(),
+                                                      0);
       }
-
-      delete data;
   }
 
   std::vector<Event> IBusIMEContext::ParseIBusHotkeys(const gchar** keybindings)
@@ -506,7 +506,7 @@
     {
       if (ev.x11_keysym == keysym && (ev.type == type || type == EVENT_KEY_DOWN))
       {
-        if (type == EVENT_KEY_UP)
+        if (ev.type == EVENT_KEY_UP)
           return (modifiers & ev.key_modifiers);
         else
           return (ev.key_modifiers == modifiers);

=== modified file 'Nux/TextEntry.cpp'
--- Nux/TextEntry.cpp	2012-07-03 19:16:38 +0000
+++ Nux/TextEntry.cpp	2012-07-03 23:03:18 +0000
@@ -237,15 +237,26 @@
 
   void TextEntry::ProcessMouseEvent(int event_type, int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
   {
-    if (GetEventButton(button_flags) != 1 && event_type != NUX_MOUSE_MOVE)
-      return;
-
-    //ResetImContext();
-    //Event::Type type = event.GetType();
-
     int X = static_cast<int>(x /*round(event.GetX())*/) - kInnerBorderX - scroll_offset_x_;
     int Y = static_cast<int>(y /*round(event.GetY())*/) - kInnerBorderY - scroll_offset_y_;
     int index = XYToTextIndex(X, Y);
+    MouseButton button = GetEventButton(button_flags);
+
+    if (event_type == NUX_MOUSE_PRESSED && (button == 2 || button == 3))
+    {
+      SetCursor(index);
+#if defined(NUX_OS_LINUX)
+      if (button == 2)
+        PastePrimaryClipboard();
+#endif
+      QueueRefresh(false, true);
+
+      return;
+    }
+
+    if (button != 1 && event_type != NUX_MOUSE_MOVE)
+      return;
+
     int sel_start, sel_end;
     GetSelectionBounds(&sel_start, &sel_end);
 
@@ -253,7 +264,7 @@
 
     if ((event_type == NUX_MOUSE_PRESSED) && (current_time - last_dblclick_time_ <= kTripleClickTimeout))
     {
-        SelectLine();
+      SelectLine();
     }
     else if (event_type == NUX_MOUSE_DOUBLECLICK && !ime_active_)
     {
@@ -294,7 +305,22 @@
     const char*      character ,   /*character*/
     unsigned short   keyCount      /*key repeat count*/)
   {
-    bool im_filtered = false;
+#if defined(NUX_OS_LINUX)
+    if (im_running())
+    {
+      // FIXME Have to get the current event for the x11_keycode for ibus-hangul/korean input
+      nux::Event const& cur_event = GetGraphicsDisplay()->GetCurrentEvent();
+      KeyEvent event(static_cast<EventType>(event_type), keysym, cur_event.x11_keycode, state, character);
+
+      if (ime_->FilterKeyEvent(event))
+        return;
+    }
+#endif
+
+    /* Ignore all the keyup events to make Composition and Dead keys to work,
+     * as no one (IBus a part) needs them */
+    if (event_type == NUX_KEYUP)
+      return;
 
 #if defined(NUX_OS_LINUX)
     if (dead_key_mode_ && keysym == XK_space)
@@ -313,17 +339,10 @@
     {
       return;
     }
-
-    // FIXME Have to get the current event fot he x11_keycode for ibus-hangul/korean input
-    nux::Event const& cur_event = GetGraphicsDisplay()->GetCurrentEvent();
-    KeyEvent event(static_cast<EventType>(event_type), keysym, cur_event.x11_keycode, state, character);
-    im_filtered = ime_->FilterKeyEvent(event);
 #endif
 
     if (event_type == NUX_KEYDOWN)
       text_input_mode_ = true;
-    else if (event_type == NUX_KEYUP)
-      return;
 
     cursor_blink_status_ = 4;
 
@@ -343,7 +362,7 @@
     if (keysym == NUX_VK_TAB)
       return;
 
-    if ((keysym == NUX_VK_ENTER || keysym == NUX_KP_ENTER) && !im_filtered)
+    if ((keysym == NUX_VK_ENTER || keysym == NUX_KP_ENTER))
     {
       activated.emit();
       return;
@@ -354,7 +373,7 @@
     bool ctrl = (state & NUX_STATE_CTRL);
 
     // DLOG("TextEntry::key_down(%d, shift:%d ctrl:%d)", keyval, shift, ctrl);
-    if (event_type == NUX_KEYDOWN && !im_filtered)
+    if (event_type == NUX_KEYDOWN)
     {
       if (keyval == NUX_VK_LEFT)
       {
@@ -464,18 +483,15 @@
 //       }
     }
 
-    if (!im_filtered)
+    if (character)
     {
-      if (character)
-      {
-        unsigned int utf_char = g_utf8_get_char(character);
-
-        if (g_unichar_isprint(utf_char))
-          EnterText(character);
-      }
-
-      QueueRefresh(false, true);
+      unsigned int utf_char = g_utf8_get_char(character);
+
+      if (g_unichar_isprint(utf_char))
+        EnterText(character);
     }
+
+    QueueRefresh(false, true);
   }
 
   void TextEntry::RecvMouseDoubleClick(int x, int y, unsigned long button_flags, unsigned long key_flags)
@@ -610,7 +626,7 @@
   {
 #if defined(NUX_OS_LINUX)
     /* Checks if the keysym between the first and last dead key */
-    if ((keysym >= XK_dead_grave) && (keysym <= XK_dead_stroke) && !dead_key_mode_)
+    if (character && (keysym >= XK_dead_grave) && (keysym <= XK_dead_stroke) && !dead_key_mode_)
     {
       int key = keysym - XK_dead_grave;
       dead_key_mode_ = true;
@@ -656,7 +672,7 @@
       return true;
     }
 
-    if (composition_mode_)
+    if (composition_mode_ && character)
     {
       if (strncmp(character, "", 1) == 0 && keysym != NUX_VK_SHIFT)
       {
@@ -1782,6 +1798,7 @@
   {
     CopyClipboard();
     DeleteSelection();
+    QueueRefresh(true, true);
   }
 
   void TextEntry::PasteClipboard()
@@ -1795,6 +1812,13 @@
 //     }
   }
 
+#if defined(NUX_OS_LINUX)
+  void TextEntry::PastePrimaryClipboard()
+  {
+    // TODO
+  }
+#endif
+
   void TextEntry::BackSpace(MovementStep step)
   {
     if (GetSelectionBounds(NULL, NULL))

=== modified file 'Nux/TextEntry.h'
--- Nux/TextEntry.h	2012-07-03 19:16:38 +0000
+++ Nux/TextEntry.h	2012-07-03 23:03:18 +0000
@@ -325,11 +325,15 @@
     void DeleteSelection();
 
     /** Cut the current selected text to the clipboard */
-    void CutClipboard();
+    virtual void CutClipboard();
     /** Copy the current selected text to the clipboard */
-    void CopyClipboard();
+    virtual void CopyClipboard();
     /** Paste the text in the clipboard to current offset */
-    void PasteClipboard();
+    virtual void PasteClipboard();
+#if defined(NUX_OS_LINUX)
+    /** Paste the text in the primary clipboard to current offset */
+    virtual void PastePrimaryClipboard();
+#endif
     /** Delete a character before the offset of the cursor */
     void BackSpace(MovementStep step);
     /** Delete a character at the offset of the cursor */

=== modified file 'tests/gtest-nux-textentry.cpp'
--- tests/gtest-nux-textentry.cpp	2012-07-03 14:55:18 +0000
+++ tests/gtest-nux-textentry.cpp	2012-07-03 23:03:18 +0000
@@ -1,26 +1,64 @@
+/*
+ * Copyright 2012 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3, as
+ * published by the  Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the applicable version of the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of both the GNU Lesser General Public
+ * License version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Marco Trevisan <[e-mail]>
+ *
+ */
+
+#include "gtest-nux-utils.h"
+
 #include <gmock/gmock.h>
 
 #include "Nux/Nux.h"
 #include "Nux/TextEntry.h"
+#include "Nux/HLayout.h"
 #if defined(NUX_OS_LINUX)
 #include "Nux/InputMethodIBus.h"
 #endif
 
-
 using namespace testing;
 using namespace nux;
 
 namespace {
 
-class MockTextEntry : public nux::TextEntry
+class MockTextEntry : public TextEntry
 {
 public:
-  MockTextEntry(const char* text) : nux::TextEntry(text)
+  MockTextEntry() : TextEntry("")
   {}
 
-  bool InspectKeyEvent(nux::Event const& event)
-  {
-    return nux::TextEntry::InspectKeyEvent(event);
+  bool InspectKeyEvent(Event const& event)
+  {
+    return TextEntry::InspectKeyEvent(event);
+  }
+
+  bool GetSelectionBounds(int* start, int* end) const
+  {
+    return TextEntry::GetSelectionBounds(start, end);
+  }
+
+  int GetCursor() const
+  {
+    return cursor_;
+  }
+
+  void SetCursor(int cursor)
+  {
+    TextEntry::SetCursor(cursor);
   }
 
   nux::IBusIMEContext* ime() const
@@ -31,6 +69,44 @@
     return nullptr;
 #endif
   }
+
+  void WaitEvent()
+  {
+    if (im_running())
+      Utils::WaitForTimeoutMSec(100);
+  }
+
+  MOCK_METHOD0(CutClipboard, void());
+  MOCK_METHOD0(CopyClipboard, void());
+  MOCK_METHOD0(PasteClipboard, void());
+#if defined(NUX_OS_LINUX)
+  MOCK_METHOD0(PastePrimaryClipboard, void());
+#endif
+};
+
+class TestEvent : public Event
+{
+public:
+  TestEvent(KeyModifier keymod, unsigned long keysym)
+  {
+    type = NUX_KEYDOWN;
+    key_modifiers = keymod;
+#if defined(NUX_OS_LINUX)
+    x11_keysym = keysym;
+#elif defined(NUX_OS_WINDOWS)
+    win32_keysym = keysym;
+#endif
+  }
+
+  TestEvent(unsigned long keysym)
+  {
+    type = NUX_KEYDOWN;
+#if defined(NUX_OS_LINUX)
+    x11_keysym = keysym;
+#elif defined(NUX_OS_WINDOWS)
+    win32_keysym = keysym;
+#endif
+  }
 };
 
 class TestTextEntry : public Test
@@ -38,16 +114,20 @@
 public:
   virtual void SetUp()
   {
-    nux::NuxInitialize(0);
-    wnd_thread.reset(nux::CreateNuxWindow("Nux Window", 300, 200,
-                     nux::WINDOWSTYLE_NORMAL, NULL, false, NULL, NULL));
-
-    text_entry = new MockTextEntry("");
-    nux::GetWindowThread()->GetWindowCompositor().SetKeyFocusArea(text_entry.GetPointer());
+    NuxInitialize(0);
+    wnd_thread.reset(CreateNuxWindow("Nux Window", 300, 200, WINDOWSTYLE_NORMAL,
+                     nullptr, false, NULL, NULL));
+
+    text_entry = new MockTextEntry();
+    HLayout* layout = new HLayout();
+    layout->AddView(text_entry);
+    wnd_thread->SetLayout(layout);
+
+    GetWindowCompositor().SetKeyFocusArea(text_entry);
   }
 
-  std::unique_ptr<nux::WindowThread> wnd_thread;
-  nux::ObjectPtr<MockTextEntry> text_entry;
+  std::unique_ptr<WindowThread> wnd_thread;
+  MockTextEntry* text_entry;
 };
 
 TEST_F(TestTextEntry, TestSetText)
@@ -81,9 +161,9 @@
 
   EXPECT_EQ(text_entry->IsInTextInputMode(), true);
 
-  nux::GetWindowThread()->GetWindowCompositor().SetKeyFocusArea(NULL);
+  GetWindowCompositor().SetKeyFocusArea(nullptr);
 
-  nux::GetWindowThread()->GetWindowCompositor().SetKeyFocusArea(text_entry.GetPointer());
+  GetWindowCompositor().SetKeyFocusArea(text_entry);
 
   EXPECT_EQ(text_entry->IsInTextInputMode(), false);
 
@@ -95,23 +175,6 @@
 }
 
 #if defined(NUX_OS_LINUX)
-class TestEvent : public nux::Event
-{
-public:
-  TestEvent(nux::KeyModifier keymod, unsigned long keysym)
-  {
-    type = nux::NUX_KEYDOWN;
-    key_modifiers = keymod;
-    x11_keysym = keysym;
-  }
-
-  TestEvent(unsigned long keysym)
-  {
-    type = nux::NUX_KEYDOWN;
-    x11_keysym = keysym;
-  }
-};
-
 TEST_F(TestTextEntry, AltLinuxKeybindings)
 {
   for (unsigned long keysym = 0; keysym < XK_VoidSymbol; ++keysym)
@@ -149,8 +212,181 @@
     unsigned int keysym = g_utf8_get_char(c.c_str());
     text_entry->DeleteText(0, std::numeric_limits<int>::max());
     text_entry->key_down.emit(NUX_KEYDOWN, keysym, 0, c.c_str(), 1);
+    text_entry->WaitEvent();
     EXPECT_EQ(text_entry->GetText(), "");
   }
 }
 
+TEST_F(TestTextEntry, CopyCtrlC)
+{
+  EXPECT_CALL(*text_entry, CopyClipboard());
+  TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_c);
+  GetWindowCompositor().ProcessEvent(event);
+  text_entry->WaitEvent();
+}
+
+TEST_F(TestTextEntry, CopyCtrlIns)
+{
+  EXPECT_CALL(*text_entry, CopyClipboard());
+  TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_INSERT);
+  GetWindowCompositor().ProcessEvent(event);
+  text_entry->WaitEvent();
+}
+
+TEST_F(TestTextEntry, PasteCtrlV)
+{
+  EXPECT_CALL(*text_entry, PasteClipboard());
+  TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_v);
+  GetWindowCompositor().ProcessEvent(event);
+  text_entry->WaitEvent();
+}
+
+TEST_F(TestTextEntry, PasteShiftIns)
+{
+  EXPECT_CALL(*text_entry, PasteClipboard());
+  TestEvent event(KEY_MODIFIER_SHIFT, NUX_VK_INSERT);
+  GetWindowCompositor().ProcessEvent(event);
+  text_entry->WaitEvent();
+}
+
+#if defined(NUX_OS_LINUX)
+TEST_F(TestTextEntry, PastePrimaryClipboard)
+{
+  EXPECT_CALL(*text_entry, PastePrimaryClipboard());
+  text_entry->mouse_down.emit(0, 0, NUX_EVENT_BUTTON2_DOWN, 0);
+
+  EXPECT_CALL(*text_entry, PastePrimaryClipboard()).Times(0);
+  text_entry->mouse_down.emit(0, 0, NUX_EVENT_BUTTON1_DOWN, 0);
+
+  EXPECT_CALL(*text_entry, PastePrimaryClipboard()).Times(0);
+  text_entry->mouse_down.emit(0, 0, NUX_EVENT_BUTTON3_DOWN, 0);
+}
+#endif
+
+TEST_F(TestTextEntry, CutCtrlX)
+{
+  EXPECT_CALL(*text_entry, CutClipboard());
+  TestEvent event(KEY_MODIFIER_CTRL, NUX_VK_x);
+  GetWindowCompositor().ProcessEvent(event);
+  text_entry->WaitEvent();
+}
+
+TEST_F(TestTextEntry, CutShiftDel)
+{
+  EXPECT_CALL(*text_entry, CutClipboard());
+  TestEvent event(KEY_MODIFIER_SHIFT, NUX_VK_DELETE);
+  GetWindowCompositor().ProcessEvent(event);
+  text_entry->WaitEvent();
+}
+
+TEST_F(TestTextEntry, CtrlA)
+{
+  TestEvent selectall(KEY_MODIFIER_CTRL, NUX_VK_a);
+  int start, end;
+  const std::string test_str("Nux");
+  text_entry->EnterText(test_str.c_str());
+  EXPECT_FALSE(text_entry->GetSelectionBounds(&start, &end));
+  ASSERT_EQ(start, end);
+  ASSERT_EQ(start, test_str.length());
+
+  GetWindowCompositor().ProcessEvent(selectall);
+  text_entry->WaitEvent();
+  EXPECT_TRUE(text_entry->GetSelectionBounds(&start, &end));
+  EXPECT_EQ(start, 0);
+  EXPECT_EQ(end, test_str.length());
+}
+
+TEST_F(TestTextEntry, MoveKeys)
+{
+  const std::string test_str("Nux");
+  text_entry->EnterText(test_str.c_str());
+  ASSERT_EQ(text_entry->GetCursor(), test_str.length());
+  text_entry->SetCursor(0);
+  ASSERT_EQ(text_entry->GetCursor(), 0);
+
+  TestEvent right(NUX_VK_RIGHT);
+  GetWindowCompositor().ProcessEvent(right);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetCursor(), 1);
+
+  TestEvent end(NUX_VK_END);
+  GetWindowCompositor().ProcessEvent(end);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetCursor(), test_str.length());
+
+  TestEvent left(NUX_VK_LEFT);
+  GetWindowCompositor().ProcessEvent(left);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetCursor(), 2);
+
+  TestEvent home(NUX_VK_HOME);
+  GetWindowCompositor().ProcessEvent(home);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetCursor(), 0);
+}
+
+TEST_F(TestTextEntry, CtrlMoveKeys)
+{
+  const std::string test_str("Nux Text Entry");
+  text_entry->EnterText(test_str.c_str());
+  ASSERT_EQ(text_entry->GetCursor(), test_str.length());
+  text_entry->SetCursor(0);
+  ASSERT_EQ(text_entry->GetCursor(), 0);
+
+  TestEvent right(KEY_MODIFIER_CTRL, NUX_VK_RIGHT);
+  GetWindowCompositor().ProcessEvent(right);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetCursor(), 3);
+
+  TestEvent left(KEY_MODIFIER_CTRL, NUX_VK_LEFT);
+  GetWindowCompositor().ProcessEvent(left);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetCursor(), 0);
+
+  TestEvent end(KEY_MODIFIER_CTRL, NUX_VK_END);
+  GetWindowCompositor().ProcessEvent(end);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetCursor(), test_str.length());
+
+  TestEvent home(KEY_MODIFIER_CTRL, NUX_VK_HOME);
+  GetWindowCompositor().ProcessEvent(home);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetCursor(), 0);
+}
+
+TEST_F(TestTextEntry, DeleteKeys)
+{
+  const std::string test_str("Nux");
+  text_entry->EnterText(test_str.c_str());
+  text_entry->SetCursor(0);
+
+  TestEvent del(NUX_VK_DELETE);
+  GetWindowCompositor().ProcessEvent(del);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetText(), "ux");
+
+  text_entry->SetCursor(std::string(text_entry->GetText()).length());
+  TestEvent backspace(NUX_VK_BACKSPACE);
+  GetWindowCompositor().ProcessEvent(backspace);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetText(), "u");
+}
+
+TEST_F(TestTextEntry, CtrlDeleteKeys)
+{
+  const std::string test_str("Nux Text Entry");
+  text_entry->EnterText(test_str.c_str());
+  text_entry->SetCursor(0);
+
+  TestEvent del(KEY_MODIFIER_CTRL, NUX_VK_DELETE);
+  GetWindowCompositor().ProcessEvent(del);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetText(), " Text Entry");
+
+  text_entry->SetCursor(std::string(text_entry->GetText()).length());
+  TestEvent backspace(KEY_MODIFIER_CTRL, NUX_VK_BACKSPACE);
+  GetWindowCompositor().ProcessEvent(backspace);
+  text_entry->WaitEvent();
+  EXPECT_EQ(text_entry->GetText(), " Text ");
+}
 }

=== added file 'tests/gtest-nux-utils.h'
--- tests/gtest-nux-utils.h	1970-01-01 00:00:00 +0000
+++ tests/gtest-nux-utils.h	2012-07-03 23:03:18 +0000
@@ -0,0 +1,58 @@
+#ifndef TEST_UTILS_H
+#define TEST_UTILS_H
+
+#include <glib.h>
+#include <gtest/gtest.h>
+
+namespace
+{
+
+class Utils
+{
+public:
+  static void WaitUntil(bool& success, unsigned int max_wait = 10)
+  {
+    bool timeout_reached = false;
+    guint32 timeout_id = ScheduleTimeout(&timeout_reached, max_wait * 1000);
+
+    while (!success && !timeout_reached)
+      g_main_context_iteration(g_main_context_get_thread_default(), TRUE);
+
+    if (success)
+      g_source_remove(timeout_id);
+
+    EXPECT_TRUE(success);
+  }
+
+  static guint32 ScheduleTimeout(bool* timeout_reached, unsigned int timeout_duration = 10)
+  {
+    return g_timeout_add(timeout_duration, TimeoutCallback, timeout_reached);
+  }
+
+  static void WaitForTimeout(unsigned int timeout_duration = 10)
+  {
+    WaitForTimeoutMSec(timeout_duration * 1000);
+  }
+
+  static void WaitForTimeoutMSec(unsigned int timeout_duration = 10)
+  {
+    bool timeout_reached = false;
+    guint32 timeout_id = ScheduleTimeout(&timeout_reached, timeout_duration);
+
+    while (!timeout_reached)
+      g_main_context_iteration(g_main_context_get_thread_default(), TRUE);
+
+    g_source_remove(timeout_id);
+  }
+
+private:
+  static gboolean TimeoutCallback(gpointer data)
+  {
+    *(bool*)data = true;
+    return FALSE;
+  };
+};
+
+}
+
+#endif

=== modified file 'tests/xtest-text-entry.cpp'
--- tests/xtest-text-entry.cpp	2012-07-02 22:56:02 +0000
+++ tests/xtest-text-entry.cpp	2012-07-03 23:03:18 +0000
@@ -353,13 +353,13 @@
     {
       // Type random stuff
       {
-        test.ViewSendString("qwerty");
+        test.ViewSendString("ninhao");
         nux::SleepForMilliseconds(500);
         test.TestReportMsg(test_textentry->text_entry_->GetText() == "", "TextEntry is only Preedit");
 
         test.ViewSendChar('1');
         nux::SleepForMilliseconds(500);
-        test.TestReportMsg(test_textentry->text_entry_->GetText() == "请问儿童有", "TextEntry is \"请问儿童有\"");
+        test.TestReportMsg(test_textentry->text_entry_->GetText() == "您好", "TextEntry is \"您好\"");
 
         test.ViewSendCtrlA();
         nux::SleepForMilliseconds(500);