diff --git a/processors_test.go b/processors_test.go
index e8c27e89..d1efc047 100644
--- a/processors_test.go
+++ b/processors_test.go
@@ -154,118 +154,86 @@ func TestProcessors(t *testing.T) {
 	}
 
 	_, err = testEngine.Before(b4InsertFunc).After(afterInsertFunc).Insert(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p.AfterInsertedFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p.AfterInsertedViaExt == 0 {
-			t.Error(errors.New("AfterInsertedViaExt not set"))
-		}
-	}
+	assert.NoError(t, err)
+	assert.True(t, p.Id > 0, "Inserted ID not set")
+	assert.True(t, p.B4InsertFlag > 0, "B4InsertFlag not set")
+	assert.True(t, p.AfterInsertedFlag > 0, "B4InsertFlag not set")
+	assert.True(t, p.B4InsertViaExt > 0, "B4InsertFlag not set")
+	assert.True(t, p.AfterInsertedViaExt > 0, "AfterInsertedViaExt not set")
 
 	p2 := &ProcessorsStruct{}
-	_, err = testEngine.ID(p.Id).Get(p2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p2.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p2.AfterInsertedFlag != 0 {
-			t.Error(errors.New("AfterInsertedFlag is set"))
-		}
-		if p2.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertViaExt not set"))
-		}
-		if p2.AfterInsertedViaExt != 0 {
-			t.Error(errors.New("AfterInsertedViaExt is set"))
-		}
-		if p2.BeforeSetFlag != 9 {
-			t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p2.BeforeSetFlag))
-		}
-		if p2.AfterSetFlag != 9 {
-			t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p2.BeforeSetFlag))
-		}
-	}
+	has, err := testEngine.ID(p.Id).Get(p2)
+	assert.NoError(t, err)
+	assert.True(t, has)
+	assert.True(t, p2.B4InsertFlag > 0, "B4InsertFlag not set")
+	assert.True(t, p2.AfterInsertedFlag == 0, "AfterInsertedFlag is set")
+	assert.True(t, p2.B4InsertViaExt > 0, "B4InsertViaExt not set")
+	assert.True(t, p2.AfterInsertedViaExt == 0, "AfterInsertedViaExt is set")
+	assert.True(t, p2.BeforeSetFlag == 9, fmt.Sprintf("BeforeSetFlag is %d not 9", p2.BeforeSetFlag))
+	assert.True(t, p2.AfterSetFlag == 9, fmt.Sprintf("AfterSetFlag is %d not 9", p2.BeforeSetFlag))
 	// --
 
 	// test find processors
 	var p2Find []*ProcessorsStruct
 	err = testEngine.Find(&p2Find)
-	if err != nil {
+	assert.NoError(t, err)
+
+	if len(p2Find) != 1 {
+		err = errors.New("Should get 1")
 		t.Error(err)
-		panic(err)
-	} else {
-		if len(p2Find) != 1 {
-			err = errors.New("Should get 1")
-			t.Error(err)
-		}
-		p21 := p2Find[0]
-		if p21.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p21.AfterInsertedFlag != 0 {
-			t.Error(errors.New("AfterInsertedFlag is set"))
-		}
-		if p21.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertViaExt not set"))
-		}
-		if p21.AfterInsertedViaExt != 0 {
-			t.Error(errors.New("AfterInsertedViaExt is set"))
-		}
-		if p21.BeforeSetFlag != 9 {
-			t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p21.BeforeSetFlag))
-		}
-		if p21.AfterSetFlag != 9 {
-			t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p21.BeforeSetFlag))
-		}
+	}
+	p21 := p2Find[0]
+	if p21.B4InsertFlag == 0 {
+		t.Error(errors.New("B4InsertFlag not set"))
+	}
+	if p21.AfterInsertedFlag != 0 {
+		t.Error(errors.New("AfterInsertedFlag is set"))
+	}
+	if p21.B4InsertViaExt == 0 {
+		t.Error(errors.New("B4InsertViaExt not set"))
+	}
+	if p21.AfterInsertedViaExt != 0 {
+		t.Error(errors.New("AfterInsertedViaExt is set"))
+	}
+	if p21.BeforeSetFlag != 9 {
+		t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p21.BeforeSetFlag))
+	}
+	if p21.AfterSetFlag != 9 {
+		t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p21.BeforeSetFlag))
 	}
 	// --
 
 	// test find map processors
 	var p2FindMap = make(map[int64]*ProcessorsStruct)
 	err = testEngine.Find(&p2FindMap)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if len(p2FindMap) != 1 {
-			err = errors.New("Should get 1")
-			t.Error(err)
-		}
-		var p22 *ProcessorsStruct
-		for _, v := range p2FindMap {
-			p22 = v
-		}
+	assert.NoError(t, err)
 
-		if p22.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p22.AfterInsertedFlag != 0 {
-			t.Error(errors.New("AfterInsertedFlag is set"))
-		}
-		if p22.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertViaExt not set"))
-		}
-		if p22.AfterInsertedViaExt != 0 {
-			t.Error(errors.New("AfterInsertedViaExt is set"))
-		}
-		if p22.BeforeSetFlag != 9 {
-			t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p22.BeforeSetFlag))
-		}
-		if p22.AfterSetFlag != 9 {
-			t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p22.BeforeSetFlag))
-		}
+	if len(p2FindMap) != 1 {
+		err = errors.New("Should get 1")
+		t.Error(err)
+	}
+	var p22 *ProcessorsStruct
+	for _, v := range p2FindMap {
+		p22 = v
+	}
+
+	if p22.B4InsertFlag == 0 {
+		t.Error(errors.New("B4InsertFlag not set"))
+	}
+	if p22.AfterInsertedFlag != 0 {
+		t.Error(errors.New("AfterInsertedFlag is set"))
+	}
+	if p22.B4InsertViaExt == 0 {
+		t.Error(errors.New("B4InsertViaExt not set"))
+	}
+	if p22.AfterInsertedViaExt != 0 {
+		t.Error(errors.New("AfterInsertedViaExt is set"))
+	}
+	if p22.BeforeSetFlag != 9 {
+		t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p22.BeforeSetFlag))
+	}
+	if p22.AfterSetFlag != 9 {
+		t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p22.BeforeSetFlag))
 	}
 	// --
 
