static gboolean
hime_zuin_label_show (void)
{
char *pszTmp = NULL;
char *pszWord = NULL;
int nZuinLen = 0, nIdx = 0, nPhoIdx = 0;
pszTmp = chewing_zuin_String (g_pChewingCtx, &nZuinLen);
pszWord = (char *) realloc (pszWord, 4);
if (!pszWord)
return FALSE;
memset (pszWord, 0x00, 4);
if (pszTmp)
{
for (nIdx = 0; nIdx < nZuinLen; nIdx++)
{
memcpy (pszWord, pszTmp + nIdx * 3, 3);
for (nPhoIdx = 0; nPhoIdx < 3; nPhoIdx++)
if (strstr (g_himeModMainFuncs.mf_pho_chars[nPhoIdx], pszWord) != NULL)
hime_label_show (pszWord, nPhoIdx + chewing_buffer_Len (g_pChewingCtx) + 1);
}
free (pszTmp);
}
free (pszWord);
return TRUE;
}
void MainWindow::keyPressEvent(QKeyEvent* evt)
{
int key = evt->key();
if(key >= 0x21 && key <= 0x5a)
{
if (key >= 'A' && key <= 'Z')
key += 'a' - 'A'; // shift to upper case
chewing_handle_Default(this->_ct, key);
}
else if(key == Qt::Key_Space)
{
chewing_handle_Space(this->_ct);
}
else if(key == Qt::Key_Return)
{
/* key_Enter : the enter key on the keypad... */
chewing_handle_Enter(this->_ct);
}
else if(key == Qt::Key_Backspace)
{
/*
* When there's a text input box (QLineEdit),
* Qt::Key_Backspace is consumed by that input box.
*/
chewing_handle_Backspace(this->_ct);
}
else if(key == Qt::Key_Escape)
{
chewing_handle_Esc(this->_ct);
}
else
{
QMainWindow::keyPressEvent(evt);
}
int zuin_size = 0;
char* aux_buf = chewing_aux_String(this->_ct);
char* zuin_buf = chewing_zuin_String(this->_ct, &zuin_size);
char* buf_buf = chewing_buffer_String(this->_ct);
char* com_buf = chewing_commit_String(this->_ct);
//printf("A|Z|B|C\n%s|%s|%s|%s\n", aux_buf, zuin_buf, buf_buf, com_buf);
this->_lblChewing->setText(QString::fromUtf8(zuin_buf));
this->_lblBuffer->setText(QString::fromUtf8(buf_buf));
QString comString = QString::fromUtf8(com_buf);
this->_lblAux->setText(QString::fromUtf8(aux_buf));
if(chewing_commit_Check(this->_ct))
{
this->_lblCommit->setText(comString);
this->_lblLine->setText(this->_lblLine->text() + comString);
}
else
{
this->_lblCommit->setText("");
}
free(aux_buf);
free(zuin_buf);
free(buf_buf);
free(com_buf);
}
static gboolean
is_empty (void)
{
if (!g_pChewingCtx)
return FALSE;
int nZuinLen = 0;
free(chewing_zuin_String (g_pChewingCtx, &nZuinLen));
return !chewing_buffer_Len (g_pChewingCtx) && !nZuinLen;
}
static int
hime_chewing_wrapper_bs (ChewingContext *pCtx)
{
// If zuin is present, force libchewing handles Backspace for removing last zuin
int nZuinLen = 0;
free(chewing_zuin_String (g_pChewingCtx, &nZuinLen));
if (nZuinLen)
return chewing_handle_Backspace (g_pChewingCtx);
HIME_CHEWING_WRAPPER_FUNC (chewing_handle_Backspace);
}
// FIXME: refine and chk
int
module_get_preedit (char *pszStr, HIME_PREEDIT_ATTR himePreeditAttr[],
int *pnCursor, int *pCompFlag)
{
char *pszTmpStr = NULL;
char *pszZuinStr = NULL;
int nIdx;
int nLength;
int nTotalLen = 0;
int nAttr = 0;
int nZuinLen = 0;
pszStr[0] = 0;
*pnCursor = 0;
himePreeditAttr[0].flag = HIME_PREEDIT_ATTR_FLAG_UNDERLINE;
himePreeditAttr[0].ofs0 = 0;
if (chewing_buffer_Len (g_pChewingCtx))
nAttr = 1;
for (nIdx = 0; nIdx < chewing_buffer_Len (g_pChewingCtx); nIdx++)
{
pszTmpStr = (char *)gtk_label_get_text (GTK_LABEL (g_pSeg[nIdx].label));
nLength = g_himeModMainFuncs.mf_utf8_str_N (pszTmpStr);
nTotalLen += nLength;
if (nIdx < chewing_cursor_Current (g_pChewingCtx))
*pnCursor += nLength;
#if 0
if (nIdx == chewing_cursor_Current (g_pChewingCtx))
{
himePreeditAttr[1].ofs0 = *pnCursor;
himePreeditAttr[1].ofs1 = *pnCursor + nLength;
himePreeditAttr[1].flag = HIME_PREEDIT_ATTR_FLAG_REVERSE;
nAttr++;
}
#endif
strcat (pszStr, pszTmpStr);
}
if (g_himeModMainFuncs.mf_hime_display_on_the_spot_key()) {
pszZuinStr = chewing_zuin_String (g_pChewingCtx, &nZuinLen);
strcat (pszStr, pszZuinStr);
free (pszZuinStr);
nTotalLen += nZuinLen;
}
himePreeditAttr[0].ofs1 = nTotalLen;
pCompFlag = 0;
return nAttr;
}
void showZuin( ChewingContext *ctx )
{
int zuin_count;
char *zuin_string;
if ( chewing_get_ChiEngMode( ctx ) )
addstr( "[中]" );
else
addstr( "[英]" );
addstr( " " );
zuin_string = chewing_zuin_String( ctx, &zuin_count );
addstr( zuin_string );
free( zuin_string );
}
gboolean
module_feedkey (int nKeyVal, int nKeyState)
{
char *pszTmp = NULL;
char *pszChewingCand = NULL;
int nZuinLen = 0;
char szWord[4];
int nPhoIdx, nBufIdx;
int nIdx;
if (!g_pChewingCtx)
return FALSE;
memset (szWord, 0x00, 4);
if (!g_himeModMainFuncs.mf_tsin_pho_mode ())
return FALSE;
switch (nKeyVal)
{
case XK_space:
chewing_handle_Space (g_pChewingCtx);
break;
case XK_Escape:
chewing_handle_Esc (g_pChewingCtx);
break;
case XK_Return:
case XK_KP_Enter:
chewing_handle_Enter (g_pChewingCtx);
break;
case XK_Delete:
case XK_KP_Delete:
chewing_handle_Del (g_pChewingCtx);
break;
case XK_BackSpace:
chewing_handle_Backspace (g_pChewingCtx);
break;
case XK_Up:
case XK_KP_Up:
chewing_handle_Up (g_pChewingCtx);
break;
case XK_Down:
case XK_KP_Down:
chewing_handle_Down (g_pChewingCtx);
break;
case XK_Left:
case XK_KP_Left:
chewing_handle_Left (g_pChewingCtx);
break;
case XK_Right:
case XK_KP_Right:
chewing_handle_Right (g_pChewingCtx);
break;
#if 0
case XK_Shift_L:
chewing_handle_ShiftLeft (g_pChewingCtx);
break;
case XK_Shift_R:
chewing_handle_ShiftRight (g_pChewingCtx);
break;
#endif
case XK_Tab:
chewing_handle_Tab (g_pChewingCtx);
break;
default:
if (nKeyVal > 32 && nKeyVal < 127)
chewing_handle_Default (g_pChewingCtx, nKeyVal);
break;
}
hime_label_clear (MAX_SEG_NUM);
g_nCurrentCursorPos = chewing_cursor_Current (g_pChewingCtx);
if (g_nCurrentCursorPos < 0 || g_nCurrentCursorPos > MAX_SEG_NUM)
return FALSE;
// zuin symbols
pszTmp = chewing_zuin_String (g_pChewingCtx, &nZuinLen);
if (pszTmp)
{
for (nBufIdx = 0; nBufIdx < nZuinLen; nBufIdx++)
{
memcpy (szWord, pszTmp + nBufIdx * 3, 3);
for (nPhoIdx = 0; nPhoIdx < 3; nPhoIdx++)
if (strstr (g_himeModMainFuncs.mf_pho_chars[nPhoIdx], szWord) != NULL)
hime_label_show (szWord, nPhoIdx + chewing_buffer_Len (g_pChewingCtx) + 1);
}
free (pszTmp);
}
// check if the composing is valid or not
if (chewing_buffer_Check (g_pChewingCtx))
{
g_himeModMainFuncs.mf_hide_selections_win ();
pszTmp = chewing_buffer_String (g_pChewingCtx);
// init cand_no
chewing_cand_Enumerate (g_pChewingCtx);
g_himeModMainFuncs.mf_clear_sele ();
if (chewing_cand_TotalChoice (g_pChewingCtx))
{
nIdx = 0;
while (chewing_cand_hasNext (g_pChewingCtx))
{
pszChewingCand = chewing_cand_String (g_pChewingCtx);
if (nIdx > chewing_get_candPerPage (g_pChewingCtx) - 1)
break;
hime_label_cand_show (pszChewingCand, nIdx++);
free (pszChewingCand);
}
}
for (nIdx = 0; nIdx < chewing_buffer_Len (g_pChewingCtx); nIdx++)
{
memcpy (szWord, pszTmp + (nIdx * 3), 3);
hime_label_show (szWord, nIdx);
}
free (pszTmp);
}
if (chewing_commit_Check (g_pChewingCtx))
{
pszTmp = chewing_commit_String (g_pChewingCtx);
g_himeModMainFuncs.mf_send_text (pszTmp);
// FIXME: workaround for repeated commit
// it impacts the bEscCleanAllBuf setting!
chewing_handle_Esc (g_pChewingCtx);
free (pszTmp);
}
module_show_win ();
return TRUE;
}
/*
Always returns a char pointer, caller must free it.
*/
char* Chewing::ZuinStr() {
return chewing_zuin_String(ctx, NULL);
}
/**
* @brief function DoInput has done everything for us.
*
* @param searchMode
* @return INPUT_RETURN_VALUE
**/
__EXPORT_API
INPUT_RETURN_VALUE FcitxChewingGetCandWords(void* arg)
{
FcitxChewing* chewing = (FcitxChewing*) arg;
FcitxInputState *input = FcitxInstanceGetInputState(chewing->owner);
FcitxMessages *msgPreedit = FcitxInputStateGetPreedit(input);
FcitxMessages *clientPreedit = FcitxInputStateGetClientPreedit(input);
ChewingContext * c = chewing->context;
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(chewing->owner);
chewing_set_candPerPage(c, config->iMaxCandWord);
FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), config->iMaxCandWord);
//clean up window asap
FcitxInstanceCleanInputWindow(chewing->owner);
char * buf_str = chewing_buffer_String(c);
char * zuin_str = chewing_zuin_String(c, NULL);
ConfigChewing(chewing);
FcitxLog(DEBUG, "%s %s", buf_str, zuin_str);
/* if not check done, so there is candidate word */
if (!chewing_cand_CheckDone(c)) {
//get candidate word
chewing_cand_Enumerate(c);
int index = 0;
while (chewing_cand_hasNext(c)) {
char* str = chewing_cand_String(c);
FcitxCandidateWord cw;
ChewingCandWord* w = (ChewingCandWord*) fcitx_utils_malloc0(sizeof(ChewingCandWord));
w->index = index;
cw.callback = FcitxChewingGetCandWord;
cw.owner = chewing;
cw.priv = w;
cw.strExtra = NULL;
cw.strWord = strdup(str);
cw.wordType = MSG_OTHER;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &cw);
chewing_free(str);
index ++;
}
}
// setup cursor
FcitxInputStateSetShowCursor(input, true);
int buf_len = chewing_buffer_Len(c);
int cur = chewing_cursor_Current(c);
FcitxLog(DEBUG, "buf len: %d, cur: %d", buf_len, cur);
int rcur = FcitxChewingGetRawCursorPos(buf_str, cur);
FcitxInputStateSetCursorPos(input, rcur);
FcitxInputStateSetClientCursorPos(input, rcur);
// insert zuin in the middle
char * half1 = strndup(buf_str, rcur);
char * half2 = strdup(buf_str + rcur);
FcitxMessagesAddMessageAtLast(msgPreedit, MSG_INPUT, "%s%s%s", half1, zuin_str, half2);
FcitxMessagesAddMessageAtLast(clientPreedit, MSG_INPUT, "%s%s%s", half1, zuin_str, half2);
chewing_free(buf_str); chewing_free(zuin_str); free(half1); free(half2);
return IRV_DISPLAY_CANDWORDS;
}
/**
* @brief Process Key Input and return the status
*
* @param keycode keycode from XKeyEvent
* @param state state from XKeyEvent
* @param count count from XKeyEvent
* @return INPUT_RETURN_VALUE
**/
__EXPORT_API
INPUT_RETURN_VALUE FcitxChewingDoInput(void* arg, FcitxKeySym sym, unsigned int state)
{
FcitxChewing* chewing = (FcitxChewing*) arg;
FcitxInputState *input = FcitxInstanceGetInputState(chewing->owner);
ChewingContext * ctx = chewing->context;
int zuin_len;
FcitxCandidateWordList* candList = FcitxInputStateGetCandidateList(input);
if (FcitxCandidateWordGetListSize(candList) > 0) {
if (FcitxHotkeyIsHotKeyDigit(sym, state) || FcitxHotkeyIsHotKey(sym, state, FCITX_RIGHT) || FcitxHotkeyIsHotKey(sym, state, FCITX_LEFT))
return IRV_TO_PROCESS;
if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {
if (FcitxCandidateWordGoNextPage(candList))
return IRV_DISPLAY_MESSAGE;
else
return IRV_DO_NOTHING;
}
}
if (FcitxHotkeyIsHotKeySimple(sym, state)) {
int scan_code = (int) sym & 0xff;
chewing_handle_Default(ctx, scan_code);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {
char * zuin_str = chewing_zuin_String(ctx, &zuin_len);
chewing_free(zuin_str);
if (chewing_buffer_Len(ctx) + zuin_len == 0)
return IRV_TO_PROCESS;
chewing_handle_Backspace(ctx);
if (chewing_buffer_Len(ctx) + zuin_len == 0)
return IRV_CLEAN;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {
chewing_handle_Esc(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_DELETE)) {
char * zuin_str = chewing_zuin_String(ctx, &zuin_len);
chewing_free(zuin_str);
if (chewing_buffer_Len(ctx) + zuin_len == 0)
return IRV_TO_PROCESS;
chewing_handle_Del(ctx);
if (chewing_buffer_Len(ctx) + zuin_len == 0)
return IRV_CLEAN;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)) {
chewing_handle_Space(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_UP)) {
chewing_handle_Up(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_DOWN)) {
chewing_handle_Down(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_PGUP)) {
chewing_handle_PageDown(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_CHEWING_PGDN)) {
chewing_handle_PageUp(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_RIGHT)) {
chewing_handle_Right(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_LEFT)) {
chewing_handle_Left(ctx);
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {
chewing_handle_Enter(ctx);
} else if (state == FcitxKeyState_Ctrl && FcitxHotkeyIsHotKeyDigit(sym, FcitxKeyState_None)) {
chewing_handle_CtrlNum(ctx, sym);
} else {
// to do: more chewing_handle
return IRV_TO_PROCESS;
}
if (chewing_keystroke_CheckAbsorb(ctx)) {
return IRV_DISPLAY_CANDWORDS;
} else if (chewing_keystroke_CheckIgnore(ctx)) {
return IRV_TO_PROCESS;
} else if (chewing_commit_Check(ctx)) {
char* str = chewing_commit_String(ctx);
FcitxInputContext* ic = FcitxInstanceGetCurrentIC(chewing->owner);
FcitxInstanceCommitString(chewing->owner, ic, str);
chewing_free(str);
return IRV_DISPLAY_CANDWORDS;
} else
return IRV_DISPLAY_CANDWORDS;
}
void test_null()
{
int ret;
char *buf;
const char *const_buf;
int *key;
unsigned short *phone;
start_testcase(NULL, fd);
chewing_Reset(NULL); // shall not crash
ret = chewing_set_KBType(NULL, 0);
ok(ret == -1, "chewing_set_KBType() returns `%d' shall be `%d'", ret, -1);
ret = chewing_get_KBType(NULL);
ok(ret == -1, "chewing_get_KBType() returns `%d' shall be `%d'", ret, -1);
buf = chewing_get_KBString(NULL);
ok(strcmp(buf, "") == 0, "chewing_get_KBString() returns `%s' shall be `%s'", buf, "");
chewing_free(buf);
chewing_delete(NULL); // shall not crash
chewing_free(NULL); // shall not crash
chewing_set_candPerPage(NULL, 0); // shall not crash
ret = chewing_get_candPerPage(NULL);
ok(ret == -1, "chewing_get_candPerPage() returns `%d' shall be `%d'", ret, -1);
chewing_set_maxChiSymbolLen(NULL, 0); // shall not crash
ret = chewing_get_maxChiSymbolLen(NULL);
ok(ret == -1, "chewing_get_maxChiSymbolLen() returns `%d' shall be `%d'", ret, -1);
chewing_set_selKey(NULL, NULL, 0); // shall not crash
key = chewing_get_selKey(NULL);
ok(key == NULL, "chewing_get_selKey() returns NULL");
chewing_free(key);
chewing_set_addPhraseDirection(NULL, 0); // shall not crash
ret = chewing_get_addPhraseDirection(NULL);
ok(ret == -1, "chewing_get_addPhraseDirection() returns `%d' shall be `%d'", ret, -1);
chewing_set_spaceAsSelection(NULL, 0); // shall not crash
ret = chewing_get_spaceAsSelection(NULL);
ok(ret == -1, "chewing_get_spaceAsSelection() returns `%d' shall be `%d'", ret, -1);
chewing_set_escCleanAllBuf(NULL, 0); // shall not crash
ret = chewing_get_escCleanAllBuf(NULL);
ok(ret == -1, "chewing_get_escCleanAllBuf() returns `%d' shall be `%d'", ret, -1);
chewing_set_autoShiftCur(NULL, 0); // shall not crash
ret = chewing_get_autoShiftCur(NULL);
ok(ret == -1, "chewing_get_autoShiftCur() returns `%d' shall be `%d'", ret, -1);
chewing_set_easySymbolInput(NULL, 0); // shall not crash
ret = chewing_get_easySymbolInput(NULL);
ok(ret == -1, "chewing_get_easySymbolInput() returns `%d' shall be `%d'", ret, -1);
chewing_set_phraseChoiceRearward(NULL, 0);
ret = chewing_get_phraseChoiceRearward(NULL);
ok(ret == -1, "chewing_get_phraseChoiceRearward() returns `%d' shall be `%d'", ret, -1);
chewing_set_ChiEngMode(NULL, 0); // shall not crash
ret = chewing_get_ChiEngMode(NULL);
ok(ret == -1, "chewing_get_ChiEngMode() returns `%d' shall be `%d'", ret, -1);
chewing_set_ShapeMode(NULL, 0); // shall not crash
ret = chewing_handle_Space(NULL);
ok(ret == -1, "chewing_handle_Space() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Esc(NULL);
ok(ret == -1, "chewing_handle_Esc() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Enter(NULL);
ok(ret == -1, "chewing_handle_Enter() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Del(NULL);
ok(ret == -1, "chewing_handle_Del() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Backspace(NULL);
ok(ret == -1, "chewing_handle_Backspace() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Up(NULL);
ok(ret == -1, "chewing_handle_Up() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Down(NULL);
ok(ret == -1, "chewing_handle_Down() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_ShiftLeft(NULL);
ok(ret == -1, "chewing_handle_ShiftLeft() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Left(NULL);
ok(ret == -1, "chewing_handle_Left() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_ShiftRight(NULL);
ok(ret == -1, "chewing_handle_ShiftRight() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Right(NULL);
ok(ret == -1, "chewing_handle_Right() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Tab(NULL);
ok(ret == -1, "chewing_handle_Tab() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_DblTab(NULL);
ok(ret == -1, "chewing_handle_DblTab() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Capslock(NULL);
ok(ret == -1, "chewing_handle_Capslock() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Home(NULL);
ok(ret == -1, "chewing_handle_Home() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_PageUp(NULL);
ok(ret == -1, "chewing_handle_PageUp() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_PageDown(NULL);
ok(ret == -1, "chewing_handle_PageDown() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Default(NULL, 0);
ok(ret == -1, "chewing_handle_Default() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_CtrlNum(NULL, 0);
ok(ret == -1, "chewing_handle_CtrlNum() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_ShiftSpace(NULL);
ok(ret == -1, "chewing_handle_ShiftSpace() returns `%d' shall be `%d'", ret, -1);
ret = chewing_handle_Numlock(NULL, 0);
ok(ret == -1, "chewing_handle_Numlock() returns `%d' shall be `%d'", ret, -1);
phone = chewing_get_phoneSeq(NULL);
ok(phone == NULL, "chewing_get_phoneSeq() returns NULL");
chewing_free(phone);
ret = chewing_get_phoneSeqLen(NULL);
ok(ret == -1, "chewing_get_phoneSeqLen() returns `%d' shall be `%d'", ret, -1);
chewing_set_logger(NULL, NULL, NULL);
ret = chewing_userphrase_enumerate(NULL);
ok(ret == -1, "chewing_userphrase_enumerate() returns `%d' shall be `%d'", ret, -1);
ret = chewing_userphrase_has_next(NULL, NULL, NULL);
ok(ret == 0, "chewing_userphrase_has_next() returns `%d' shall be `%d'", ret, 0);
ret = chewing_userphrase_get(NULL, NULL, 0, NULL, 0);
ok(ret == -1, "chewing_userphrase_get() returns `%d' shall be `%d'", ret, -1);
ret = chewing_userphrase_add(NULL, NULL, NULL);
ok(ret == -1, "chewing_userphrase_add() returns `%d' shall be `%d'", ret, -1);
ret = chewing_userphrase_remove(NULL, NULL, NULL);
ok(ret == -1, "chewing_userphrase_remove() returns `%d' shall be `%d'", ret, -1);
ret = chewing_userphrase_lookup(NULL, NULL, NULL);
ok(ret == 0, "chewing_userphrase_lookup() returns `%d' shall be `%d'", ret, 0);
ret = chewing_cand_open(NULL);
ok(ret == -1, "chewing_cand_open() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_close(NULL);
ok(ret == -1, "chewing_cand_open() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_choose_by_index(NULL, 0);
ok(ret == -1, "chewing_cand_choose_by_index() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_list_first(NULL);
ok(ret == -1, "chewing_cand_list_first() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_list_last(NULL);
ok(ret == -1, "chewing_cand_list_last() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_list_has_next(NULL);
ok(ret == 0, "chewing_cand_list_has_next() returns `%d' shall be `%d'", ret, 0);
ret = chewing_cand_list_has_prev(NULL);
ok(ret == 0, "chewing_cand_list_has_prev() returns `%d' shall be `%d'", ret, 0);
ret = chewing_cand_list_next(NULL);
ok(ret == -1, "chewing_cand_list_next() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_list_prev(NULL);
ok(ret == -1, "chewing_cand_list_prev() returns `%d' shall be `%d'", ret, -1);
ret = chewing_commit_preedit_buf(NULL);
ok(ret == -1, "chewing_commit_preedit_buf() returns `%d' shall be `%d'", ret, -1);
ret = chewing_clean_preedit_buf(NULL);
ok(ret == -1, "chewing_clean_preedit_buf() returns `%d' shall be `%d'", ret, -1);
ret = chewing_clean_bopomofo_buf(NULL);
ok(ret == -1, "chewing_clean_bopomofo_buf() returns `%d' shall be `%d'", ret, -1);
ret = chewing_commit_Check(NULL);
ok(ret == -1, "chewing_commit_Check() returns `%d' shall be `%d'", ret, -1);
buf = chewing_commit_String(NULL);
ok(strcmp(buf, "") == 0, "chewing_commit_String() returns `%s' shall be `%s'", buf, "");
chewing_free(buf);
const_buf = chewing_commit_String_static(NULL);
ok(strcmp(const_buf, "") == 0, "chewing_commit_String() returns `%s' shall be `%s'", const_buf, "");
ret = chewing_buffer_Check(NULL);
ok(ret == -1, "chewing_buffer_Check() returns `%d' shall be `%d'", ret, -1);
ret = chewing_buffer_Len(NULL);
ok(ret == -1, "chewing_buffer_Len() returns `%d' shall be `%d'", ret, -1);
buf = chewing_buffer_String(NULL);
ok(strcmp(buf, "") == 0, "chewing_buffer_String() returns `%s' shall be `%s'", buf, "");
chewing_free(buf);
const_buf = chewing_buffer_String_static(NULL);
ok(strcmp(const_buf, "") == 0, "chewing_buffer_String_static() returns `%s' shall be `%s'", const_buf, "");
const_buf = chewing_bopomofo_String_static(NULL);
ok(strcmp(const_buf, "") == 0, "chewing_bopomofo_String_static() returns `%s' shall be `%s'", const_buf, "");
BEGIN_IGNORE_DEPRECATIONS
buf = chewing_zuin_String(NULL, NULL);
END_IGNORE_DEPRECATIONS
ok(strcmp(buf, "") == 0, "chewing_zuin_String() returns `%s' shall be `%s'", buf, "");
chewing_free(buf);
ret = chewing_bopomofo_Check(NULL);
ok(ret == -1, "chewing_bopomofo_Check() returns `%d' shall be `%d'", ret, -1);
BEGIN_IGNORE_DEPRECATIONS
chewing_zuin_Check(NULL); // shall not crash
END_IGNORE_DEPRECATIONS
ret = chewing_cursor_Current(NULL);
ok(ret == -1, "chewing_cursor_Current() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_CheckDone(NULL);
ok(ret == -1, "chewing_cand_CheckDone() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_TotalPage(NULL);
ok(ret == -1, "chewing_cand_TotalPage() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_ChoicePerPage(NULL);
ok(ret == -1, "chewing_cand_ChoicePerPage() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_TotalChoice(NULL);
ok(ret == -1, "chewing_cand_TotalChoice() returns `%d' shall be `%d'", ret, -1);
ret = chewing_cand_CurrentPage(NULL);
ok(ret == -1, "chewing_cand_CurrentPage() returns `%d' shall be `%d'", ret, -1);
chewing_cand_Enumerate(NULL); // shall not crash
ret = chewing_cand_hasNext(NULL);
ok(ret == -1, "chewing_cand_hasNext() returns `%d' shall be `%d'", ret, -1);
const_buf = chewing_cand_String_static(NULL);
ok(strcmp(const_buf, "") == 0, "chewing_cand_String_static() returns `%s' shall be `%s'", const_buf, "");
buf = chewing_cand_String(NULL);
ok(strcmp(buf, "") == 0, "chewing_cand_String() returns `%s' shall be `%s'", buf, "");
chewing_free(buf);
chewing_interval_Enumerate(NULL); // shall not crash
ret = chewing_interval_hasNext(NULL);
ok(ret == -1, "chewing_interval_hasNext() returns `%d' shall be `%d'", ret, -1);
chewing_interval_Get(NULL, NULL); // shall not crash
ret = chewing_aux_Check(NULL);
ok(ret == -1, "chewing_aux_Check() returns `%d' shall be `%d'", ret, -1);
ret = chewing_aux_Length(NULL);
ok(ret == -1, "chewing_aux_Length() returns `%d' shall be `%d'", ret, -1);
const_buf = chewing_aux_String_static(NULL);
ok(strcmp(const_buf, "") == 0, "chewing_aux_String_static() returns `%s' shall be `%s'", const_buf, "");
buf = chewing_aux_String(NULL);
ok(strcmp(buf, "") == 0, "chewing_aux_String() returns `%s' shall be `%s'", buf, "");
chewing_free(buf);
ret = chewing_keystroke_CheckIgnore(NULL);
ok(ret == -1, "chewing_keystroke_CheckIgnore() returns `%d' shall be `%d'", ret, -1);
ret = chewing_keystroke_CheckAbsorb(NULL);
ok(ret == -1, "chewing_keystroke_CheckAbsorb() returns `%d' shall be `%d'", ret, -1);
chewing_kbtype_Enumerate(NULL); // shall not crash
ret = chewing_kbtype_hasNext(NULL);
ok(ret == -1, "chewing_kbtype_hasNext() returns `%d' shall be `%d'", ret, -1);
const_buf = chewing_kbtype_String_static(NULL);
ok(strcmp(const_buf, "") == 0, "chewing_kbtype_String_static() returns `%s' shall be `%s'", const_buf, "");
buf = chewing_kbtype_String(NULL);
ok(strcmp(buf, "") == 0, "chewing_kbtype_String() returns `%s' shall be `%s'", buf, "");
chewing_free(buf);
}