W+

Project neovim เป็น project ที่ fork vim ออกมาเพื่อปรับปรุง source code, quality, improve plugin system และ developer friendly มากขึ้น ซึ่งในตัว project เองได้มีการเขียนเรื่องของเทคนิคการ refactor source code เอาไว้โดยหนึ่งในตัวอย่างของวันนี้เป็นเรื่องของเทคนิคการ refactor loop ซึ่งสามารถนำเอาไป apply กับภาษาอะไรก็ได้ที่มีปัญหาคล้ายกัน

Code ที่เราจะมาดูกันเป็น code ที่ส่วนของการเปลี่ยน mode (เช่น เปลี่ยนเป็น insert mode จาก normal mode) ในตัว vim 

while (1) { normal_mode_process_byte(getc()); } void normal_mode_process_byte(char c) { if (c == 'i') // enter insert mode while (1) { insert_mode_process_byte(getc()); } }

จากโค้ดตัวอย่างเราจะสังเกตเห็นว่า

normal_mode_process_byte, insert_mode_process_byte มีการติดต่อกับ IO (ในที่นี้คือ getc)

ใน insert_mode_process_byte จะเกิด infinite loop หากมีการกด ‘i’

ซึ่งการติดต่อพวกนี้มีผลทำให้ทดสอบและ debug ได้ยาก ดังนั้นควรเปลี่ยนมุมมองใหม่โดยนำ state machine มาใช้โดย extract function ที่จัดการเรื่องของการรับ input จาก IO ออกมาก่อนและเปลี่ยนตัวจัดการ state ไปเป็น global variable​ ซะ

while(1) { process_byte(getc()); } void process_byte(char ch) { if (mode == NORMAL) { normal_mode_process_byte(ch); } else if (mode == INSERT) { insert_mode_process_byte(ch); } }

พอเราเปลี่ยนการจัดการ state มาใช้ global variable ตัว function insert_mode_process_byte และ normal_mode_process_byte ก็สามารถเปลี่ยน state ได้ด้วยการเปลี่ยน global variable นั้นเอง เช่น

void normal_mode_process_byte(char ch) { if (ch == 'i') { mode = INSERT; return; } // do something ... }

เมื่อเราแยกส่วนของ state ออกจาก IO จะสามารถทำการทดสอบได้ง่ายขึ้นของแต่ล่ะ และไม่ต้องพึ่ง IO เลย

อันเนื่องมาจากงานที่ทำต้อง compile ออกมาเป็น shared library เพื่อนำไปใช้ต่อ เวลา compile ก็ใช้ -l และ -L เพื่อเรียกใช้และหา shared library ปกติ

gcc -lcmocka -leqxtest -L ../build/lib/ -I ../build/include/ -I ../libs/ext/include/ sample_test.c

จากนั้นมันก็จะได้ไฟล์ a.out ออกเพื่อนำไป execute ต่อ

./a.out dyld: Library not loaded: build/lib/libeqxtest.dylib Referenced from: /Users/wingyplus/project/ais/c/eqxtest/sample/./a.out Reason: image not found Trace/BPT trap: 5

มันคืออะไรฟระ ก็เลยใช้วิชา SDD (StackOverflow Driven Development) หาไปเจอ link http://stackoverflow.com/questions/12808225/dyld-library-not-loaded-libmysql-16-dylib-mac อ่าา อ่านคร่าวแก้ได้ด้วยการเอา lib search path ใส่เข้าไปใน DYLD_LIBRARY_PATH ค่อย execute

export DYLD_LIBRARY_PATH=$HOME/project/ais/c/eqxtest/build/lib:$DYLD_LIBRARY_PATH ./a.out [==========] Running 1 test(s). [ RUN ] test_sample [ OK ] test_sample [==========] 1 test(s) run. [ PASSED ] 1 test(s).

จากที่ได้หาข้อมูลมาซักพักว่าจะเขียน C ได้อย่างไรกับคนเริ่มต้นที่ไม่ยากมากจนเกินไป ก็ได้เจอกับ library ตัวหนึ่งที่ชื่อว่า cmocka​​ (https://cmocka.org/) โอ้วว มาลองเขียนกัน ซึ่งสิ่งที่ต้องเริ่มมี 

gcc 

make 

cmake 

git 

 ซึ่งเครื่องมือทั้ง 4 นี้หากเราเป็น linux ส่วนใหญ่จะมีให้ติดตั้งผ่าน package manager ซึ่งขึ้นกับ distro เอง หรือ OS X ก็จะมีให้ลงผ่าน brew หรือ macport ส่วน windows นั้นต้อง MinGW และลง cmake อีกต่างหากซึ่งดูเอกสารการติดตั้งได้ที่ https://cmake.org/install/ และ git จาก https://git-scm.com/downloads เริ่มจาก clone source ของ cmocka มา compile

$ git clone git://git.cryptomilk.org/projects/cmocka.git $ cd cmocka $ mkdir build $ cmake .. && make && make install

จากนั้นมาทดลองเขียนเทสกันโดยหัดจากโจทย์ fizzbuzz นี่แหละ โดยสร้างไฟล์ชื่อ fizzbuzz_test.c ขึ้นมาและเขียนเริ่มเขียนเทสกันเลย

#include <stdarg.h> #include <stddef.h> #include <setjmp.h> #include <cmocka.h> char *fizzbuzz_say(int n) { return ""; } static void test_fizzbuzz_return_Fizz_when_it_can_modulo_with3(void **state) { assert_string_equal(fizzbuzz_say(3), "Fizz"); } int main(void) { const struct CMUnitTest tests[] = { cmocka_unit_test(test_fizzbuzz_return_Fizz_when_it_can_modulo_with3), }; return cmocka_run_group_tests(tests, NULL, NULL); }

หัวใจหลักของมันมีอยู่สามส่วนคือ ส่วนแรก register test function ของเราโดยการสร้าง struct CMUnitTest ขึ้นมา

const struct CMUnitTest tests[] = { cmocka_unit_test(test_fizzbuzz_return_Fizz_when_it_can_modulo_with3), };

ส่วนที่สอง function test_fizzbuzz_return_Fizz_when_it_can_modulo_with3 ของเราจะต้องรับ void **state และ return void เสมอนะ

static void test_fizzbuzz_return_Fizz_when_it_can_modulo_with3(void **state) { assert_string_equal(fizzbuzz_say(3), "Fizz"); }

assert_string_equal เป็น function ที่เอาไว้เพื่อเปรียบเทียบผลลัพธ์การทดสอบ โดย argument ตัวแรกเป็นสิ่งที่เราจะใช้ในการทดสอบ และตัวที่สองเป็นค่าที่เราคาดหวังจาก argument ตัวแรก ส่วนที่สามเป็นการสั่งให้รันการทดสอบโดยใช้ cmocka_run_group_tests​ ซึ่งส่ง CMUnitTest ที่ใช้ในการ register test เข้าไป ต่อมาทำการ compile fizzbuzz_test.c ของเราด้วย gcc

$ gcc -I/usr/local/include -L/usr/local/lib -lcmocka -o fizzbuzz_test fizzbuzz_test.c

ทำการรัน fizzbuzz_test ของเรา

$ ./fizzbuzz_test [==========] Running 1 test(s). [ RUN ] test_fizzbuzz_return_Fizz_when_it_can_modulo_with3 [ ERROR ] --- "" != "Fizz" [ LINE ] --- fizzbuzz_test.c:12: error: Failure! [ FAILED ] test_fizzbuzz_return_Fizz_when_it_can_modulo_with3 [==========] 1 test(s) run. [ PASSED ] 0 test(s). [ FAILED ] 1 test(s), listed below: [ FAILED ] test_fizzbuzz_return_Fizz_when_it_can_modulo_with3 1 FAILED TEST(S)

จะสังเกตเห็นว่ามีผลการรัน unit test ขึ้นมาบรรทัดที่เป็น error จะแสดงผลที่ได้จากการ assert_string_equal ตรงบรรทัดที่ 12 นะ เพราะเราไป hard code ไว้ให้ fizzbuzz_say ของเราคืน empty string กลับมาเพราะงั้นไปทำให้เทสมัน PASS โดยเร็วที่สุดซะ

char *fizzbuzz_say(int n) { return "Fizz"; }

จากนั้น recompile ใหม่และรันการทดสอบเหมือนกับก่อนหน้านี้ ผลลัพธ์ที่ได้จะเปลี่ยนเป็น PASS

[==========] Running 1 test(s). [ RUN ] test_fizzbuzz_return_Fizz_when_it_can_modulo_with3 [ OK ] test_fizzbuzz_return_Fizz_when_it_can_modulo_with3 [==========] 1 test(s) run. [ PASSED ] 1 test(s).

Go มีความสามารถใน binding กับภาษา C โดยใช้ cgo เพราะงั้นก็น่าจะลองเอามาเขียน unittest ให้กับ C ได้นะ โจทย์วันนี้เราจะลองเขียน tree ด้วย C โดยสร้างไฟล์ชื่อ tree_test.go เป็นไฟล์สำหรับทดสอบเรื่องของ tree

// tree_test.go package tree // #include <stdlib.h> // // typedef struct _Node Node; // // struct _Node { // int val; // Node *left; // Node *right; // }; // // Node * NewNode(int val) { // Node *node = (Node *) malloc(sizeof(Node)); // node->val = val; // return node; // } import "C" import ( "testing" "unsafe" ) func TestNode_Value_ShouldSetAfterNewNode(t *testing.T) { node := C.NewNode(2) if node.val != 2 { t.Error("Expect value of node is 2 but got", node.val) } C.free(unsafe.Pointer(node)) }

Go ใช้การ import “C” เพื่อนำ C โค้ดเข้ามาใช้ใน Go เราสามารถเขียน C โค้ดที่จะใช้ในการทดสอบใน Go ได้ด้วยการเขียนคอมเม้นต์ C โค้ดบน import “C” จากนั้นรัน go test มันจะขึ้น

can't load package: package .: use of cgo in test /Users/wingyplus/gopath/src/github.com/wingyplus/tree/tree_test.go not supported

เหตุเพราะ Go ไม่ยอมให้เราใช้ cgo ในเทสไฟล์แต่ก็มีทางแก้อยู่นะ สร้างอีกไฟล์ขึ้นมาชื่อว่า tree.go และนำเทสของเราไปอยู่ในนั้นซะ

// tree_test.go package tree import "testing" func TestNode_Value_ShouldSetAfterNewNode(t *testing.T) { testNode_Value_ShouldSetAfterNewNode(t) }

// tree.go package tree // #include <stdlib.h> // // typedef struct _Node Node; // // struct _Node { // int val; // Node *left; // Node *right; // }; // // Node * NewNode(int val) { // Node *node = (Node *) malloc(sizeof(Node)); // node->val = val; // return node; // } import "C" import ( "testing" "unsafe" ) func testNode_Value_ShouldSetAfterNewNode(t *testing.T) { node := C.NewNode(2) if node.val != 2 { t.Error("Expect value of node is 2 but got", node.val) } C.free(unsafe.Pointer(node)) }

รัน go test อีกรอบก็จะผ่าน

$ go test PASS ok _/Users/wingyplus/gopath/src/github.com/wingyplus/tree 0.008s

แต่ในความเป็นจริงเรามักจะแยกออกเป็น .h และ .c แล้วค่อย include เข้ามานะ เพราะงั้น extract มันซะ โดยผมแยกออกมาเป็น tree.h และ tree.c

// tree.h #include <stdlib.h> typedef struct _Node Node; struct _Node { int val; Node *left; Node *right; }; Node * NewNode(int val);

// tree.c #include "tree.h" Node * NewNode(int val) { Node *node = (Node *) malloc(sizeof(Node)); node->val = val; return node; }

ที่ tree.go ของเราก็เปลี่ยนคอมเม้นต์ C โค้ดให้ไป include tree.h ซะ

// tree.go // #include "tree.h" import "C"

จากนั้นรัน go test ซะเพื่อยืนยันอีกรอบว่าที่เราทำไปนั้นผ่าน

$ go test PASS ok _/Users/wingyplus/gopath/src/github.com/wingyplus/tree 0.009s

คิดอยู่ว่ามีทางไหนที่จะทำให้การทดสอบเขียนได้ง่ายเรียนรู้ได้เร็ว (ทั้งเราและเค้า) นึกๆ ออกมาได้มี 3 ทางที่น่าลอง

ใช้ Go เขียนเทสโดยใช้ cgo ในการ binding และใช้ package testing ในการทดสอบ (หรืออาจจะ ginkgo แต่คิดว่าไม่ใช้) ข้อดีที่จะได้คือเราเขียนส่วนที่ทดสอบการเชื่อมต่อข้าม network ได้ง่าย เช่น http server, tcp server

ใช้ lib LuaJIT แล้วใช้ busted ซึ่งเป็น test framework หน้าตาคล้าย jasmine ของ js มาช่วยในการทดสอบ

หมดหนทางแล้วใช้ test framework ของ c ที่มีอยู่ในท้องตลาด

ตอนแรกตั้งใจจะหาไฟล์ javascript ด้วย bash แต่ดันขี้เกียจหา command บวกกับนั่งคิดว่าใช้ Go สำหรับหาไฟล์ javascript แล้วส่งให้ bash จัดการต่อดีกว่า ซึ่งเราจะใช้แพคเกจ path/filepath

หน้าตาของโค้ดจะเป็นแบบนี้

package main import ( "fmt" "os" "path/filepath" "strings" ) func isJs(path string) bool { return strings.HasSuffix(path, ".js") } func findJs(path string, info os.FileInfo, err error) error { if isJs(path) { fmt.Println(path) } return err } func main() { filepath.Walk("assets/js/project", findJs) }

วันนี้ได้อ่านบล็อคของ soundcloud มา ได้เจอเทคนิคนึงที่น่าสนใจคือการใช้ tag เพื่อเอามาทำ integration test โดยการใส่ // +build integration ไปที่ด้านบนของเทส

// +build integration package db import ( "testing" ) func TestDBIntegration(t *testing.T) { // do integration test... }

เมื่อเราระบุ tag integration go จะรันเฉพาะไฟล์ที่ติด tag integration ให้เท่านั้น หลังจากนั้นรันคำสั่ง go test โดยระบุ tags เพื่อรัน integration test 

$ go test -tags integration

ช่วงนี้เขียน Go มานาน ก็เริ่มอยากกลับไปหัด C เหมือนเมื่อก่อน โดยเริ่มอ่าน manual จาก http://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html อ่านคร่าวๆ จากนั้นก็เริ่มทำ kata fizzbuzz เพื่อดูว่าเราเรียนรู้อะไรจากมันบ้างนะ

อันนี้เป็น code ที่ผมทำไปได้ (unittest เขียนไม่เป็นนะ เอาเป็น printf ไปก่อนล่ะกัน :P)

#include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 typedef int bool; struct rule { int mod; char *word; }; typedef struct rule Rule; Rule * new_rule(int mod, char *word) { Rule *r = (Rule *) malloc(sizeof(Rule)); r->mod = mod; r->word = word; return r; } bool match(Rule *rule, int n) { if ((n % rule->mod) == 0) { return TRUE; } return FALSE; } char * say(Rule *rule) { return rule->word; } char * itoa(int n) { char * w = (char *) malloc(sizeof(char) * BUFSIZ); sprintf(w, "%d", n); return w; } char * fizzbuzz(Rule **rules, size_t l, int n) { int i, length = l/sizeof(rules[0]); for (i = 0; i < length; i++) { if (match(rules[i], n)) { return say(rules[i]); } } return itoa(n); } int main(int argc, char *argv[]) { Rule *rules[] = { new_rule(15, "fizbuzz"), new_rule(5, "buzz"), new_rule(3, "fizz"), }; size_t rulessize = sizeof(rules); // expect "1" printf("%s\n", fizzbuzz(rules, rulessize, 1)); // expect "fizz" printf("%s\n", fizzbuzz(rules, rulessize, 3)); // expect "buzz" printf("%s\n", fizzbuzz(rules, rulessize, 5)); // expect "fizzbuzz" printf("%s\n", fizzbuzz(rules, rulessize, 15)); return 0; }

สิ่งที่ค้นพบคือ

ใช้ typedef สำหรับสร้าง type ใหม่ขึ้นมาเพื่อทำให้โค้ดของเราอ่านง่ายขึ้น เช่น function match เราอยากให้คืนเป็น type boolean (true, false) แต่ว่าในใช้ 0 กับ 1 ซึ่งเป็น int เราสามารถใช้ typedef int bool และนำไปใช้แทน return type int ได้ และเรายังจะคืนค่าเป็น 0 กับ 1 ได้เหมือนเดิม เพราะ bool เกิดมาจาก int

ใช้ malloc สำหรับการ allocate ให้กับ pointer

ใช้ sizeof สำหรับหา size ของ variable หรือ type นั้นๆ ซึ่งจะได้เป็น type size_t ออกมา

size_t จริงๆ ก็มาจากท่า typedef ตามที่กล่าวไว้นั้นแหละ :)

การ convert จาก int ไปเป็น string ทำเหนื่อยเหมือนกัน แต่ไม่ได้ยากอะไร วิธีการคือ allocate pointer ของ char ไว้และใช้ sprintf เพื่อ print string เข้าไปที่ variable ที่เรา allocate ไว้

ใช้ * ที่ arg แทน []

array ไม่มี function สำหรับการหา length ของ array ต้องใช้ท่า sizeof(arr)/sizeof(arr[0]) เอา จะได้ length มาได้โดยง่าย :D

สิ่งที่ไม่เข้าใจคือ

ได้อ่านจาก blog ของพี่ป้อ แล้วเลยสงสัยว่าเราจะ test ตัว handler ได้อย่างไร ลองวิเคราะห์สิ่งที่จะต้องใช้สำหรับ test ก่อนเลยคือ

ต้องจำลอง Request ที่เข้าไปหา handler

ต้องบันทึก Response กลับมาเพื่อนำมาทดสอบ

ซึ่งใน Go เราสามารถใช้ NewRequest เพื่อจำลอง Request เข้าไปได้ตามข้อแรก และข้อที่ 2 นั้นเราสามารถใช้ Recorder ซึ่งมีใน "net/http/httptest" ของ Go เอง โดยจะทดลองเขียนเทสตามที่เราคิดไว้ด้านบน

package simplehttp import ( "fmt" "log" "net/http" "net/http/httptest" "testing" ) func TestHandler(t *testing.T) { handler := func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:]) } req, _ := http.NewRequest("GET", "http://localhost/wingyplus", nil) w := httptest.NewRecorder() handler(w, req) expectedResponse := "Hi there, I love wingyplus!" if w.Body.String() != expectedResponse { t.Errorf("expect %s but was %s", expectedResponse, w.Body.String()) } }

