static void KBType_set_callback(PropertyContext *ctx, GValue *value){
#ifdef IBUS_CHEWING_MAIN
ChewingKbType kbType=kbType_id_get_index(g_value_get_string(value));
IBusChewingEngine *engine=(IBusChewingEngine *) ctx->userData;
chewing_set_KBType(engine->context,kbType);
#endif
}
void test_set_keyboard_type()
{
ChewingContext *ctx;
size_t i;
char *keyboard_string;
int keyboard_type;
ctx = chewing_new();
keyboard_string = chewing_get_KBString( ctx );
ok( strcmp( keyboard_string, KEYBOARD_STRING[KEYBOARD_DEFAULT_TYPE] ) == 0,
"`%s' shall be `%s'", keyboard_string, KEYBOARD_STRING[KEYBOARD_DEFAULT_TYPE] );
chewing_free( keyboard_string );
keyboard_type = chewing_get_KBType( ctx );
ok( keyboard_type == KEYBOARD_DEFAULT_TYPE ,
"`%d' shall be `%d'", keyboard_type, KEYBOARD_DEFAULT_TYPE );
for ( i = 0; i < ARRAY_SIZE( KEYBOARD_STRING ); ++i ) {
ok ( chewing_set_KBType( ctx, i ) == 0, "return shall be 0" );
keyboard_string = chewing_get_KBString( ctx );
ok( strcmp( keyboard_string, KEYBOARD_STRING[i] ) == 0,
"`%s' shall be `%s'", keyboard_string, KEYBOARD_STRING[i] );
chewing_free( keyboard_string );
keyboard_type = chewing_get_KBType( ctx );
ok( keyboard_type == (int)i ,
"`%d' shall be `%d'", keyboard_type, (int)i );
}
// The invalid KBType will reset KBType to default value.
ok( chewing_set_KBType( ctx, -1 ) == -1, "return shall be -1" );
keyboard_type = chewing_get_KBType( ctx );
ok( keyboard_type == KEYBOARD_DEFAULT_TYPE ,
"`%d' shall be `%d'", keyboard_type, KEYBOARD_DEFAULT_TYPE );
ok( chewing_set_KBType( ctx, ARRAY_SIZE( KEYBOARD_STRING ) + 1 ),
"return shall be -1" );
keyboard_type = chewing_get_KBType( ctx );
ok( keyboard_type == KEYBOARD_DEFAULT_TYPE ,
"`%d' shall be `%d'", keyboard_type, KEYBOARD_DEFAULT_TYPE );
chewing_delete( ctx );
}
Chewing::Chewing( bool spaceAsSelection, int keyLayout ) {
ctx = chewing_new();
chewing_set_KBType( ctx, keyLayout );
chewing_set_candPerPage( ctx, 9 );
chewing_set_maxChiSymbolLen( ctx, 20 );
//chewing_set_addPhraseDirection( ctx, 1 );
//chewing_set_selKey( ctx, selKey_define, 10 );
chewing_set_spaceAsSelection( ctx, spaceAsSelection );
}
/*============================================
* Callback routines
*/
gboolean KBType_apply_callback(PropertyContext * ctx, gpointer userData)
{
GValue *value = &(ctx->value);
IBUS_CHEWING_LOG(DEBUG, "KBType_apply_callback(%s,%s)", ctx->spec->key,
mkdg_g_value_to_string(value));
ChewingKbType kbType = kbType_id_get_index(g_value_get_string(value));
IBusChewingPreEdit *icPreEdit = (IBusChewingPreEdit *) ctx->parent;
chewing_set_KBType(icPreEdit->context, kbType);
return TRUE;
}
void ConfigChewing(FcitxChewing* chewing)
{
ChewingContext* ctx = chewing->context;
chewing_set_KBType( ctx, chewing_KBStr2Num(
(char *) builtin_keymaps[chewing->config.layout]));
chewing_set_addPhraseDirection( ctx, chewing->config.bAddPhraseForward ? 0 : 1 );
chewing_set_phraseChoiceRearward( ctx, chewing->config.bChoiceBackward ? 1 : 0 );
chewing_set_autoShiftCur( ctx, chewing->config.bAutoShiftCursor ? 1 : 0 );
chewing_set_spaceAsSelection( ctx, chewing->config.bSpaceAsSelection ? 1 : 0 );
}
void Chewing::SetKeyboardLayout(int kb)
{
/* if (kb==KB_HSU) {
if(cd->config.hsuSelKeyType == HSU_SELKEY_TYPE2) {
SelKey("asdfzxcv89");
} else {
SelKey("asdfjkl789");
}
} else if (kb==KB_DVORAK_HSU) SelKey("aoeuhtn789");
else SelKey("1234567890");
*/
chewing_set_KBType(ctx, kb);
}
int main(int argc, char *argv[])
{
ChewingContext *ctx;
int i;
FILE *fp = stdin;
/* Initialize libchewing */
putenv("CHEWING_PATH=" CHEWING_DATA_PREFIX);
/* for the sake of testing, we should not change existing hash data */
putenv("CHEWING_USER_PATH=" TEST_HASH_DIR);
if (argc == 2) {
fp = fopen(argv[1], "r");
if (!fp) {
fprintf(stderr, "failed to open '%s'\n", argv[1]);
return 1;
}
}
/* Request handle to ChewingContext */
ctx = chewing_new();
/* Set keyboard type */
chewing_set_KBType(ctx, chewing_KBStr2Num("KB_DEFAULT"));
chewing_set_candPerPage(ctx, 9);
chewing_set_maxChiSymbolLen(ctx, 16);
chewing_set_addPhraseDirection(ctx, 1);
chewing_set_selKey(ctx, selKey_define, 10);
chewing_set_spaceAsSelection(ctx, 1);
while (1) {
i = get_keystroke(get_char_from_fp, fp);
if (i == END)
goto end;
type_single_keystroke(ctx, i);
commit_string(ctx);
}
end:
/* Free Chewing IM handle */
chewing_delete(ctx);
if (fp)
fclose(fp);
return 0;
}
void test_KB_MPS2()
{
ChewingContext *ctx;
ctx = chewing_new();
start_testcase(ctx, fd);
chewing_set_KBType(ctx, KB_MPS2_PINYIN);
type_keystroke_by_string(ctx, "shin ku4in jen de5hen3bang4");
ok_preedit_buffer(ctx, "\xE6\x96\xB0\xE9\x85\xB7\xE9\x9F\xB3\xE7\x9C\x9F\xE7\x9A\x84\xE5\xBE\x88\xE6\xA3\x92"
/* 新酷音真的很棒 */ );
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "huan ing2shr3iung4pin in muo2shz4");
ok_preedit_buffer(ctx, "\xE6\xAD\xA1\xE8\xBF\x8E\xE4\xBD\xBF\xE7\x94\xA8\xE6\x8B\xBC\xE9\x9F\xB3\xE6\xA8\xA1\xE5\xBC\x8F"
/* 歡迎使用拼音模式 */ );
chewing_clean_preedit_buf(ctx);
chewing_delete(ctx);
}
int main( int argc, char *argv[] )
#endif
{
ChewingContext *ctx;
char *prefix = CHEWING_DATA_PREFIX;
int i;
int ctrl_shifted;
/* Initialize libchewing */
/* for the sake of testing, we should not change existing hash data */
chewing_Init( prefix, TEST_HASH_DIR );
/* Request handle to ChewingContext */
ctx = chewing_new();
/* Set keyboard type */
chewing_set_KBType( ctx, chewing_KBStr2Num( "KB_DEFAULT" ) );
chewing_set_candPerPage( ctx, 9 );
chewing_set_maxChiSymbolLen( ctx, 16 );
chewing_set_addPhraseDirection( ctx, 1 );
chewing_set_selKey( ctx, selKey_define, 10 );
chewing_set_spaceAsSelection( ctx, 1 );
while ( 1 ) {
i = get_keystroke();
switch ( i ) {
case KEY_LEFT:
chewing_handle_Left( ctx );
break;
case KEY_SLEFT:
chewing_handle_ShiftLeft( ctx );
break;
case KEY_RIGHT:
chewing_handle_Right( ctx );
break;
case KEY_SRIGHT:
chewing_handle_ShiftRight( ctx );
break;
case KEY_UP:
chewing_handle_Up( ctx );
break;
case KEY_DOWN:
chewing_handle_Down( ctx );
break;
case KEY_SPACE:
chewing_handle_Space( ctx );
break;
case KEY_ENTER:
chewing_handle_Enter( ctx );
break;
case KEY_BACKSPACE:
chewing_handle_Backspace( ctx );
break;
case KEY_ESC:
chewing_handle_Esc( ctx );
break;
case KEY_DELETE:
chewing_handle_Del( ctx );
break;
case KEY_HOME:
chewing_handle_Home( ctx );
break;
case KEY_END:
chewing_handle_End( ctx );
break;
case KEY_TAB:
chewing_handle_Tab( ctx );
break;
case KEY_CAPSLOCK:
chewing_handle_Capslock( ctx );
break;
case END:
goto end;
default:
ctrl_shifted = ( i - KEY_CTRL_BASE );
if ( ( ctrl_shifted >= '0' ) && ( ctrl_shifted <= '9' ) ) {
chewing_handle_CtrlNum( ctx, ctrl_shifted );
} else {
chewing_handle_Default( ctx, (char) i );
}
break;
}
commit_string( ctx );
#ifdef USED_IN_SIMULATION
if ( i == KEY_ENTER )
compare_per_run();
#endif
}
end:
/* Free Chewing IM handle */
chewing_delete( ctx );
/* Termate Chewing services */
chewing_Terminate();
#ifndef USED_IN_SIMULATION
printf( "\n" );
#endif
return 0;
}
void test_KB_DACHEN_CP26()
{
ChewingContext *ctx;
ctx = chewing_new();
start_testcase(ctx, fd);
chewing_set_KBType(ctx, KB_DACHEN_CP26);
type_keystroke_by_string(ctx, "vup djdup tp wkycprqlld");
ok_preedit_buffer(ctx, "\xE6\x96\xB0\xE9\x85\xB7\xE9\x9F\xB3\xE7\x9C\x9F\xE7\x9A\x84\xE5\xBE\x88\xE6\xA3\x92"
/* 新酷音真的很棒 */ );
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "qq"); /* switch between "ㄅ" and "ㄆ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x86" /* ㄆ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "ww"); /* switch between "ㄉ" and "ㄊ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x8A" /* ㄊ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "tt"); /* switch between "ㄓ" and "ㄔ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x94" /* ㄔ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "xmm"); /* switch between "ㄩ" and "ㄡ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x8C\xE3\x84\xA1" /* ㄌㄡ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "xum"); /* convert "ㄧㄩ" to "ㄧㄡ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x8C\xE3\x84\xA7\xE3\x84\xA1" /* ㄌㄧㄡ */);
type_keystroke_by_string(ctx, "m"); /* convert "ㄧㄡ" to "ㄩ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x8C\xE3\x84\xA9" /* ㄌㄩ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "ii"); /* switch between "ㄛ" and "ㄞ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x9E" /* ㄞ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "oo"); /* switch between "ㄟ" and "ㄢ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\xA2" /* ㄢ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "ll"); /* switch between "ㄠ" and "ㄤ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\xA4" /* ㄤ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "pp"); /* switch between "ㄣ" and "ㄦ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\xA6" /* ㄦ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "wu"); /* switch among "ㄧ", "ㄚ" and "ㄧㄚ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x89\xE3\x84\xA7" /* ㄉㄧ */);
type_keystroke_by_string(ctx, "u");
ok_bopomofo_buffer(ctx, "\xE3\x84\x89\xE3\x84\x9A" /* ㄉㄚ */);
type_keystroke_by_string(ctx, "u");
ok_bopomofo_buffer(ctx, "\xE3\x84\x89\xE3\x84\xA7\xE3\x84\x9A" /* ㄉㄧㄚ */);
type_keystroke_by_string(ctx, "u");
ok_bopomofo_buffer(ctx, "\xE3\x84\x89" /* ㄉ */);
type_keystroke_by_string(ctx, "ju");
ok_bopomofo_buffer(ctx, "\xE3\x84\x89\xE3\x84\xA8\xE3\x84\x9A" /* ㄉㄨㄚ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "bb"); /* convert "ㄖ" to "ㄝ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x96\xE3\x84\x9D" /* ㄖㄝ */);
chewing_clean_bopomofo_buf(ctx);
type_keystroke_by_string(ctx, "njn"); /* convert "ㄙ" to "ㄥ" */
ok_bopomofo_buffer(ctx, "\xE3\x84\x99\xE3\x84\xA8\xE3\x84\xA5" /* ㄙㄨㄥ */);
chewing_clean_bopomofo_buf(ctx);
chewing_delete(ctx);
}
void test_KB_ET26()
{
ChewingContext *ctx;
ctx = chewing_new();
start_testcase(ctx, fd);
chewing_set_KBType(ctx, KB_ET26);
type_keystroke_by_string(ctx, "cen kxken gn drdhnjbtk");
ok_preedit_buffer(ctx, "\xE6\x96\xB0\xE9\x85\xB7\xE9\x9F\xB3\xE7\x9C\x9F\xE7\x9A\x84\xE5\xBE\x88\xE6\xA3\x92"
/* 新酷音真的很棒 */ );
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "p");
ok_bopomofo_buffer(ctx, "\xE3\x84\x86" /* ㄆ */ );
type_keystroke_by_string(ctx, "f"); /* convert "ㄆ" to "ㄡ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE5\x90\xBD" /* 吽 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "m");
ok_bopomofo_buffer(ctx, "\xE3\x84\x87" /* ㄇ */ );
type_keystroke_by_string(ctx, " "); /* convert "ㄇ" to "ㄢ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE5\xAE\x89" /* 安 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "n");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8B" /* ㄋ */ );
type_keystroke_by_string(ctx, "j"); /* convert "ㄋ" to "ㄣ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE5\xB3\x8E" /* 峎 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "t");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8A" /* ㄊ */ );
type_keystroke_by_string(ctx, " "); /* convert "ㄊ" to "ㄤ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE9\xAA\xAF" /* 骯 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "l");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8C" /* ㄌ */ );
type_keystroke_by_string(ctx, " "); /* convert "ㄌ" to "ㄥ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE9\x9E\xA5" /* 鞥 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "h");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8F" /* ㄏ */);
type_keystroke_by_string(ctx, "j"); /* convert "ㄏ" to "ㄦ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE7\x88\xBE" /* 爾 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "g");
ok_bopomofo_buffer(ctx, "\xE3\x84\x90" /* ㄐ */);
type_keystroke_by_string(ctx, " "); /* convert "ㄐ,ㄒ" to "ㄓ,ㄕ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE4\xB9\x8B" /* 之 */);
chewing_clean_preedit_buf(ctx);
chewing_delete(ctx);
}
void test_KB_HSU()
{
ChewingContext *ctx;
ctx = chewing_new();
start_testcase(ctx, fd);
chewing_set_KBType(ctx, KB_HSU);
type_keystroke_by_string(ctx, "cen kxjen jn dgshnfbkj");
ok_preedit_buffer(ctx, "\xE6\x96\xB0\xE9\x85\xB7\xE9\x9F\xB3\xE7\x9C\x9F\xE7\x9A\x84\xE5\xBE\x88\xE6\xA3\x92"
/* 新酷音真的很棒 */ );
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "m");
ok_bopomofo_buffer(ctx, "\xE3\x84\x87" /* ㄇ */ );
type_keystroke_by_string(ctx, " "); /* convert "ㄇ" to "ㄢ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE5\xAE\x89" /* 安 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "h");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8F" /* ㄏ */ );
type_keystroke_by_string(ctx, "d"); /* convert "ㄏ" to "ㄛ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE5\x93\xA6" /* 哦 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "g");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8D" /* ㄍ */ );
type_keystroke_by_string(ctx, " "); /* convert "ㄍ" to "ㄜ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE9\x98\xBF" /* 阿 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "n");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8B" /* ㄋ */ );
type_keystroke_by_string(ctx, "f"); /* convert "ㄋ" to "ㄣ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE5\xB3\x8E" /* 峎 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "k");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8E" /* ㄎ */ );
type_keystroke_by_string(ctx, " "); /* convert "ㄎ" to "ㄤ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE9\xAA\xAF" /* 骯 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "j");
ok_bopomofo_buffer(ctx, "\xE3\x84\x90" /* ㄐ */);
type_keystroke_by_string(ctx, " "); /* convert "ㄐ,ㄑ,ㄒ" to "ㄓ,ㄔ,ㄕ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE4\xB9\x8B" /* 之 */);
chewing_clean_preedit_buf(ctx);
type_keystroke_by_string(ctx, "l");
ok_bopomofo_buffer(ctx, "\xE3\x84\x8C" /* ㄌ */);
type_keystroke_by_string(ctx, "f"); /* convert "ㄌ" to "ㄦ" */
ok_bopomofo_buffer(ctx, "");
ok_preedit_buffer(ctx, "\xE7\x88\xBE" /* 爾 */);
chewing_clean_preedit_buf(ctx);
chewing_delete(ctx);
}
int main( int argc, char *argv[] )
{
ChewingContext *ctx;
FILE *fout;
FILE *fout2;
char *prefix = CHEWING_DATA_PREFIX;
char *out_file = "tmp.txt";
char *out_file2 = "tmp_out.txt";
int ch;
int width, height;
int add_phrase_length;
/*if ( argc < 2 ) {
fprintf( stderr, "usage: genkeystroke filename\n" );
exit( 1 );
}
else {
fout = fopen( argv[ 1 ], "w" );*/
fout = fopen( out_file, "w" );
if ( ! fout ) {
fprintf( stderr, "Error: failed to open %s\n", out_file );
exit( 1 );
}
fout2 = fopen( out_file2, "w" );
if ( ! fout2 ) {
fprintf( stderr, "Error: failed to open %s\n", out_file2 );
exit( 1 );
}
/*}*/
/* Initialize curses library */
setlocale(LC_CTYPE, "");
initscr();
if ( has_colors() == TRUE ) {
start_color();
init_pair( 1, COLOR_WHITE, COLOR_BLUE );
init_pair( 2, COLOR_RED, COLOR_YELLOW );
init_pair( 3, COLOR_WHITE, COLOR_RED );
hasColor = 1;
}
cbreak();
noecho();
keypad( stdscr, 1 );
getmaxyx( stdscr, height, width );
start_color();
clear();
refresh();
/* Initialize libchewing */
/* for the sake of testing, we should not change existing hash data */
chewing_Init( prefix, TEST_HASH_DIR );
/* Request handle to ChewingContext */
ctx = chewing_new();
/* Set keyboard type */
chewing_set_KBType( ctx, chewing_KBStr2Num( "KB_DEFAULT" ) );
/* Fill configuration values */
chewing_set_candPerPage( ctx, 9 );
chewing_set_maxChiSymbolLen( ctx, 16 );
chewing_set_addPhraseDirection( ctx, 1 );
chewing_set_selKey( ctx, selKey_define, 10 );
chewing_set_spaceAsSelection( ctx, 1 );
chewing_set_autoShiftCur( ctx, 1 );
chewing_set_phraseChoiceRearward( ctx, 1 );
clear();
mvaddstr( 0, 0, "Any key to start testing..." );
while ( TRUE ) {
ch = getch();
switch ( ch ) {
case KEY_LEFT:
chewing_handle_Left( ctx );
fprintf( fout, "<L>" );
break;
case KEY_SLEFT:
chewing_handle_ShiftLeft( ctx );
fprintf( fout, "<SL>" );
break;
case KEY_RIGHT:
chewing_handle_Right( ctx );
fprintf( fout, "<R>" );
break;
case KEY_SRIGHT:
chewing_handle_ShiftRight( ctx );
fprintf( fout, "<SR>" );
break;
case KEY_UP:
chewing_handle_Up( ctx );
fprintf( fout, "<U>" );
break;
case KEY_DOWN:
chewing_handle_Down( ctx );
fprintf( fout, "<D>" );
break;
case KEY_SPACE:
chewing_handle_Space( ctx );
fprintf( fout, " " );
break;
case KEY_ENTER:
chewing_handle_Enter( ctx );
fprintf( fout, "<E>" );
break;
case KEY_BACKSPACE:
chewing_handle_Backspace( ctx );
fprintf( fout, "<B>" );
break;
case KEY_ESC:
chewing_handle_Esc( ctx );
fprintf( fout, "<EE>" );
break;
case KEY_DC:
chewing_handle_Del( ctx );
fprintf( fout, "<DC>" );
break;
case KEY_HOME:
chewing_handle_Home( ctx );
fprintf( fout, "<H>" );
break;
case KEY_END:
chewing_handle_End( ctx );
fprintf( fout, "<EN>" );
break;
case KEY_TAB:
chewing_handle_Tab( ctx );
fprintf( fout, "<T>" );
break;
case CTRL_0:
case CTRL_1:
case CTRL_2:
case CTRL_3:
case CTRL_4:
case CTRL_5:
case CTRL_6:
case CTRL_7:
case CTRL_8:
case CTRL_9:
add_phrase_length = ( ch - CTRL_0 + '0' );
chewing_handle_CtrlNum( ctx, add_phrase_length );
fprintf( fout, "<C%c>", add_phrase_length );
break;
case KEY_CTRL_('B'): /* emulate CapsLock */
chewing_handle_Capslock( ctx );
fprintf( fout, "<CB>");
break;
case KEY_CTRL_('D'):
case EOF:
goto end;
case KEY_CTRL_('H'): /* emulate Shift */
if ( chewing_get_ShapeMode( ctx ) == FULLSHAPE_MODE )
chewing_set_ShapeMode( ctx, HALFSHAPE_MODE );
else
chewing_set_ShapeMode( ctx, FULLSHAPE_MODE );
break;
default:
chewing_handle_Default( ctx, (char) ch );
fprintf( fout, "%c", (char) ch );
break;
}
drawline( 0, 0 );
drawline( 2, 0 );
show_interval_buffer( 3, 0, ctx );
drawline( 4, 0 );
show_choose_buffer( 5, 0, ctx );
drawline( 6, 0 );
show_zuin_buffer( 7, 0, ctx );
show_full_shape( 7, 5, ctx );
drawline( 8, 0 );
mvaddstr( 9, 0, "Ctrl + d : leave" );
mvaddstr( 9, 20, "Ctrl + b : toggle Eng/Chi mode" );
mvaddstr( 10, 0, "F1, F2, F3, ..., F9 : Add user defined phrase");
mvaddstr( 11, 0, "Crtl + h : toggle Full/Half shape mode" );
show_commit_string( ctx );
store_commit_string( ctx, fout2 );
show_userphrase( 7, 12, ctx );
show_edit_buffer( 1, 0, ctx );
}
end:
endwin();
/* Release Chewing context */
chewing_delete( ctx );
/* Termate Chewing services */
chewing_Terminate();
fprintf( fout, "\n" );
fprintf( fout2, "\n" );
fclose( fout );
fclose( fout2 );
return 0;
}
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);
}
int main(int argc, char *argv[])
{
size_t i;
int flag_random_init = 0;
int flag_random_extra = 0;
int flag_loop = -1;
int (*get_input)() = &random256;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-init") == 0)
flag_random_init = 1;
else if (strcmp(argv[i], "-extra") == 0 && argv[i + 1])
flag_random_extra = 1;
else if (strcmp(argv[i], "-loop") == 0 && argv[i + 1])
flag_loop = atoi(argv[++i]);
else if (strcmp(argv[i], "-stdin") == 0)
get_input = &get_stdin;
else {
printf("Usage: %s [-init] [-extra] [-loop N] [-stdin]\n", argv[0]);
printf("\t-init Random initial configuration\n");
printf("\t-extra Random change all configurations during input.\n");
printf("\t This is usually unexpected.\n");
printf("\t-stdin Get random input from stdin\n");
printf("\t-loop N How many iterations to test (default infinite=-1)\n");
exit(1);
}
}
/* Initialize libchewing */
putenv("CHEWING_PATH=" CHEWING_DATA_PREFIX);
/* for the sake of testing, we should not change existing hash data */
putenv("CHEWING_USER_PATH=" TEST_HASH_DIR);
for (i = 0; i != flag_loop; i++) {
ChewingContext *ctx = chewing_new();
/* typical configuration */
chewing_set_KBType(ctx, chewing_KBStr2Num("KB_DEFAULT"));
chewing_set_candPerPage(ctx, 9);
chewing_set_maxChiSymbolLen(ctx, 16);
chewing_set_addPhraseDirection(ctx, 1);
chewing_set_selKey(ctx, selKey_define, 10);
chewing_set_spaceAsSelection(ctx, 1);
if (flag_random_init) {
chewing_set_KBType(ctx, get_input());
chewing_set_candPerPage(ctx, get_input());
chewing_set_maxChiSymbolLen(ctx, get_input());
chewing_set_addPhraseDirection(ctx, get_input());
chewing_set_selKey(ctx, selKey_define, get_input() % 11);
chewing_set_spaceAsSelection(ctx, get_input());
chewing_set_escCleanAllBuf(ctx, get_input());
chewing_set_autoShiftCur(ctx, get_input());
chewing_set_easySymbolInput(ctx, get_input());
chewing_set_phraseChoiceRearward(ctx, get_input());
}
while (1) {
/* Random value: [0, max_key) for keys, [max_key, 0xff] for
* configurations. Use a fixed range here because I don't want the
* meaning of input changed a lot frequently if we add more keys in
* the future. */
const int max_key = 192; /* arbitrary number */
int v = get_input();
if (v == EOF)
break;
assert(max_key * sizeof(all_key[0]) >= sizeof(all_key));
if (v >= max_key) {
const int typical = 2;
int handled = 1;
v = v - max_key;
if (flag_random_extra || v < typical) {
switch (v) {
/* typical configurations may be changed during input */
case 0:
chewing_set_ChiEngMode(ctx, get_input());
break;
case 1:
chewing_set_ShapeMode(ctx, get_input());
break;
/* usually not changed during input */
case 2:
chewing_set_KBType(ctx, get_input());
break;
case 3:
chewing_set_candPerPage(ctx, get_input());
break;
case 4:
chewing_set_maxChiSymbolLen(ctx, get_input());
break;
case 5:
chewing_set_addPhraseDirection(ctx, get_input());
break;
case 6:
chewing_set_selKey(ctx, selKey_define, get_input() % 11);
break;
case 7:
chewing_set_spaceAsSelection(ctx, get_input());
break;
case 8:
chewing_set_escCleanAllBuf(ctx, get_input());
break;
case 9:
chewing_set_autoShiftCur(ctx, get_input());
break;
case 10:
chewing_set_easySymbolInput(ctx, get_input());
break;
case 11:
chewing_set_phraseChoiceRearward(ctx, get_input());
break;
default:
handled = 0;
break;
}
} else {
handled = 0;
}
if (!handled)
break;
} else {
if (0 <= v && v < max_key) {
int key = all_key[v];
type_single_keystroke(ctx, key);
} else {
break;
}
}
commit_string(ctx);
}
chewing_delete(ctx);
if (i % 10000 == 0)
printf("%zu\n", i);
if (getenv("AFL_PERSISTENT"))
raise(SIGSTOP);
}
return 0;
}