@@ -289,48 +257,43 @@ func TestProcessors(t *testing.T) {
 	p = p2 // reset
 
 	_, err = testEngine.Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p.AfterUpdatedFlag == 0 {
-			t.Error(errors.New("AfterUpdatedFlag not set"))
-		}
-		if p.B4UpdateViaExt == 0 {
-			t.Error(errors.New("B4UpdateViaExt not set"))
-		}
-		if p.AfterUpdatedViaExt == 0 {
-			t.Error(errors.New("AfterUpdatedViaExt not set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
+	}
+	if p.AfterUpdatedFlag == 0 {
+		t.Error(errors.New("AfterUpdatedFlag not set"))
+	}
+	if p.B4UpdateViaExt == 0 {
+		t.Error(errors.New("B4UpdateViaExt not set"))
+	}
+	if p.AfterUpdatedViaExt == 0 {
+		t.Error(errors.New("AfterUpdatedViaExt not set"))
 	}
 
 	p2 = &ProcessorsStruct{}
-	_, err = testEngine.ID(p.Id).Get(p2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p2.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p2.AfterUpdatedFlag != 0 {
-			t.Error(errors.New("AfterUpdatedFlag is set: " + string(p.AfterUpdatedFlag)))
-		}
-		if p2.B4UpdateViaExt == 0 {
-			t.Error(errors.New("B4UpdateViaExt not set"))
-		}
-		if p2.AfterUpdatedViaExt != 0 {
-			t.Error(errors.New("AfterUpdatedViaExt is set: " + string(p.AfterUpdatedViaExt)))
-		}
-		if p2.BeforeSetFlag != 9 {
-			t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p2.BeforeSetFlag))
-		}
-		if p2.AfterSetFlag != 9 {
-			t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p2.BeforeSetFlag))
-		}
+	has, err = testEngine.ID(p.Id).Get(p2)
+	assert.NoError(t, err)
+	assert.True(t, has)
+
+	if p2.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
+	}
+	if p2.AfterUpdatedFlag != 0 {
+		t.Error(errors.New("AfterUpdatedFlag is set: " + string(p.AfterUpdatedFlag)))
+	}
+	if p2.B4UpdateViaExt == 0 {
+		t.Error(errors.New("B4UpdateViaExt not set"))
+	}
+	if p2.AfterUpdatedViaExt != 0 {
+		t.Error(errors.New("AfterUpdatedViaExt is set: " + string(p.AfterUpdatedViaExt)))
+	}
+	if p2.BeforeSetFlag != 9 {
+		t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p2.BeforeSetFlag))
+	}
+	if p2.AfterSetFlag != 9 {
+		t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p2.BeforeSetFlag))
 	}
 	// --
 