จากตัวอย่างด้านบน ผมสร้าง handler (นำมาจาก blog ของพี่ป้อตามที่กล่าวไว้ตอนแรก) ต่อมาผมสร้าง Request ขึ้นมาเพื่อตอบข้อ 1 และสร้าง Recorder ขึ้นมาเพื่อเก็บผลจากข้อ 2  execute handler function และสุดท้ายก็นำ Recorder ที่ได้กลับมาตรวจสอบผลลัพธ์ว่าเป็นไปตามที่เราคาดหวังไว้หรือไม่ :)

การ execute command line บน groovy ทำได้ง่ายมากๆ โดยใช้ method ชื่อ execute() ซึ่งเป็น method ของ class String เช่น

"ls".execute()

สิ่งที่ execute return มาคือ process ของการสั่ง command นั้น ซึ่งเราก็เอาผลลัพธ์ที่ได้จากการ execute นั้นผ่าน object ของ process นั้นเองเช่น

อยากได้ผลลัพธ์จากคำสั่ง "pwd"

def proc = "pwd".execute() println proc.in.text

หรือหากเราต้องรอให้การ execute นี้ทำจนเสร็จ ก็ทำได้โดยใช้ method ที่ชื่อว่า waitFor() เช่น

ต้องการรอให้คำสั่ง "./artisan migrate" ทำจนเสร็จ