add some tests

convert.go

@@ -284,3 +284,53 @@ func asKind(vv reflect.Value, tp reflect.Type) (interface{}, error) {
 	}
 	return nil, fmt.Errorf("unsupported primary key type: %v, %v", tp, vv)
 }
+
+func convertFloat(v interface{}) (float64, error) {
+	switch v.(type) {
+	case float32:
+		return float64(v.(float32)), nil
+	case float64:
+		return v.(float64), nil
+	case string:
+		i, err := strconv.ParseFloat(v.(string), 64)
+		if err != nil {
+			return 0, err
+		}
+		return i, nil
+	case []byte:
+		i, err := strconv.ParseFloat(string(v.([]byte)), 64)
+		if err != nil {
+			return 0, err
+		}
+		return i, nil
+	}
+	return 0, fmt.Errorf("unsupported type: %v", v)
+}
+
+func convertInt(v interface{}) (int64, error) {
+	switch v.(type) {
+	case int:
+		return int64(v.(int)), nil
+	case int8:
+		return int64(v.(int8)), nil
+	case int16:
+		return int64(v.(int16)), nil
+	case int32:
+		return int64(v.(int32)), nil
+	case int64:
+		return v.(int64), nil
+	case []byte:
+		i, err := strconv.ParseInt(string(v.([]byte)), 10, 64)
+		if err != nil {
+			return 0, err
+		}
+		return i, nil
+	case string:
+		i, err := strconv.ParseInt(v.(string), 10, 64)
+		if err != nil {
+			return 0, err
+		}
+		return i, nil
+	}
+	return 0, fmt.Errorf("unsupported type: %v", v)
+}

session_get_test.go

@@ -6,7 +6,6 @@ package xorm
 
 import (
 	"fmt"
-	"strconv"
 	"testing"
 	"time"
 
@@ -46,6 +45,15 @@ func TestGetVar(t *testing.T) {
 	assert.Equal(t, true, has)
 	assert.Equal(t, 28, age)
 
+	var age2 int64
+	has, err = testEngine.Table("get_var").Cols("age").
+		Where("age > ?", 20).
+		And("age < ?", 30).
+		Get(&age2)
+	assert.NoError(t, err)
+	assert.Equal(t, true, has)
+	assert.EqualValues(t, 28, age2)
+
 	var money float64
 	has, err = testEngine.Table("get_var").Cols("money").Get(&money)
 	assert.NoError(t, err)
@@ -100,53 +108,3 @@ func TestGetVar(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, "1.5", fmt.Sprintf("%v", v4))
 }
-
-func convertFloat(v interface{}) (float64, error) {
-	switch v.(type) {
-	case float32:
-		return float64(v.(float32)), nil
-	case float64:
-		return v.(float64), nil
-	case string:
-		i, err := strconv.ParseFloat(v.(string), 64)
-		if err != nil {
-			return 0, err
-		}
-		return i, nil
-	case []byte:
-		i, err := strconv.ParseFloat(string(v.([]byte)), 64)
-		if err != nil {
-			return 0, err
-		}
-		return i, nil
-	}
-	return 0, fmt.Errorf("unsupported type: %v", v)
-}
-
-func convertInt(v interface{}) (int64, error) {
-	switch v.(type) {
-	case int:
-		return int64(v.(int)), nil
-	case int8:
-		return int64(v.(int8)), nil
-	case int16:
-		return int64(v.(int16)), nil
-	case int32:
-		return int64(v.(int32)), nil
-	case int64:
-		return v.(int64), nil
-	case []byte:
-		i, err := strconv.ParseInt(string(v.([]byte)), 10, 64)
-		if err != nil {
-			return 0, err
-		}
-		return i, nil
-	case string:
-		i, err := strconv.ParseInt(v.(string), 10, 64)
-		if err != nil {
-			return 0, err
-		}
-		return i, nil
-	}
-	return 0, fmt.Errorf("unsupported type: %v", v)
-}

session_insert_test.go

@@ -5,6 +5,8 @@
 package xorm
 
 import (
+	"fmt"
+	"reflect"
 	"testing"
 	"time"
 
@@ -43,6 +45,82 @@ func TestInsertOne2(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestInsertMulti(t *testing.T) {
+
+	assert.NoError(t, prepareEngine())
+	type TestMulti struct {
+		Id   int64  `xorm:"int(11) pk"`
+		Name string `xorm:"varchar(255)"`
+	}
+
+	assert.NoError(t, testEngine.Sync2(new(TestMulti)))
+
+	num, err := insertMultiDatas(1,
+		append([]TestMulti{}, TestMulti{1, "test1"}, TestMulti{2, "test2"}, TestMulti{3, "test3"}))
+	assert.NoError(t, err)
+	assert.EqualValues(t, 3, num)
+}
+
+func insertMultiDatas(step int, datas interface{}) (num int64, err error) {
+	sliceValue := reflect.Indirect(reflect.ValueOf(datas))
+	var iLen int64
+	if sliceValue.Kind() != reflect.Slice {
+		return 0, fmt.Errorf("not silce")
+	}
+	iLen = int64(sliceValue.Len())
+	if iLen == 0 {
+		return
+	}
+
+	session := testEngine.NewSession()
+	defer session.Close()
+
+	if err = callbackLooper(datas, step,
+		func(innerDatas interface{}) error {
+			n, e := session.InsertMulti(innerDatas)
+			if e != nil {
+				return e
+			}
+			num += n
+			return nil
+		}); err != nil {
+		return 0, err
+	} else if num != iLen {
+		return 0, fmt.Errorf("num error: %d - %d", num, iLen)
+	}
+	return
+}
+
+func callbackLooper(datas interface{}, step int, actionFunc func(interface{}) error) (err error) {
+
+	sliceValue := reflect.Indirect(reflect.ValueOf(datas))
+	if sliceValue.Kind() != reflect.Slice {
+		return fmt.Errorf("not slice")
+	}
+	if sliceValue.Len() <= 0 {
+		return
+	}
+
+	tempLen := 0
+	processedLen := sliceValue.Len()
+	for i := 0; i < sliceValue.Len(); i += step {
+		if processedLen > step {
+			tempLen = i + step
+		} else {
+			tempLen = sliceValue.Len()
+		}
+		var tempInterface []interface{}
+		for j := i; j < tempLen; j++ {
+			tempInterface = append(tempInterface, sliceValue.Index(j).Interface())
+		}
+		if err = actionFunc(tempInterface); err != nil {
+			return
+		}
+		processedLen = processedLen - step
+	}
+	return
+}
+
 func TestInsertOneIfPkIsPoint(t *testing.T) {
 	assert.NoError(t, prepareEngine())