@@ -353,22 +316,18 @@ func TestProcessors(t *testing.T) {
 
 	p = p2 // reset
 	_, err = testEngine.Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4DeleteFlag == 0 {
-			t.Error(errors.New("B4DeleteFlag not set"))
-		}
-		if p.AfterDeletedFlag == 0 {
-			t.Error(errors.New("AfterDeletedFlag not set"))
-		}
-		if p.B4DeleteViaExt == 0 {
-			t.Error(errors.New("B4DeleteViaExt not set"))
-		}
-		if p.AfterDeletedViaExt == 0 {
-			t.Error(errors.New("AfterDeletedViaExt not set"))
-		}
+	assert.NoError(t, err)
+	if p.B4DeleteFlag == 0 {
+		t.Error(errors.New("B4DeleteFlag not set"))
+	}
+	if p.AfterDeletedFlag == 0 {
+		t.Error(errors.New("AfterDeletedFlag not set"))
+	}
+	if p.B4DeleteViaExt == 0 {
+		t.Error(errors.New("B4DeleteViaExt not set"))
+	}
+	if p.AfterDeletedViaExt == 0 {
+		t.Error(errors.New("AfterDeletedViaExt not set"))
 	}
 	// --
 
@@ -377,54 +336,46 @@ func TestProcessors(t *testing.T) {
 	pslice = append(pslice, &ProcessorsStruct{})
 	pslice = append(pslice, &ProcessorsStruct{})
 	cnt, err := testEngine.Before(b4InsertFunc).After(afterInsertFunc).Insert(&pslice)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if cnt != 2 {
-			t.Error(errors.New("incorrect insert count"))
+	assert.NoError(t, err)
+	assert.EqualValues(t, 2, cnt, "incorrect insert count")
+
+	for _, elem := range pslice {
+		if elem.B4InsertFlag == 0 {
+			t.Error(errors.New("B4InsertFlag not set"))
 		}
-		for _, elem := range pslice {
-			if elem.B4InsertFlag == 0 {
-				t.Error(errors.New("B4InsertFlag not set"))
-			}
-			if elem.AfterInsertedFlag == 0 {
-				t.Error(errors.New("B4InsertFlag not set"))
-			}
-			if elem.B4InsertViaExt == 0 {
-				t.Error(errors.New("B4InsertFlag not set"))
-			}
-			if elem.AfterInsertedViaExt == 0 {
-				t.Error(errors.New("AfterInsertedViaExt not set"))
-			}
+		if elem.AfterInsertedFlag == 0 {
+			t.Error(errors.New("B4InsertFlag not set"))
+		}
+		if elem.B4InsertViaExt == 0 {
+			t.Error(errors.New("B4InsertFlag not set"))
+		}
+		if elem.AfterInsertedViaExt == 0 {
+			t.Error(errors.New("AfterInsertedViaExt not set"))
 		}
 	}
 
 	for _, elem := range pslice {
 		p = &ProcessorsStruct{}
 		_, err = testEngine.ID(elem.Id).Get(p)
-		if err != nil {
-			t.Error(err)
-			panic(err)
-		} else {
-			if p2.B4InsertFlag == 0 {
-				t.Error(errors.New("B4InsertFlag not set"))
-			}
-			if p2.AfterInsertedFlag != 0 {
-				t.Error(errors.New("AfterInsertedFlag is set"))
-			}
-			if p2.B4InsertViaExt == 0 {
-				t.Error(errors.New("B4InsertViaExt not set"))
-			}
-			if p2.AfterInsertedViaExt != 0 {
-				t.Error(errors.New("AfterInsertedViaExt is set"))
-			}
-			if p2.BeforeSetFlag != 9 {
-				t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p2.BeforeSetFlag))
-			}
-			if p2.AfterSetFlag != 9 {
-				t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p2.BeforeSetFlag))
-			}
+		assert.NoError(t, err)
+
+		if p2.B4InsertFlag == 0 {
+			t.Error(errors.New("B4InsertFlag not set"))
+		}
+		if p2.AfterInsertedFlag != 0 {
+			t.Error(errors.New("AfterInsertedFlag is set"))
+		}
+		if p2.B4InsertViaExt == 0 {
+			t.Error(errors.New("B4InsertViaExt not set"))
+		}
+		if p2.AfterInsertedViaExt != 0 {
+			t.Error(errors.New("AfterInsertedViaExt is set"))
+		}
+		if p2.BeforeSetFlag != 9 {
+			t.Error(fmt.Errorf("BeforeSetFlag is %d not 9", p2.BeforeSetFlag))
+		}
+		if p2.AfterSetFlag != 9 {
+			t.Error(fmt.Errorf("AfterSetFlag is %d not 9", p2.BeforeSetFlag))
 		}
 	}
 	// --
@@ -434,24 +385,17 @@ func TestProcessorsTx(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(&ProcessorsStruct{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	err = testEngine.CreateTables(&ProcessorsStruct{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	// test insert processors with tx rollback
 	session := testEngine.NewSession()
+	defer session.Close()
+
 	err = session.Begin()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	p := &ProcessorsStruct{}
 	b4InsertFunc := func(bean interface{}) {
@@ -470,133 +414,117 @@ func TestProcessorsTx(t *testing.T) {
 		}
 	}
 	_, err = session.Before(b4InsertFunc).After(afterInsertFunc).Insert(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p.AfterInsertedFlag != 0 {
-			t.Error(errors.New("B4InsertFlag is set"))
-		}
-		if p.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertViaExt not set"))
-		}
-		if p.AfterInsertedViaExt != 0 {
-			t.Error(errors.New("AfterInsertedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4InsertFlag == 0 {
+		t.Error(errors.New("B4InsertFlag not set"))
+	}
+	if p.AfterInsertedFlag != 0 {
+		t.Error(errors.New("B4InsertFlag is set"))
+	}
+	if p.B4InsertViaExt == 0 {
+		t.Error(errors.New("B4InsertViaExt not set"))
+	}
+	if p.AfterInsertedViaExt != 0 {
+		t.Error(errors.New("AfterInsertedViaExt is set"))
 	}
 
 	err = session.Rollback()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p.AfterInsertedFlag != 0 {
-			t.Error(errors.New("B4InsertFlag is set"))
-		}
-		if p.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertViaExt not set"))
-		}
-		if p.AfterInsertedViaExt != 0 {
-			t.Error(errors.New("AfterInsertedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4InsertFlag == 0 {
+		t.Error(errors.New("B4InsertFlag not set"))
 	}
+	if p.AfterInsertedFlag != 0 {
+		t.Error(errors.New("B4InsertFlag is set"))
+	}
+	if p.B4InsertViaExt == 0 {
+		t.Error(errors.New("B4InsertViaExt not set"))
+	}
+	if p.AfterInsertedViaExt != 0 {
+		t.Error(errors.New("AfterInsertedViaExt is set"))
+	}
+
 	session.Close()
+
 	p2 := &ProcessorsStruct{}
 	_, err = testEngine.ID(p.Id).Get(p2)
-	if err != nil {
+	assert.NoError(t, err)
+
+	if p2.Id > 0 {
+		err = errors.New("tx got committed upon insert!?")
 		t.Error(err)
 		panic(err)
-	} else {
-		if p2.Id > 0 {
-			err = errors.New("tx got committed upon insert!?")
-			t.Error(err)
-			panic(err)
-		}
 	}
 	// --
 
 	// test insert processors with tx commit
 	session = testEngine.NewSession()
+	defer session.Close()
+
 	err = session.Begin()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	p = &ProcessorsStruct{}
 	_, err = session.Before(b4InsertFunc).After(afterInsertFunc).Insert(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p.AfterInsertedFlag != 0 {
-			t.Error(errors.New("AfterInsertedFlag is set"))
-		}
-		if p.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertViaExt not set"))
-		}
-		if p.AfterInsertedViaExt != 0 {
-			t.Error(errors.New("AfterInsertedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4InsertFlag == 0 {
+		t.Error(errors.New("B4InsertFlag not set"))
+	}
+	if p.AfterInsertedFlag != 0 {
+		t.Error(errors.New("AfterInsertedFlag is set"))
+	}
+	if p.B4InsertViaExt == 0 {
+		t.Error(errors.New("B4InsertViaExt not set"))
+	}
+	if p.AfterInsertedViaExt != 0 {
+		t.Error(errors.New("AfterInsertedViaExt is set"))
 	}
 
 	err = session.Commit()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p.AfterInsertedFlag == 0 {
-			t.Error(errors.New("AfterInsertedFlag not set"))
-		}
-		if p.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertViaExt not set"))
-		}
-		if p.AfterInsertedViaExt == 0 {
-			t.Error(errors.New("AfterInsertedViaExt not set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4InsertFlag == 0 {
+		t.Error(errors.New("B4InsertFlag not set"))
 	}
+	if p.AfterInsertedFlag == 0 {
+		t.Error(errors.New("AfterInsertedFlag not set"))
+	}
+	if p.B4InsertViaExt == 0 {
+		t.Error(errors.New("B4InsertViaExt not set"))
+	}
+	if p.AfterInsertedViaExt == 0 {
+		t.Error(errors.New("AfterInsertedViaExt not set"))
+	}
+
 	session.Close()
 	p2 = &ProcessorsStruct{}
 	_, err = testEngine.ID(p.Id).Get(p2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p2.B4InsertFlag == 0 {
-			t.Error(errors.New("B4InsertFlag not set"))
-		}
-		if p2.AfterInsertedFlag != 0 {
-			t.Error(errors.New("AfterInsertedFlag is set"))
-		}
-		if p2.B4InsertViaExt == 0 {
-			t.Error(errors.New("B4InsertViaExt not set"))
-		}
-		if p2.AfterInsertedViaExt != 0 {
-			t.Error(errors.New("AfterInsertedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p2.B4InsertFlag == 0 {
+		t.Error(errors.New("B4InsertFlag not set"))
 	}
+	if p2.AfterInsertedFlag != 0 {
+		t.Error(errors.New("AfterInsertedFlag is set"))
+	}
+	if p2.B4InsertViaExt == 0 {
+		t.Error(errors.New("B4InsertViaExt not set"))
+	}
+	if p2.AfterInsertedViaExt != 0 {
+		t.Error(errors.New("AfterInsertedViaExt is set"))
+	}
+
 	insertedId := p2.Id
 	// --
 
 	// test update processors with tx rollback
 	session = testEngine.NewSession()
+	defer session.Close()
+
 	err = session.Begin()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	b4UpdateFunc := func(bean interface{}) {
 		if v, ok := (bean).(*ProcessorsStruct); ok {
@@ -617,183 +545,160 @@ func TestProcessorsTx(t *testing.T) {
 	p = p2 // reset
 
 	_, err = session.ID(insertedId).Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p.AfterUpdatedFlag != 0 {
-			t.Error(errors.New("AfterUpdatedFlag is set"))
-		}
-		if p.B4UpdateViaExt == 0 {
-			t.Error(errors.New("B4UpdateViaExt not set"))
-		}
-		if p.AfterUpdatedViaExt != 0 {
-			t.Error(errors.New("AfterUpdatedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
 	}
+	if p.AfterUpdatedFlag != 0 {
+		t.Error(errors.New("AfterUpdatedFlag is set"))
+	}
+	if p.B4UpdateViaExt == 0 {
+		t.Error(errors.New("B4UpdateViaExt not set"))
+	}
+	if p.AfterUpdatedViaExt != 0 {
+		t.Error(errors.New("AfterUpdatedViaExt is set"))
+	}
+
 	err = session.Rollback()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p.AfterUpdatedFlag != 0 {
-			t.Error(errors.New("AfterUpdatedFlag is set"))
-		}
-		if p.B4UpdateViaExt == 0 {
-			t.Error(errors.New("B4UpdateViaExt not set"))
-		}
-		if p.AfterUpdatedViaExt != 0 {
-			t.Error(errors.New("AfterUpdatedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
+	}
+	if p.AfterUpdatedFlag != 0 {
+		t.Error(errors.New("AfterUpdatedFlag is set"))
+	}
+	if p.B4UpdateViaExt == 0 {
+		t.Error(errors.New("B4UpdateViaExt not set"))
+	}
+	if p.AfterUpdatedViaExt != 0 {
+		t.Error(errors.New("AfterUpdatedViaExt is set"))
 	}
 
 	session.Close()
 
 	p2 = &ProcessorsStruct{}
 	_, err = testEngine.ID(insertedId).Get(p2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p2.B4UpdateFlag != 0 {
-			t.Error(errors.New("B4UpdateFlag is set"))
-		}
-		if p2.AfterUpdatedFlag != 0 {
-			t.Error(errors.New("AfterUpdatedFlag is set"))
-		}
-		if p2.B4UpdateViaExt != 0 {
-			t.Error(errors.New("B4UpdateViaExt not set"))
-		}
-		if p2.AfterUpdatedViaExt != 0 {
-			t.Error(errors.New("AfterUpdatedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p2.B4UpdateFlag != 0 {
+		t.Error(errors.New("B4UpdateFlag is set"))
+	}
+	if p2.AfterUpdatedFlag != 0 {
+		t.Error(errors.New("AfterUpdatedFlag is set"))
+	}
+	if p2.B4UpdateViaExt != 0 {
+		t.Error(errors.New("B4UpdateViaExt not set"))
+	}
+	if p2.AfterUpdatedViaExt != 0 {
+		t.Error(errors.New("AfterUpdatedViaExt is set"))
 	}
 	// --
 
 	// test update processors with tx rollback
 	session = testEngine.NewSession()
+	defer session.Close()
+
 	err = session.Begin()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	p = &ProcessorsStruct{Id: insertedId}
 
 	_, err = session.Update(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p.AfterUpdatedFlag != 0 {
-			t.Error(errors.New("AfterUpdatedFlag is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
 	}
+	if p.AfterUpdatedFlag != 0 {
+		t.Error(errors.New("AfterUpdatedFlag is set"))
+	}
+
 	err = session.Commit()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p.AfterUpdatedFlag == 0 {
-			t.Error(errors.New("AfterUpdatedFlag not set"))
-		}
-		if p.AfterDeletedFlag != 0 {
-			t.Error(errors.New("AfterDeletedFlag set"))
-		}
-		if p.AfterInsertedFlag != 0 {
-			t.Error(errors.New("AfterInsertedFlag set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
+	}
+	if p.AfterUpdatedFlag == 0 {
+		t.Error(errors.New("AfterUpdatedFlag not set"))
+	}
+	if p.AfterDeletedFlag != 0 {
+		t.Error(errors.New("AfterDeletedFlag set"))
+	}
+	if p.AfterInsertedFlag != 0 {
+		t.Error(errors.New("AfterInsertedFlag set"))
 	}
 
 	session.Close()
 
 	// test update processors with tx commit
 	session = testEngine.NewSession()
+	defer session.Close()
+
 	err = session.Begin()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	p = &ProcessorsStruct{}
 
 	_, err = session.ID(insertedId).Before(b4UpdateFunc).After(afterUpdateFunc).Update(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p.AfterUpdatedFlag != 0 {
-			t.Error(errors.New("AfterUpdatedFlag is set"))
-		}
-		if p.B4UpdateViaExt == 0 {
-			t.Error(errors.New("B4UpdateViaExt not set"))
-		}
-		if p.AfterUpdatedViaExt != 0 {
-			t.Error(errors.New("AfterUpdatedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
 	}
+	if p.AfterUpdatedFlag != 0 {
+		t.Error(errors.New("AfterUpdatedFlag is set"))
+	}
+	if p.B4UpdateViaExt == 0 {
+		t.Error(errors.New("B4UpdateViaExt not set"))
+	}
+	if p.AfterUpdatedViaExt != 0 {
+		t.Error(errors.New("AfterUpdatedViaExt is set"))
+	}
+
 	err = session.Commit()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p.AfterUpdatedFlag == 0 {
-			t.Error(errors.New("AfterUpdatedFlag not set"))
-		}
-		if p.B4UpdateViaExt == 0 {
-			t.Error(errors.New("B4UpdateViaExt not set"))
-		}
-		if p.AfterUpdatedViaExt == 0 {
-			t.Error(errors.New("AfterUpdatedViaExt not set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
 	}
+	if p.AfterUpdatedFlag == 0 {
+		t.Error(errors.New("AfterUpdatedFlag not set"))
+	}
+	if p.B4UpdateViaExt == 0 {
+		t.Error(errors.New("B4UpdateViaExt not set"))
+	}
+	if p.AfterUpdatedViaExt == 0 {
+		t.Error(errors.New("AfterUpdatedViaExt not set"))
+	}
+
 	session.Close()
 	p2 = &ProcessorsStruct{}
 	_, err = testEngine.ID(insertedId).Get(p2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4UpdateFlag == 0 {
-			t.Error(errors.New("B4UpdateFlag not set"))
-		}
-		if p.AfterUpdatedFlag == 0 {
-			t.Error(errors.New("AfterUpdatedFlag not set"))
-		}
-		if p.B4UpdateViaExt == 0 {
-			t.Error(errors.New("B4UpdateViaExt not set"))
-		}
-		if p.AfterUpdatedViaExt == 0 {
-			t.Error(errors.New("AfterUpdatedViaExt not set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4UpdateFlag == 0 {
+		t.Error(errors.New("B4UpdateFlag not set"))
+	}
+	if p.AfterUpdatedFlag == 0 {
+		t.Error(errors.New("AfterUpdatedFlag not set"))
+	}
+	if p.B4UpdateViaExt == 0 {
+		t.Error(errors.New("B4UpdateViaExt not set"))
+	}
+	if p.AfterUpdatedViaExt == 0 {
+		t.Error(errors.New("AfterUpdatedViaExt not set"))
 	}
 	// --
 
 	// test delete processors with tx rollback
 	session = testEngine.NewSession()
+	defer session.Close()
+
 	err = session.Begin()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	b4DeleteFunc := func(bean interface{}) {
 		if v, ok := (bean).(*ProcessorsStruct); ok {
@@ -814,152 +719,131 @@ func TestProcessorsTx(t *testing.T) {
 	p = &ProcessorsStruct{} // reset
 
 	_, err = session.ID(insertedId).Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4DeleteFlag == 0 {
-			t.Error(errors.New("B4DeleteFlag not set"))
-		}
-		if p.AfterDeletedFlag != 0 {
-			t.Error(errors.New("AfterDeletedFlag is set"))
-		}
-		if p.B4DeleteViaExt == 0 {
-			t.Error(errors.New("B4DeleteViaExt not set"))
-		}
-		if p.AfterDeletedViaExt != 0 {
-			t.Error(errors.New("AfterDeletedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4DeleteFlag == 0 {
+		t.Error(errors.New("B4DeleteFlag not set"))
 	}
+	if p.AfterDeletedFlag != 0 {
+		t.Error(errors.New("AfterDeletedFlag is set"))
+	}
+	if p.B4DeleteViaExt == 0 {
+		t.Error(errors.New("B4DeleteViaExt not set"))
+	}
+	if p.AfterDeletedViaExt != 0 {
+		t.Error(errors.New("AfterDeletedViaExt is set"))
+	}
+
 	err = session.Rollback()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4DeleteFlag == 0 {
-			t.Error(errors.New("B4DeleteFlag not set"))
-		}
-		if p.AfterDeletedFlag != 0 {
-			t.Error(errors.New("AfterDeletedFlag is set"))
-		}
-		if p.B4DeleteViaExt == 0 {
-			t.Error(errors.New("B4DeleteViaExt not set"))
-		}
-		if p.AfterDeletedViaExt != 0 {
-			t.Error(errors.New("AfterDeletedViaExt is set"))
-		}
+	assert.NoError(t, err)
+	if p.B4DeleteFlag == 0 {
+		t.Error(errors.New("B4DeleteFlag not set"))
 	}
+	if p.AfterDeletedFlag != 0 {
+		t.Error(errors.New("AfterDeletedFlag is set"))
+	}
+	if p.B4DeleteViaExt == 0 {
+		t.Error(errors.New("B4DeleteViaExt not set"))
+	}
+	if p.AfterDeletedViaExt != 0 {
+		t.Error(errors.New("AfterDeletedViaExt is set"))
+	}
+
 	session.Close()
 
 	p2 = &ProcessorsStruct{}
 	_, err = testEngine.ID(insertedId).Get(p2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p2.B4DeleteFlag != 0 {
-			t.Error(errors.New("B4DeleteFlag is set"))
-		}
-		if p2.AfterDeletedFlag != 0 {
-			t.Error(errors.New("AfterDeletedFlag is set"))
-		}
-		if p2.B4DeleteViaExt != 0 {
-			t.Error(errors.New("B4DeleteViaExt is set"))
-		}
-		if p2.AfterDeletedViaExt != 0 {
-			t.Error(errors.New("AfterDeletedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p2.B4DeleteFlag != 0 {
+		t.Error(errors.New("B4DeleteFlag is set"))
+	}
+	if p2.AfterDeletedFlag != 0 {
+		t.Error(errors.New("AfterDeletedFlag is set"))
+	}
+	if p2.B4DeleteViaExt != 0 {
+		t.Error(errors.New("B4DeleteViaExt is set"))
+	}
+	if p2.AfterDeletedViaExt != 0 {
+		t.Error(errors.New("AfterDeletedViaExt is set"))
 	}
 	// --
 
 	// test delete processors with tx commit
 	session = testEngine.NewSession()
+	defer session.Close()
+
 	err = session.Begin()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	p = &ProcessorsStruct{}
 
 	_, err = session.ID(insertedId).Before(b4DeleteFunc).After(afterDeleteFunc).Delete(p)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4DeleteFlag == 0 {
-			t.Error(errors.New("B4DeleteFlag not set"))
-		}
-		if p.AfterDeletedFlag != 0 {
-			t.Error(errors.New("AfterDeletedFlag is set"))
-		}
-		if p.B4DeleteViaExt == 0 {
-			t.Error(errors.New("B4DeleteViaExt not set"))
-		}
-		if p.AfterDeletedViaExt != 0 {
-			t.Error(errors.New("AfterDeletedViaExt is set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4DeleteFlag == 0 {
+		t.Error(errors.New("B4DeleteFlag not set"))
 	}
+	if p.AfterDeletedFlag != 0 {
+		t.Error(errors.New("AfterDeletedFlag is set"))
+	}
+	if p.B4DeleteViaExt == 0 {
+		t.Error(errors.New("B4DeleteViaExt not set"))
+	}
+	if p.AfterDeletedViaExt != 0 {
+		t.Error(errors.New("AfterDeletedViaExt is set"))
+	}
+
 	err = session.Commit()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4DeleteFlag == 0 {
-			t.Error(errors.New("B4DeleteFlag not set"))
-		}
-		if p.AfterDeletedFlag == 0 {
-			t.Error(errors.New("AfterDeletedFlag not set"))
-		}
-		if p.B4DeleteViaExt == 0 {
-			t.Error(errors.New("B4DeleteViaExt not set"))
-		}
-		if p.AfterDeletedViaExt == 0 {
-			t.Error(errors.New("AfterDeletedViaExt not set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4DeleteFlag == 0 {
+		t.Error(errors.New("B4DeleteFlag not set"))
 	}
+	if p.AfterDeletedFlag == 0 {
+		t.Error(errors.New("AfterDeletedFlag not set"))
+	}
+	if p.B4DeleteViaExt == 0 {
+		t.Error(errors.New("B4DeleteViaExt not set"))
+	}
+	if p.AfterDeletedViaExt == 0 {
+		t.Error(errors.New("AfterDeletedViaExt not set"))
+	}
+
 	session.Close()
 
 	// test delete processors with tx commit
 	session = testEngine.NewSession()
+	defer session.Close()
+
 	err = session.Begin()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	p = &ProcessorsStruct{Id: insertedId}
-	fmt.Println("delete")
 	_, err = session.Delete(p)
+	assert.NoError(t, err)
 
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4DeleteFlag == 0 {
-			t.Error(errors.New("B4DeleteFlag not set"))
-		}
-		if p.AfterDeletedFlag != 0 {
-			t.Error(errors.New("AfterDeletedFlag is set"))
-		}
+	if p.B4DeleteFlag == 0 {
+		t.Error(errors.New("B4DeleteFlag not set"))
 	}
+	if p.AfterDeletedFlag != 0 {
+		t.Error(errors.New("AfterDeletedFlag is set"))
+	}
+
 	err = session.Commit()
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	} else {
-		if p.B4DeleteFlag == 0 {
-			t.Error(errors.New("B4DeleteFlag not set"))
-		}
-		if p.AfterDeletedFlag == 0 {
-			t.Error(errors.New("AfterDeletedFlag not set"))
-		}
-		if p.AfterInsertedFlag != 0 {
-			t.Error(errors.New("AfterInsertedFlag set"))
-		}
-		if p.AfterUpdatedFlag != 0 {
-			t.Error(errors.New("AfterUpdatedFlag set"))
-		}
+	assert.NoError(t, err)
+
+	if p.B4DeleteFlag == 0 {
+		t.Error(errors.New("B4DeleteFlag not set"))
+	}
+	if p.AfterDeletedFlag == 0 {
+		t.Error(errors.New("AfterDeletedFlag not set"))
+	}
+	if p.AfterInsertedFlag != 0 {
+		t.Error(errors.New("AfterInsertedFlag set"))
+	}
+	if p.AfterUpdatedFlag != 0 {
+		t.Error(errors.New("AfterUpdatedFlag set"))
 	}
 	session.Close()
 	// --
diff --git a/session_delete_test.go b/session_delete_test.go
index 916dab46..66032afe 100644
--- a/session_delete_test.go
+++ b/session_delete_test.go
@@ -8,6 +8,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/go-xorm/core"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -21,11 +22,27 @@ func TestDelete(t *testing.T) {
 
 	assert.NoError(t, testEngine.Sync2(new(UserinfoDelete)))
 
+	session := testEngine.NewSession()
+	defer session.Close()
+
+	var err error
+	if testEngine.Dialect().DBType() == core.MSSQL {
+		err = session.Begin()
+		assert.NoError(t, err)
+		_, err = session.Exec("SET IDENTITY_INSERT userinfo_delete ON")
+		assert.NoError(t, err)
+	}
+
 	user := UserinfoDelete{Uid: 1}
-	cnt, err := testEngine.Insert(&user)
+	cnt, err := session.Insert(&user)
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
+	if testEngine.Dialect().DBType() == core.MSSQL {
+		err = session.Commit()
+		assert.NoError(t, err)
+	}
+
 	cnt, err = testEngine.Delete(&UserinfoDelete{Uid: user.Uid})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
@@ -40,7 +57,7 @@ func TestDelete(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
-	cnt, err = testEngine.Where("id=?", user.Uid).Delete(&UserinfoDelete{})
+	cnt, err = testEngine.Where("`id`=?", user.Uid).Delete(&UserinfoDelete{})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
 
diff --git a/session_exist.go b/session_exist.go
index df205d33..5d3969f9 100644
--- a/session_exist.go
+++ b/session_exist.go
@@ -41,14 +41,14 @@ func (session *Session) Exist(bean ...interface{}) (bool, error) {
 				}
 
 				if session.engine.dialect.DBType() == core.MSSQL {
-					sqlStr = fmt.Sprintf("SELECT top 1 * FROM %s WHERE %s", tableName, condSQL)
+					sqlStr = fmt.Sprintf("SELECT TOP 1 * FROM %s WHERE %s", tableName, condSQL)
 				} else {
 					sqlStr = fmt.Sprintf("SELECT * FROM %s WHERE %s LIMIT 1", tableName, condSQL)
 				}
 				args = condArgs
 			} else {
 				if session.engine.dialect.DBType() == core.MSSQL {
-					sqlStr = fmt.Sprintf("SELECT top 1 * FROM %s", tableName)
+					sqlStr = fmt.Sprintf("SELECT TOP 1 * FROM %s", tableName)
 				} else {
 					sqlStr = fmt.Sprintf("SELECT * FROM %s LIMIT 1", tableName)
 				}
diff --git a/session_get_test.go b/session_get_test.go
index 68bf8e68..025a747a 100644
--- a/session_get_test.go
+++ b/session_get_test.go
@@ -84,7 +84,11 @@ func TestGetVar(t *testing.T) {
 	assert.Equal(t, "1.5", fmt.Sprintf("%.1f", money))
 
 	var money2 float64
-	has, err = testEngine.SQL("SELECT money FROM " + testEngine.TableName("get_var", true) + " LIMIT 1").Get(&money2)
+	if testEngine.Dialect().DBType() == core.MSSQL {
+		has, err = testEngine.SQL("SELECT TOP 1 money FROM " + testEngine.TableName("get_var", true)).Get(&money2)
+	} else {
+		has, err = testEngine.SQL("SELECT money FROM " + testEngine.TableName("get_var", true) + " LIMIT 1").Get(&money2)
+	}
 	assert.NoError(t, err)
 	assert.Equal(t, true, has)
 	assert.Equal(t, "1.5", fmt.Sprintf("%.1f", money2))
@@ -156,14 +160,23 @@ func TestGetStruct(t *testing.T) {
 
 	assert.NoError(t, testEngine.Sync2(new(UserinfoGet)))
 
+	session := testEngine.NewSession()
+	defer session.Close()
+
 	var err error
 	if testEngine.Dialect().DBType() == core.MSSQL {
-		_, err = testEngine.Exec("SET IDENTITY_INSERT userinfo_get ON")
+		err = session.Begin()
+		assert.NoError(t, err)
+		_, err = session.Exec("SET IDENTITY_INSERT userinfo_get ON")
 		assert.NoError(t, err)
 	}
-	cnt, err := testEngine.Insert(&UserinfoGet{Uid: 2})
+	cnt, err := session.Insert(&UserinfoGet{Uid: 2})
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, cnt)
+	if testEngine.Dialect().DBType() == core.MSSQL {
+		err = session.Commit()
+		assert.NoError(t, err)
+	}
 
 	user := UserinfoGet{Uid: 2}
 	has, err := testEngine.Get(&user)
diff --git a/session_insert.go b/session_insert.go
index 7d5999e0..aa2a432b 100644
--- a/session_insert.go
+++ b/session_insert.go
@@ -373,21 +373,30 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 
 	var sqlStr string
 	var tableName = session.statement.TableName()
+	var output string
+	if session.engine.dialect.DBType() == core.MSSQL && len(table.AutoIncrement) > 0 {
+		output = fmt.Sprintf(" OUTPUT Inserted.%s", table.AutoIncrement)
+	}
 	if len(colPlaces) > 0 {
-		sqlStr = fmt.Sprintf("INSERT INTO %s (%v%v%v) VALUES (%v)",
+		sqlStr = fmt.Sprintf("INSERT INTO %s (%v%v%v)%s VALUES (%v)",
 			session.engine.Quote(tableName),
 			session.engine.QuoteStr(),
 			strings.Join(colNames, session.engine.Quote(", ")),
 			session.engine.QuoteStr(),
+			output,
 			colPlaces)
 	} else {
 		if session.engine.dialect.DBType() == core.MYSQL {
 			sqlStr = fmt.Sprintf("INSERT INTO %s VALUES ()", session.engine.Quote(tableName))
 		} else {
-			sqlStr = fmt.Sprintf("INSERT INTO %s DEFAULT VALUES", session.engine.Quote(tableName))
+			sqlStr = fmt.Sprintf("INSERT INTO %s%s DEFAULT VALUES", session.engine.Quote(tableName), output)
 		}
 	}
 
+	if len(table.AutoIncrement) > 0 && session.engine.dialect.DBType() == core.POSTGRES {
+		sqlStr = sqlStr + " RETURNING " + session.engine.Quote(table.AutoIncrement)
+	}
+
 	handleAfterInsertProcessorFunc := func(bean interface{}) {
 		if session.isAutoCommit {
 			for _, closure := range session.afterClosures {
@@ -459,9 +468,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		aiValue.Set(int64ToIntValue(id, aiValue.Type()))
 
 		return 1, nil
-	} else if session.engine.dialect.DBType() == core.POSTGRES && len(table.AutoIncrement) > 0 {
-		//assert table.AutoIncrement != ""
-		sqlStr = sqlStr + " RETURNING " + session.engine.Quote(table.AutoIncrement)
+	} else if len(table.AutoIncrement) > 0 && (session.engine.dialect.DBType() == core.POSTGRES || session.engine.dialect.DBType() == core.MSSQL) {
 		res, err := session.queryBytes(sqlStr, args...)
 
 		if err != nil {
@@ -481,7 +488,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		}
 
 		if len(res) < 1 {
-			return 0, errors.New("insert no error but not returned id")
+			return 0, errors.New("insert successfully but not returned id")
 		}
 
 		idByte := res[0][table.AutoIncrement]
diff --git a/session_insert_test.go b/session_insert_test.go
index 2027fbb7..8e7ffa99 100644
--- a/session_insert_test.go
+++ b/session_insert_test.go
@@ -145,41 +145,22 @@ func TestInsert(t *testing.T) {
 	user := Userinfo{0, "xiaolunwen", "dev", "lunny", time.Now(),
 		Userdetail{Id: 1}, 1.78, []byte{1, 2, 3}, true}
 	cnt, err := testEngine.Insert(&user)
-	fmt.Println(user.Uid)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
-	if cnt != 1 {
-		err = errors.New("insert not returned 1")
-		t.Error(err)
-		panic(err)
-	}
-
-	if user.Uid <= 0 {
-		err = errors.New("not return id error")
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
+	assert.EqualValues(t, 1, cnt, "insert not returned 1")
+	assert.True(t, user.Uid > 0, "not return id error")
 
 	user.Uid = 0
 	cnt, err = testEngine.Insert(&user)
+	// Username is unique, so this should return error
+	assert.Error(t, err, "insert should fail but no error returned")
+	assert.EqualValues(t, 0, cnt, "insert not returned 1")
 	if err == nil {
-		err = errors.New("insert failed but no return error")
-		t.Error(err)
-		panic(err)
-	}
-	if cnt != 0 {
-		err = errors.New("insert not returned 1")
-		t.Error(err)
-		panic(err)
-		return
+		panic("should return err")
 	}
 }
 
 func TestInsertAutoIncr(t *testing.T) {
 	assert.NoError(t, prepareEngine())
-
 	assertSync(t, new(Userinfo))
 
 	// auto increment insert
@@ -214,20 +195,14 @@ func TestInsertDefault(t *testing.T) {
 
 	di := new(DefaultInsert)
 	err := testEngine.Sync2(di)
-	if err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, err)
 
 	var di2 = DefaultInsert{Name: "test"}
 	_, err = testEngine.Omit(testEngine.GetColumnMapper().Obj2Table("Status")).Insert(&di2)
-	if err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, err)
 
 	has, err := testEngine.Desc("(id)").Get(di)
-	if err != nil {
-		t.Error(err)
-	}
+	assert.NoError(t, err)
 	if !has {
 		err = errors.New("error with no data")
 		t.Error(err)
diff --git a/session_query_test.go b/session_query_test.go
index b644b74e..233929af 100644
--- a/session_query_test.go
+++ b/session_query_test.go
@@ -207,7 +207,7 @@ func TestQueryStringNoParam(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
 	assert.EqualValues(t, "1", records[0]["id"])
-	if testEngine.Dialect().URI().DbType == core.POSTGRES {
+	if testEngine.Dialect().DBType() == core.POSTGRES || testEngine.Dialect().DBType() == core.MSSQL {
 		assert.EqualValues(t, "false", records[0]["msg"])
 	} else {
 		assert.EqualValues(t, "0", records[0]["msg"])
@@ -217,7 +217,7 @@ func TestQueryStringNoParam(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
 	assert.EqualValues(t, "1", records[0]["id"])
-	if testEngine.Dialect().URI().DbType == core.POSTGRES {
+	if testEngine.Dialect().DBType() == core.POSTGRES || testEngine.Dialect().DBType() == core.MSSQL {
 		assert.EqualValues(t, "false", records[0]["msg"])
 	} else {
 		assert.EqualValues(t, "0", records[0]["msg"])
@@ -244,7 +244,7 @@ func TestQuerySliceStringNoParam(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
 	assert.EqualValues(t, "1", records[0][0])
-	if testEngine.Dialect().URI().DbType == core.POSTGRES {
+	if testEngine.Dialect().DBType() == core.POSTGRES || testEngine.Dialect().DBType() == core.MSSQL {
 		assert.EqualValues(t, "false", records[0][1])
 	} else {
 		assert.EqualValues(t, "0", records[0][1])
@@ -254,7 +254,7 @@ func TestQuerySliceStringNoParam(t *testing.T) {
 	assert.NoError(t, err)
 	assert.EqualValues(t, 1, len(records))
 	assert.EqualValues(t, "1", records[0][0])
-	if testEngine.Dialect().URI().DbType == core.POSTGRES {
+	if testEngine.Dialect().DBType() == core.POSTGRES || testEngine.Dialect().DBType() == core.MSSQL {
 		assert.EqualValues(t, "false", records[0][1])
 	} else {
 		assert.EqualValues(t, "0", records[0][1])
diff --git a/statement.go b/statement.go
index cd59c376..03ac107a 100644
--- a/statement.go
+++ b/statement.go
@@ -1089,7 +1089,7 @@ func (statement *Statement) genSelectSQL(columnStr, condSQL string, needLimit, n
 
 	if dialect.DBType() == core.MSSQL {
 		if statement.LimitN > 0 {
-			top = fmt.Sprintf(" TOP %d ", statement.LimitN)
+			top = fmt.Sprintf("TOP %d ", statement.LimitN)
 		}
 		if statement.Start > 0 {
 			var column string
diff --git a/tag_extends_test.go b/tag_extends_test.go
index 4a4150ba..aec30da9 100644
--- a/tag_extends_test.go
+++ b/tag_extends_test.go
@@ -60,63 +60,37 @@ func TestExtends(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(&tempUser2{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	err = testEngine.CreateTables(&tempUser2{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	tu := &tempUser2{tempUser{0, "extends"}, "dev depart"}
 	_, err = testEngine.Insert(tu)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	tu2 := &tempUser2{}
 	_, err = testEngine.Get(tu2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	tu3 := &tempUser2{tempUser{0, "extends update"}, ""}
 	_, err = testEngine.ID(tu2.TempUser.Id).Update(tu3)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	err = testEngine.DropTables(&tempUser4{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	err = testEngine.CreateTables(&tempUser4{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	tu8 := &tempUser4{tempUser2{tempUser{0, "extends"}, "dev depart"}}
 	_, err = testEngine.Insert(tu8)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	tu9 := &tempUser4{}
 	_, err = testEngine.Get(tu9)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
+
 	if tu9.TempUser2.TempUser.Username != tu8.TempUser2.TempUser.Username || tu9.TempUser2.Departname != tu8.TempUser2.Departname {
 		err = errors.New(fmt.Sprintln("not equal for", tu8, tu9))
 		t.Error(err)
@@ -125,36 +99,22 @@ func TestExtends(t *testing.T) {
 
 	tu10 := &tempUser4{tempUser2{tempUser{0, "extends update"}, ""}}
 	_, err = testEngine.ID(tu9.TempUser2.TempUser.Id).Update(tu10)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	err = testEngine.DropTables(&tempUser3{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	err = testEngine.CreateTables(&tempUser3{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	tu4 := &tempUser3{&tempUser{0, "extends"}, "dev depart"}
 	_, err = testEngine.Insert(tu4)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	tu5 := &tempUser3{}
 	_, err = testEngine.Get(tu5)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
+
 	if tu5.Temp == nil {
 		err = errors.New("error get data extends")
 		t.Error(err)
@@ -169,22 +129,12 @@ func TestExtends(t *testing.T) {
 
 	tu6 := &tempUser3{&tempUser{0, "extends update"}, ""}
 	_, err = testEngine.ID(tu5.Temp.Id).Update(tu6)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	users := make([]tempUser3, 0)
 	err = testEngine.Find(&users)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
-	if len(users) != 1 {
-		err = errors.New("error get data not 1")
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
+	assert.EqualValues(t, 1, len(users), "error get data not 1")
 
 	assertSync(t, new(Userinfo), new(Userdetail))
 
@@ -249,10 +199,7 @@ func TestExtends(t *testing.T) {
 		Join("LEFT", qt(ud), qt(ui)+"."+qt("detail_id")+" = "+qt(ud)+"."+qt(uiid)).
 		NoCascade().
 		Find(&infos2)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 	fmt.Println(infos2)
 }
 
@@ -297,25 +244,16 @@ func TestExtends2(t *testing.T) {
 	assert.NoError(t, prepareEngine())
 
 	err := testEngine.DropTables(&Message{}, &MessageUser{}, &MessageType{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	err = testEngine.CreateTables(&Message{}, &MessageUser{}, &MessageType{})
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	var sender = MessageUser{Name: "sender"}
 	var receiver = MessageUser{Name: "receiver"}
 	var msgtype = MessageType{Name: "type"}
 	_, err = testEngine.Insert(&sender, &receiver, &msgtype)
-	if err != nil {
-		t.Error(err)
-		panic(err)
-	}
+	assert.NoError(t, err)
 
 	msg := Message{
 		MessageBase: MessageBase{
@@ -326,15 +264,24 @@ func TestExtends2(t *testing.T) {
 		Uid:     sender.Id,
 		ToUid:   receiver.Id,
 	}
+
+	session := testEngine.NewSession()
+	defer session.Close()
+
+	// MSSQL deny insert identity column excep declare as below
 	if testEngine.Dialect().DBType() == core.MSSQL {
-		_, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
+		err = session.Begin()
+		assert.NoError(t, err)
+		_, err = session.Exec("SET IDENTITY_INSERT message ON")
 		assert.NoError(t, err)
 	}
+	cnt, err := session.Insert(&msg)
+	assert.NoError(t, err)
+	assert.EqualValues(t, 1, cnt)
 
-	_, err = testEngine.Insert(&msg)
-	if err != nil {
-		t.Error(err)
-		panic(err)
+	if testEngine.Dialect().DBType() == core.MSSQL {
+		err = session.Commit()
+		assert.NoError(t, err)
 	}
 
 	var mapper = testEngine.GetTableMapper().Obj2Table
@@ -344,23 +291,14 @@ func TestExtends2(t *testing.T) {
 	msgTableName := quote(testEngine.TableName(mapper("Message"), true))
 
 	list := make([]Message, 0)
-	err = testEngine.Table(msgTableName).Join("LEFT", []string{userTableName, "sender"}, "`sender`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`").
+	err = session.Table(msgTableName).Join("LEFT", []string{userTableName, "sender"}, "`sender`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`").
 		Join("LEFT", []string{userTableName, "receiver"}, "`receiver`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("ToUid")+"`").
 		Join("LEFT", []string{typeTableName, "type"}, "`type`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Id")+"`").
 		Find(&list)
 	assert.NoError(t, err)
 
-	if len(list) != 1 {
-		err = errors.New(fmt.Sprintln("should have 1 message, got", len(list)))
-		t.Error(err)
-		panic(err)
-	}
-
-	if list[0].Id != msg.Id {
-		err = errors.New(fmt.Sprintln("should message equal", list[0], msg))
-		t.Error(err)
-		panic(err)
-	}
+	assert.EqualValues(t, 1, len(list), fmt.Sprintln("should have 1 message, got", len(list)))
+	assert.EqualValues(t, msg.Id, list[0].Id, fmt.Sprintln("should message equal", list[0], msg))
 }
 
 func TestExtends3(t *testing.T) {
@@ -396,13 +334,25 @@ func TestExtends3(t *testing.T) {
 		Uid:     sender.Id,
 		ToUid:   receiver.Id,
 	}
+
+	session := testEngine.NewSession()
+	defer session.Close()
+
+	// MSSQL deny insert identity column excep declare as below
 	if testEngine.Dialect().DBType() == core.MSSQL {
-		_, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
+		err = session.Begin()
+		assert.NoError(t, err)
+		_, err = session.Exec("SET IDENTITY_INSERT message ON")
 		assert.NoError(t, err)
 	}
-	_, err = testEngine.Insert(&msg)
+	_, err = session.Insert(&msg)
 	assert.NoError(t, err)
 
+	if testEngine.Dialect().DBType() == core.MSSQL {
+		err = session.Commit()
+		assert.NoError(t, err)
+	}
+
 	var mapper = testEngine.GetTableMapper().Obj2Table
 	var quote = testEngine.Quote
 	userTableName := quote(testEngine.TableName(mapper("MessageUser"), true))
@@ -410,7 +360,7 @@ func TestExtends3(t *testing.T) {
 	msgTableName := quote(testEngine.TableName(mapper("Message"), true))
 
 	list := make([]MessageExtend3, 0)
-	err = testEngine.Table(msgTableName).Join("LEFT", []string{userTableName, "sender"}, "`sender`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`").
+	err = session.Table(msgTableName).Join("LEFT", []string{userTableName, "sender"}, "`sender`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`").
 		Join("LEFT", []string{userTableName, "receiver"}, "`receiver`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("ToUid")+"`").
 		Join("LEFT", []string{typeTableName, "type"}, "`type`.`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Id")+"`").
 		Find(&list)
@@ -478,14 +428,23 @@ func TestExtends4(t *testing.T) {
 		Content: "test",
 		Uid:     sender.Id,
 	}
+
+	session := testEngine.NewSession()
+	defer session.Close()
+
+	// MSSQL deny insert identity column excep declare as below
 	if testEngine.Dialect().DBType() == core.MSSQL {
-		_, err = testEngine.Exec("SET IDENTITY_INSERT message ON")
+		err = session.Begin()
+		assert.NoError(t, err)
+		_, err = session.Exec("SET IDENTITY_INSERT message ON")
 		assert.NoError(t, err)
 	}
-	_, err = testEngine.Insert(&msg)
-	if err != nil {
-		t.Error(err)
-		panic(err)
+	_, err = session.Insert(&msg)
+	assert.NoError(t, err)
+
+	if testEngine.Dialect().DBType() == core.MSSQL {
+		err = session.Commit()
+		assert.NoError(t, err)
 	}
 
 	var mapper = testEngine.GetTableMapper().Obj2Table
@@ -495,7 +454,7 @@ func TestExtends4(t *testing.T) {
 	msgTableName := quote(testEngine.TableName(mapper("Message"), true))
 
 	list := make([]MessageExtend4, 0)
-	err = testEngine.Table(msgTableName).Join("LEFT", userTableName, userTableName+".`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`").
+	err = session.Table(msgTableName).Join("LEFT", userTableName, userTableName+".`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Uid")+"`").
 		Join("LEFT", typeTableName, typeTableName+".`"+mapper("Id")+"`="+msgTableName+".`"+mapper("Id")+"`").
 		Find(&list)
 	if err != nil {
diff --git a/test_mssql.sh b/test_mssql.sh
index 6f9cf729..7f060cff 100755
--- a/test_mssql.sh
+++ b/test_mssql.sh
@@ -1 +1 @@
-go test -db=mssql -conn_str="server=192.168.1.58;user id=sa;password=123456;database=xorm_test"
\ No newline at end of file
+go test -db=mssql -conn_str="server=localhost;user id=sa;password=yourStrong(!)Password;database=xorm_test"
\ No newline at end of file
diff --git a/types_test.go b/types_test.go
index 20511407..b863671d 100644
--- a/types_test.go
+++ b/types_test.go
@@ -309,16 +309,24 @@ func TestCustomType2(t *testing.T) {
 	_, err = testEngine.Exec("delete from " + testEngine.Quote(tableName))
 	assert.NoError(t, err)
 
+	session := testEngine.NewSession()
+	defer session.Close()
+
 	if testEngine.Dialect().DBType() == core.MSSQL {
-		return
-		/*_, err = engine.Exec("set IDENTITY_INSERT " + tableName + " on")
-		if err != nil {
-			t.Fatal(err)
-		}*/
+		err = session.Begin()
+		assert.NoError(t, err)
+		_, err = session.Exec("set IDENTITY_INSERT " + tableName + " on")
+		assert.NoError(t, err)
 	}
 
-	_, err = testEngine.Insert(&UserCus{1, "xlw", Registed})
+	cnt, err := session.Insert(&UserCus{1, "xlw", Registed})
 	assert.NoError(t, err)
+	assert.EqualValues(t, 1, cnt)
+
+	if testEngine.Dialect().DBType() == core.MSSQL {
+		err = session.Commit()
+		assert.NoError(t, err)
+	}
 
 	user := UserCus{}
 	exist, err := testEngine.ID(1).Get(&user)