Groonga - fulltext search engine.

[Groonga-commit] groonga/grngo at 43040a1 [master] Add missing tests and benchmarks.

susumu.yata null+****@clear*****
Thu Jul 2 16:52:08 JST 2015

• Previous message: [Groonga-commit] groonga/grngo at fdb1812 [master] Add defer.
• Next message: [Groonga-commit] groonga/groonga at 3aaf0f0 [master] mrb: add NULL check
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

susumu.yata	2015-07-02 16:52:08 +0900 (Thu, 02 Jul 2015)

  New Revision: 43040a1b3e9e14c49ecabf4cc5e5579ea9a41b1c
  https://github.com/groonga/grngo/commit/43040a1b3e9e14c49ecabf4cc5e5579ea9a41b1c

  Message:
    Add missing tests and benchmarks.

  Modified files:
    grngo_test.go

  Modified: grngo_test.go (+348 -12)
===================================================================
--- grngo_test.go    2015-07-02 16:42:33 +0900 (465e232)
+++ grngo_test.go    2015-07-02 16:52:08 +0900 (1722e23)
@@ -362,10 +362,38 @@ func TestDBCreateTableWithBoolValue(t *testing.T) {
 	testDBCreateTableWithValue(t, "Bool")
 }
 
-func TestDBCreateTableWithIntValue(t *testing.T) {
+func TestDBCreateTableWithInt8Value(t *testing.T) {
+	testDBCreateTableWithValue(t, "Int8")
+}
+
+func TestDBCreateTableWithInt16Value(t *testing.T) {
+	testDBCreateTableWithValue(t, "Int16")
+}
+
+func TestDBCreateTableWithInt32Value(t *testing.T) {
+	testDBCreateTableWithValue(t, "Int32")
+}
+
+func TestDBCreateTableWithInt64Value(t *testing.T) {
 	testDBCreateTableWithValue(t, "Int64")
 }
 
+func TestDBCreateTableWithUInt8Value(t *testing.T) {
+	testDBCreateTableWithValue(t, "UInt8")
+}
+
+func TestDBCreateTableWithUInt16Value(t *testing.T) {
+	testDBCreateTableWithValue(t, "UInt16")
+}
+
+func TestDBCreateTableWithUInt32Value(t *testing.T) {
+	testDBCreateTableWithValue(t, "UInt32")
+}
+
+func TestDBCreateTableWithUInt64Value(t *testing.T) {
+	testDBCreateTableWithValue(t, "UInt64")
+}
+
 func TestDBCreateTableWithFloatValue(t *testing.T) {
 	testDBCreateTableWithValue(t, "Float")
 }
@@ -386,10 +414,38 @@ func TestDBCreateTableWithBoolRefKey(t *testing.T) {
 	testDBCreateTableWithRefKey(t, "Bool")
 }
 
-func TestDBCreateTableWithIntRefKey(t *testing.T) {
+func TestDBCreateTableWithInt8RefKey(t *testing.T) {
+	testDBCreateTableWithRefKey(t, "Int8")
+}
+
+func TestDBCreateTableWithInt16RefKey(t *testing.T) {
+	testDBCreateTableWithRefKey(t, "Int16")
+}
+
+func TestDBCreateTableWithInt32RefKey(t *testing.T) {
+	testDBCreateTableWithRefKey(t, "Int32")
+}
+
+func TestDBCreateTableWithInt64RefKey(t *testing.T) {
 	testDBCreateTableWithRefKey(t, "Int64")
 }
 
+func TestDBCreateTableWithUInt8RefKey(t *testing.T) {
+	testDBCreateTableWithRefKey(t, "UInt8")
+}
+
+func TestDBCreateTableWithUInt16RefKey(t *testing.T) {
+	testDBCreateTableWithRefKey(t, "UInt16")
+}
+
+func TestDBCreateTableWithUInt32RefKey(t *testing.T) {
+	testDBCreateTableWithRefKey(t, "UInt32")
+}
+
+func TestDBCreateTableWithUInt64RefKey(t *testing.T) {
+	testDBCreateTableWithRefKey(t, "UInt64")
+}
+
 func TestDBCreateTableWithFloatRefKey(t *testing.T) {
 	testDBCreateTableWithRefKey(t, "Float")
 }
@@ -414,10 +470,38 @@ func TestDBCreateTableWithBoolRefValue(t *testing.T) {
 	testDBCreateTableWithRefValue(t, "Bool")
 }
 
-func TestDBCreateTableWithIntRefValue(t *testing.T) {
+func TestDBCreateTableWithInt8RefValue(t *testing.T) {
+	testDBCreateTableWithRefValue(t, "Int8")
+}
+
+func TestDBCreateTableWithInt16RefValue(t *testing.T) {
+	testDBCreateTableWithRefValue(t, "Int16")
+}
+
+func TestDBCreateTableWithInt32RefValue(t *testing.T) {
+	testDBCreateTableWithRefValue(t, "Int32")
+}
+
+func TestDBCreateTableWithInt64RefValue(t *testing.T) {
 	testDBCreateTableWithRefValue(t, "Int64")
 }
 
+func TestDBCreateTableWithUInt8RefValue(t *testing.T) {
+	testDBCreateTableWithRefValue(t, "UInt8")
+}
+
+func TestDBCreateTableWithUInt16RefValue(t *testing.T) {
+	testDBCreateTableWithRefValue(t, "UInt16")
+}
+
+func TestDBCreateTableWithUInt32RefValue(t *testing.T) {
+	testDBCreateTableWithRefValue(t, "UInt32")
+}
+
+func TestDBCreateTableWithUInt64RefValue(t *testing.T) {
+	testDBCreateTableWithRefValue(t, "UInt64")
+}
+
 func TestDBCreateTableWithFloatRefValue(t *testing.T) {
 	testDBCreateTableWithRefValue(t, "Float")
 }
@@ -603,10 +687,38 @@ func TestTableCreateColumnForBool(t *testing.T) {
 	testTableCreateScalarColumn(t, "Bool")
 }
 
-func TestTableCreateColumnForInt(t *testing.T) {
+func TestTableCreateColumnForInt8(t *testing.T) {
+	testTableCreateScalarColumn(t, "Int8")
+}
+
+func TestTableCreateColumnForInt16(t *testing.T) {
+	testTableCreateScalarColumn(t, "Int16")
+}
+
+func TestTableCreateColumnForInt32(t *testing.T) {
+	testTableCreateScalarColumn(t, "Int32")
+}
+
+func TestTableCreateColumnForInt64(t *testing.T) {
 	testTableCreateScalarColumn(t, "Int64")
 }
 
+func TestTableCreateColumnForUInt8(t *testing.T) {
+	testTableCreateScalarColumn(t, "UInt8")
+}
+
+func TestTableCreateColumnForUInt16(t *testing.T) {
+	testTableCreateScalarColumn(t, "UInt16")
+}
+
+func TestTableCreateColumnForUInt32(t *testing.T) {
+	testTableCreateScalarColumn(t, "UInt32")
+}
+
+func TestTableCreateColumnForUInt64(t *testing.T) {
+	testTableCreateScalarColumn(t, "UInt64")
+}
+
 func TestTableCreateColumnForFloat(t *testing.T) {
 	testTableCreateScalarColumn(t, "Float")
 }
@@ -639,10 +751,38 @@ func TestTableCreateColumnForBoolVector(t *testing.T) {
 	testTableCreateVectorColumn(t, "Bool")
 }
 
-func TestTableCreateColumnForIntVector(t *testing.T) {
+func TestTableCreateColumnForInt8Vector(t *testing.T) {
+	testTableCreateVectorColumn(t, "Int8")
+}
+
+func TestTableCreateColumnForInt16Vector(t *testing.T) {
+	testTableCreateVectorColumn(t, "Int16")
+}
+
+func TestTableCreateColumnForInt32Vector(t *testing.T) {
+	testTableCreateVectorColumn(t, "Int32")
+}
+
+func TestTableCreateColumnForInt64Vector(t *testing.T) {
 	testTableCreateVectorColumn(t, "Int64")
 }
 
+func TestTableCreateColumnForUInt8Vector(t *testing.T) {
+	testTableCreateVectorColumn(t, "UInt8")
+}
+
+func TestTableCreateColumnForUInt16Vector(t *testing.T) {
+	testTableCreateVectorColumn(t, "UInt16")
+}
+
+func TestTableCreateColumnForUInt32Vector(t *testing.T) {
+	testTableCreateVectorColumn(t, "UInt32")
+}
+
+func TestTableCreateColumnForUInt64Vector(t *testing.T) {
+	testTableCreateVectorColumn(t, "UInt64")
+}
+
 func TestTableCreateColumnForFloatVector(t *testing.T) {
 	testTableCreateVectorColumn(t, "Float")
 }
@@ -675,10 +815,38 @@ func TestTableCreateColumnForRefToBool(t *testing.T) {
 	testTableCreateScalarRefColumn(t, "Bool")
 }
 
-func TestTableCreateColumnForRefToInt(t *testing.T) {
+func TestTableCreateColumnForRefToInt8(t *testing.T) {
+	testTableCreateScalarRefColumn(t, "Int8")
+}
+
+func TestTableCreateColumnForRefToInt16(t *testing.T) {
+	testTableCreateScalarRefColumn(t, "Int16")
+}
+
+func TestTableCreateColumnForRefToInt32(t *testing.T) {
+	testTableCreateScalarRefColumn(t, "Int32")
+}
+
+func TestTableCreateColumnForRefToInt64(t *testing.T) {
 	testTableCreateScalarRefColumn(t, "Int64")
 }
 
+func TestTableCreateColumnForRefToUInt8(t *testing.T) {
+	testTableCreateScalarRefColumn(t, "UInt8")
+}
+
+func TestTableCreateColumnForRefToUInt16(t *testing.T) {
+	testTableCreateScalarRefColumn(t, "UInt16")
+}
+
+func TestTableCreateColumnForRefToUInt32(t *testing.T) {
+	testTableCreateScalarRefColumn(t, "UInt32")
+}
+
+func TestTableCreateColumnForRefToUInt64(t *testing.T) {
+	testTableCreateScalarRefColumn(t, "UInt64")
+}
+
 func TestTableCreateColumnForRefToFloat(t *testing.T) {
 	testTableCreateScalarRefColumn(t, "Float")
 }
@@ -1065,10 +1233,38 @@ func BenchmarkColumnSetValueForBool(b *testing.B) {
 	benchmarkColumnSetValue(b, "Bool")
 }
 
-func BenchmarkColumnSetValueForInt(b *testing.B) {
+func BenchmarkColumnSetValueForInt8(b *testing.B) {
+	benchmarkColumnSetValue(b, "Int8")
+}
+
+func BenchmarkColumnSetValueForInt16(b *testing.B) {
+	benchmarkColumnSetValue(b, "Int16")
+}
+
+func BenchmarkColumnSetValueForInt32(b *testing.B) {
+	benchmarkColumnSetValue(b, "Int32")
+}
+
+func BenchmarkColumnSetValueForInt64(b *testing.B) {
 	benchmarkColumnSetValue(b, "Int64")
 }
 
+func BenchmarkColumnSetValueForUInt8(b *testing.B) {
+	benchmarkColumnSetValue(b, "UInt8")
+}
+
+func BenchmarkColumnSetValueForUInt16(b *testing.B) {
+	benchmarkColumnSetValue(b, "UInt16")
+}
+
+func BenchmarkColumnSetValueForUInt32(b *testing.B) {
+	benchmarkColumnSetValue(b, "UInt32")
+}
+
+func BenchmarkColumnSetValueForUInt64(b *testing.B) {
+	benchmarkColumnSetValue(b, "UInt64")
+}
+
 func BenchmarkColumnSetValueForFloat(b *testing.B) {
 	benchmarkColumnSetValue(b, "Float")
 }
@@ -1101,10 +1297,38 @@ func BenchmarkColumnSetValueForBoolVector(b *testing.B) {
 	benchmarkColumnSetValue(b, "[]Bool")
 }
 
-func BenchmarkColumnSetValueForIntVector(b *testing.B) {
+func BenchmarkColumnSetValueForInt8Vector(b *testing.B) {
+	benchmarkColumnSetValue(b, "[]Int8")
+}
+
+func BenchmarkColumnSetValueForInt16Vector(b *testing.B) {
+	benchmarkColumnSetValue(b, "[]Int16")
+}
+
+func BenchmarkColumnSetValueForInt32Vector(b *testing.B) {
+	benchmarkColumnSetValue(b, "[]Int32")
+}
+
+func BenchmarkColumnSetValueForInt64Vector(b *testing.B) {
 	benchmarkColumnSetValue(b, "[]Int64")
 }
 
+func BenchmarkColumnSetValueForUInt8Vector(b *testing.B) {
+	benchmarkColumnSetValue(b, "[]UInt8")
+}
+
+func BenchmarkColumnSetValueForUInt16Vector(b *testing.B) {
+	benchmarkColumnSetValue(b, "[]UInt16")
+}
+
+func BenchmarkColumnSetValueForUInt32Vector(b *testing.B) {
+	benchmarkColumnSetValue(b, "[]UInt32")
+}
+
+func BenchmarkColumnSetValueForUInt64Vector(b *testing.B) {
+	benchmarkColumnSetValue(b, "[]UInt64")
+}
+
 func BenchmarkColumnSetValueForFloatVector(b *testing.B) {
 	benchmarkColumnSetValue(b, "[]Float")
 }
@@ -1163,10 +1387,38 @@ func BenchmarkColumnGetValueForBool(b *testing.B) {
 	benchmarkColumnGetValue(b, "Bool")
 }
 
-func BenchmarkColumnGetValueForInt(b *testing.B) {
+func BenchmarkColumnGetValueForInt8(b *testing.B) {
+	benchmarkColumnGetValue(b, "Int8")
+}
+
+func BenchmarkColumnGetValueForInt16(b *testing.B) {
+	benchmarkColumnGetValue(b, "Int16")
+}
+
+func BenchmarkColumnGetValueForInt32(b *testing.B) {
+	benchmarkColumnGetValue(b, "Int32")
+}
+
+func BenchmarkColumnGetValueForInt64(b *testing.B) {
 	benchmarkColumnGetValue(b, "Int64")
 }
 
+func BenchmarkColumnGetValueForUInt8(b *testing.B) {
+	benchmarkColumnGetValue(b, "UInt8")
+}
+
+func BenchmarkColumnGetValueForUInt16(b *testing.B) {
+	benchmarkColumnGetValue(b, "UInt16")
+}
+
+func BenchmarkColumnGetValueForUInt32(b *testing.B) {
+	benchmarkColumnGetValue(b, "UInt32")
+}
+
+func BenchmarkColumnGetValueForUInt64(b *testing.B) {
+	benchmarkColumnGetValue(b, "UInt64")
+}
+
 func BenchmarkColumnGetValueForFloat(b *testing.B) {
 	benchmarkColumnGetValue(b, "Float")
 }
@@ -1199,10 +1451,38 @@ func BenchmarkColumnGetValueForBoolVector(b *testing.B) {
 	benchmarkColumnGetValue(b, "[]Bool")
 }
 
-func BenchmarkColumnGetValueForIntVector(b *testing.B) {
+func BenchmarkColumnGetValueForInt8Vector(b *testing.B) {
+	benchmarkColumnGetValue(b, "[]Int8")
+}
+
+func BenchmarkColumnGetValueForInt16Vector(b *testing.B) {
+	benchmarkColumnGetValue(b, "[]Int16")
+}
+
+func BenchmarkColumnGetValueForInt32Vector(b *testing.B) {
+	benchmarkColumnGetValue(b, "[]Int32")
+}
+
+func BenchmarkColumnGetValueForInt64Vector(b *testing.B) {
 	benchmarkColumnGetValue(b, "[]Int64")
 }
 
+func BenchmarkColumnGetValueForUInt8Vector(b *testing.B) {
+	benchmarkColumnGetValue(b, "[]UInt8")
+}
+
+func BenchmarkColumnGetValueForUInt16Vector(b *testing.B) {
+	benchmarkColumnGetValue(b, "[]UInt16")
+}
+
+func BenchmarkColumnGetValueForUInt32Vector(b *testing.B) {
+	benchmarkColumnGetValue(b, "[]UInt32")
+}
+
+func BenchmarkColumnGetValueForUInt64Vector(b *testing.B) {
+	benchmarkColumnGetValue(b, "[]UInt64")
+}
+
 func BenchmarkColumnGetValueForFloatVector(b *testing.B) {
 	benchmarkColumnGetValue(b, "[]Float")
 }
@@ -1260,10 +1540,38 @@ func BenchmarkDBSelectForBool(b *testing.B) {
 	benchmarkDBSelect(b, "Bool")
 }
 
-func BenchmarkDBSelectForInt(b *testing.B) {
+func BenchmarkDBSelectForInt8(b *testing.B) {
+	benchmarkDBSelect(b, "Int8")
+}
+
+func BenchmarkDBSelectForInt16(b *testing.B) {
+	benchmarkDBSelect(b, "Int16")
+}
+
+func BenchmarkDBSelectForInt32(b *testing.B) {
+	benchmarkDBSelect(b, "Int32")
+}
+
+func BenchmarkDBSelectForInt64(b *testing.B) {
 	benchmarkDBSelect(b, "Int64")
 }
 
+func BenchmarkDBSelectForUInt8(b *testing.B) {
+	benchmarkDBSelect(b, "UInt8")
+}
+
+func BenchmarkDBSelectForUInt16(b *testing.B) {
+	benchmarkDBSelect(b, "UInt16")
+}
+
+func BenchmarkDBSelectForUInt32(b *testing.B) {
+	benchmarkDBSelect(b, "UInt32")
+}
+
+func BenchmarkDBSelectForUInt64(b *testing.B) {
+	benchmarkDBSelect(b, "UInt64")
+}
+
 func BenchmarkDBSelectForFloat(b *testing.B) {
 	benchmarkDBSelect(b, "Float")
 }
@@ -1296,10 +1604,38 @@ func BenchmarkDBSelectForBoolVector(b *testing.B) {
 	benchmarkDBSelect(b, "[]Bool")
 }
 
-func BenchmarkDBSelectForIntVector(b *testing.B) {
+func BenchmarkDBSelectForInt8Vector(b *testing.B) {
+	benchmarkDBSelect(b, "[]Int8")
+}
+
+func BenchmarkDBSelectForInt16Vector(b *testing.B) {
+	benchmarkDBSelect(b, "[]Int16")
+}
+
+func BenchmarkDBSelectForInt32Vector(b *testing.B) {
+	benchmarkDBSelect(b, "[]Int32")
+}
+
+func BenchmarkDBSelectForInt64Vector(b *testing.B) {
 	benchmarkDBSelect(b, "[]Int64")
 }
 
+func BenchmarkDBSelectForUInt8Vector(b *testing.B) {
+	benchmarkDBSelect(b, "[]UInt8")
+}
+
+func BenchmarkDBSelectForUInt16Vector(b *testing.B) {
+	benchmarkDBSelect(b, "[]UInt16")
+}
+
+func BenchmarkDBSelectForUInt32Vector(b *testing.B) {
+	benchmarkDBSelect(b, "[]UInt32")
+}
+
+func BenchmarkDBSelectForUInt64Vector(b *testing.B) {
+	benchmarkDBSelect(b, "[]UInt64")
+}
+
 func BenchmarkDBSelectForFloatVector(b *testing.B) {
 	benchmarkDBSelect(b, "[]Float")
 }
-------------- next part --------------
HTML����������������������������...
下載 

• Previous message: [Groonga-commit] groonga/grngo at fdb1812 [master] Add defer.
• Next message: [Groonga-commit] groonga/groonga at 3aaf0f0 [master] mrb: add NULL check
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]