You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by cc...@apache.org on 2016/03/17 02:09:35 UTC
[45/52] [abbrv] [partial] incubator-mynewt-newt git commit: Replace
godeps _workspace with new go vendor dir.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go
deleted file mode 100644
index 44ec640..0000000
--- a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test.go
+++ /dev/null
@@ -1,1350 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <ma...@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package sqlite3
-
-import (
- "database/sql"
- "database/sql/driver"
- "errors"
- "fmt"
- "io/ioutil"
- "net/url"
- "os"
- "reflect"
- "regexp"
- "strings"
- "sync"
- "testing"
- "time"
-
- "github.com/mattn/go-sqlite3/sqlite3_test"
-)
-
-func TempFilename(t *testing.T) string {
- f, err := ioutil.TempFile("", "go-sqlite3-test-")
- if err != nil {
- t.Fatal(err)
- }
- f.Close()
- return f.Name()
-}
-
-func doTestOpen(t *testing.T, option string) (string, error) {
- var url string
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- if option != "" {
- url = tempFilename + option
- } else {
- url = tempFilename
- }
- db, err := sql.Open("sqlite3", url)
- if err != nil {
- return "Failed to open database:", err
- }
- defer os.Remove(tempFilename)
- defer db.Close()
-
- _, err = db.Exec("drop table foo")
- _, err = db.Exec("create table foo (id integer)")
- if err != nil {
- return "Failed to create table:", err
- }
-
- if stat, err := os.Stat(tempFilename); err != nil || stat.IsDir() {
- return "Failed to create ./foo.db", nil
- }
-
- return "", nil
-}
-
-func TestOpen(t *testing.T) {
- cases := map[string]bool{
- "": true,
- "?_txlock=immediate": true,
- "?_txlock=deferred": true,
- "?_txlock=exclusive": true,
- "?_txlock=bogus": false,
- }
- for option, expectedPass := range cases {
- result, err := doTestOpen(t, option)
- if result == "" {
- if !expectedPass {
- errmsg := fmt.Sprintf("_txlock error not caught at dbOpen with option: %s", option)
- t.Fatal(errmsg)
- }
- } else if expectedPass {
- if err == nil {
- t.Fatal(result)
- } else {
- t.Fatal(result, err)
- }
- }
- }
-}
-
-func TestReadonly(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
-
- db1, err := sql.Open("sqlite3", "file:"+tempFilename)
- if err != nil {
- t.Fatal(err)
- }
- db1.Exec("CREATE TABLE test (x int, y float)")
-
- db2, err := sql.Open("sqlite3", "file:"+tempFilename+"?mode=ro")
- if err != nil {
- t.Fatal(err)
- }
- _ = db2
- _, err = db2.Exec("INSERT INTO test VALUES (1, 3.14)")
- if err == nil {
- t.Fatal("didn't expect INSERT into read-only database to work")
- }
-}
-
-func TestClose(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
-
- _, err = db.Exec("drop table foo")
- _, err = db.Exec("create table foo (id integer)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- stmt, err := db.Prepare("select id from foo where id = ?")
- if err != nil {
- t.Fatal("Failed to select records:", err)
- }
-
- db.Close()
- _, err = stmt.Exec(1)
- if err == nil {
- t.Fatal("Failed to operate closed statement")
- }
-}
-
-func TestInsert(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("drop table foo")
- _, err = db.Exec("create table foo (id integer)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- res, err := db.Exec("insert into foo(id) values(123)")
- if err != nil {
- t.Fatal("Failed to insert record:", err)
- }
- affected, _ := res.RowsAffected()
- if affected != 1 {
- t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
- }
-
- rows, err := db.Query("select id from foo")
- if err != nil {
- t.Fatal("Failed to select records:", err)
- }
- defer rows.Close()
-
- rows.Next()
-
- var result int
- rows.Scan(&result)
- if result != 123 {
- t.Errorf("Expected %d for fetched result, but %d:", 123, result)
- }
-}
-
-func TestUpdate(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("drop table foo")
- _, err = db.Exec("create table foo (id integer)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- res, err := db.Exec("insert into foo(id) values(123)")
- if err != nil {
- t.Fatal("Failed to insert record:", err)
- }
- expected, err := res.LastInsertId()
- if err != nil {
- t.Fatal("Failed to get LastInsertId:", err)
- }
- affected, _ := res.RowsAffected()
- if err != nil {
- t.Fatal("Failed to get RowsAffected:", err)
- }
- if affected != 1 {
- t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
- }
-
- res, err = db.Exec("update foo set id = 234")
- if err != nil {
- t.Fatal("Failed to update record:", err)
- }
- lastId, err := res.LastInsertId()
- if err != nil {
- t.Fatal("Failed to get LastInsertId:", err)
- }
- if expected != lastId {
- t.Errorf("Expected %q for last Id, but %q:", expected, lastId)
- }
- affected, _ = res.RowsAffected()
- if err != nil {
- t.Fatal("Failed to get RowsAffected:", err)
- }
- if affected != 1 {
- t.Fatalf("Expected %d for affected rows, but %d:", 1, affected)
- }
-
- rows, err := db.Query("select id from foo")
- if err != nil {
- t.Fatal("Failed to select records:", err)
- }
- defer rows.Close()
-
- rows.Next()
-
- var result int
- rows.Scan(&result)
- if result != 234 {
- t.Errorf("Expected %d for fetched result, but %d:", 234, result)
- }
-}
-
-func TestDelete(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("drop table foo")
- _, err = db.Exec("create table foo (id integer)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- res, err := db.Exec("insert into foo(id) values(123)")
- if err != nil {
- t.Fatal("Failed to insert record:", err)
- }
- expected, err := res.LastInsertId()
- if err != nil {
- t.Fatal("Failed to get LastInsertId:", err)
- }
- affected, err := res.RowsAffected()
- if err != nil {
- t.Fatal("Failed to get RowsAffected:", err)
- }
- if affected != 1 {
- t.Errorf("Expected %d for cout of affected rows, but %q:", 1, affected)
- }
-
- res, err = db.Exec("delete from foo where id = 123")
- if err != nil {
- t.Fatal("Failed to delete record:", err)
- }
- lastId, err := res.LastInsertId()
- if err != nil {
- t.Fatal("Failed to get LastInsertId:", err)
- }
- if expected != lastId {
- t.Errorf("Expected %q for last Id, but %q:", expected, lastId)
- }
- affected, err = res.RowsAffected()
- if err != nil {
- t.Fatal("Failed to get RowsAffected:", err)
- }
- if affected != 1 {
- t.Errorf("Expected %d for cout of affected rows, but %q:", 1, affected)
- }
-
- rows, err := db.Query("select id from foo")
- if err != nil {
- t.Fatal("Failed to select records:", err)
- }
- defer rows.Close()
-
- if rows.Next() {
- t.Error("Fetched row but expected not rows")
- }
-}
-
-func TestBooleanRoundtrip(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("DROP TABLE foo")
- _, err = db.Exec("CREATE TABLE foo(id INTEGER, value BOOL)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- _, err = db.Exec("INSERT INTO foo(id, value) VALUES(1, ?)", true)
- if err != nil {
- t.Fatal("Failed to insert true value:", err)
- }
-
- _, err = db.Exec("INSERT INTO foo(id, value) VALUES(2, ?)", false)
- if err != nil {
- t.Fatal("Failed to insert false value:", err)
- }
-
- rows, err := db.Query("SELECT id, value FROM foo")
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
- defer rows.Close()
-
- for rows.Next() {
- var id int
- var value bool
-
- if err := rows.Scan(&id, &value); err != nil {
- t.Error("Unable to scan results:", err)
- continue
- }
-
- if id == 1 && !value {
- t.Error("Value for id 1 should be true, not false")
-
- } else if id == 2 && value {
- t.Error("Value for id 2 should be false, not true")
- }
- }
-}
-
-func timezone(t time.Time) string { return t.Format("-07:00") }
-
-func TestTimestamp(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("DROP TABLE foo")
- _, err = db.Exec("CREATE TABLE foo(id INTEGER, ts timeSTAMP, dt DATETIME)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- timestamp1 := time.Date(2012, time.April, 6, 22, 50, 0, 0, time.UTC)
- timestamp2 := time.Date(2006, time.January, 2, 15, 4, 5, 123456789, time.UTC)
- timestamp3 := time.Date(2012, time.November, 4, 0, 0, 0, 0, time.UTC)
- tzTest := time.FixedZone("TEST", -9*3600-13*60)
- tests := []struct {
- value interface{}
- expected time.Time
- }{
- {"nonsense", time.Time{}},
- {"0000-00-00 00:00:00", time.Time{}},
- {timestamp1, timestamp1},
- {timestamp2.Unix(), timestamp2.Truncate(time.Second)},
- {timestamp2.UnixNano() / int64(time.Millisecond), timestamp2.Truncate(time.Millisecond)},
- {timestamp1.In(tzTest), timestamp1.In(tzTest)},
- {timestamp1.Format("2006-01-02 15:04:05.000"), timestamp1},
- {timestamp1.Format("2006-01-02T15:04:05.000"), timestamp1},
- {timestamp1.Format("2006-01-02 15:04:05"), timestamp1},
- {timestamp1.Format("2006-01-02T15:04:05"), timestamp1},
- {timestamp2, timestamp2},
- {"2006-01-02 15:04:05.123456789", timestamp2},
- {"2006-01-02T15:04:05.123456789", timestamp2},
- {"2006-01-02T05:51:05.123456789-09:13", timestamp2.In(tzTest)},
- {"2012-11-04", timestamp3},
- {"2012-11-04 00:00", timestamp3},
- {"2012-11-04 00:00:00", timestamp3},
- {"2012-11-04 00:00:00.000", timestamp3},
- {"2012-11-04T00:00", timestamp3},
- {"2012-11-04T00:00:00", timestamp3},
- {"2012-11-04T00:00:00.000", timestamp3},
- {"2006-01-02T15:04:05.123456789Z", timestamp2},
- {"2012-11-04Z", timestamp3},
- {"2012-11-04 00:00Z", timestamp3},
- {"2012-11-04 00:00:00Z", timestamp3},
- {"2012-11-04 00:00:00.000Z", timestamp3},
- {"2012-11-04T00:00Z", timestamp3},
- {"2012-11-04T00:00:00Z", timestamp3},
- {"2012-11-04T00:00:00.000Z", timestamp3},
- }
- for i := range tests {
- _, err = db.Exec("INSERT INTO foo(id, ts, dt) VALUES(?, ?, ?)", i, tests[i].value, tests[i].value)
- if err != nil {
- t.Fatal("Failed to insert timestamp:", err)
- }
- }
-
- rows, err := db.Query("SELECT id, ts, dt FROM foo ORDER BY id ASC")
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
- defer rows.Close()
-
- seen := 0
- for rows.Next() {
- var id int
- var ts, dt time.Time
-
- if err := rows.Scan(&id, &ts, &dt); err != nil {
- t.Error("Unable to scan results:", err)
- continue
- }
- if id < 0 || id >= len(tests) {
- t.Error("Bad row id: ", id)
- continue
- }
- seen++
- if !tests[id].expected.Equal(ts) {
- t.Errorf("Timestamp value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
- }
- if !tests[id].expected.Equal(dt) {
- t.Errorf("Datetime value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
- }
- if timezone(tests[id].expected) != timezone(ts) {
- t.Errorf("Timezone for id %v (%v) should be %v, not %v", id, tests[id].value,
- timezone(tests[id].expected), timezone(ts))
- }
- if timezone(tests[id].expected) != timezone(dt) {
- t.Errorf("Timezone for id %v (%v) should be %v, not %v", id, tests[id].value,
- timezone(tests[id].expected), timezone(dt))
- }
- }
-
- if seen != len(tests) {
- t.Errorf("Expected to see %d rows", len(tests))
- }
-}
-
-func TestBoolean(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
-
- defer db.Close()
-
- _, err = db.Exec("CREATE TABLE foo(id INTEGER, fbool BOOLEAN)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- bool1 := true
- _, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(1, ?)", bool1)
- if err != nil {
- t.Fatal("Failed to insert boolean:", err)
- }
-
- bool2 := false
- _, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(2, ?)", bool2)
- if err != nil {
- t.Fatal("Failed to insert boolean:", err)
- }
-
- bool3 := "nonsense"
- _, err = db.Exec("INSERT INTO foo(id, fbool) VALUES(3, ?)", bool3)
- if err != nil {
- t.Fatal("Failed to insert nonsense:", err)
- }
-
- rows, err := db.Query("SELECT id, fbool FROM foo where fbool = ?", bool1)
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
- counter := 0
-
- var id int
- var fbool bool
-
- for rows.Next() {
- if err := rows.Scan(&id, &fbool); err != nil {
- t.Fatal("Unable to scan results:", err)
- }
- counter++
- }
-
- if counter != 1 {
- t.Fatalf("Expected 1 row but %v", counter)
- }
-
- if id != 1 && fbool != true {
- t.Fatalf("Value for id 1 should be %v, not %v", bool1, fbool)
- }
-
- rows, err = db.Query("SELECT id, fbool FROM foo where fbool = ?", bool2)
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
-
- counter = 0
-
- for rows.Next() {
- if err := rows.Scan(&id, &fbool); err != nil {
- t.Fatal("Unable to scan results:", err)
- }
- counter++
- }
-
- if counter != 1 {
- t.Fatalf("Expected 1 row but %v", counter)
- }
-
- if id != 2 && fbool != false {
- t.Fatalf("Value for id 2 should be %v, not %v", bool2, fbool)
- }
-
- // make sure "nonsense" triggered an error
- rows, err = db.Query("SELECT id, fbool FROM foo where id=?;", 3)
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
-
- rows.Next()
- err = rows.Scan(&id, &fbool)
- if err == nil {
- t.Error("Expected error from \"nonsense\" bool")
- }
-}
-
-func TestFloat32(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("CREATE TABLE foo(id INTEGER)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- _, err = db.Exec("INSERT INTO foo(id) VALUES(null)")
- if err != nil {
- t.Fatal("Failed to insert null:", err)
- }
-
- rows, err := db.Query("SELECT id FROM foo")
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
-
- if !rows.Next() {
- t.Fatal("Unable to query results:", err)
- }
-
- var id interface{}
- if err := rows.Scan(&id); err != nil {
- t.Fatal("Unable to scan results:", err)
- }
- if id != nil {
- t.Error("Expected nil but not")
- }
-}
-
-func TestNull(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- rows, err := db.Query("SELECT 3.141592")
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
-
- if !rows.Next() {
- t.Fatal("Unable to query results:", err)
- }
-
- var v interface{}
- if err := rows.Scan(&v); err != nil {
- t.Fatal("Unable to scan results:", err)
- }
- f, ok := v.(float64)
- if !ok {
- t.Error("Expected float but not")
- }
- if f != 3.141592 {
- t.Error("Expected 3.141592 but not")
- }
-}
-
-func TestTransaction(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("CREATE TABLE foo(id INTEGER)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- tx, err := db.Begin()
- if err != nil {
- t.Fatal("Failed to begin transaction:", err)
- }
-
- _, err = tx.Exec("INSERT INTO foo(id) VALUES(1)")
- if err != nil {
- t.Fatal("Failed to insert null:", err)
- }
-
- rows, err := tx.Query("SELECT id from foo")
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
-
- err = tx.Rollback()
- if err != nil {
- t.Fatal("Failed to rollback transaction:", err)
- }
-
- if rows.Next() {
- t.Fatal("Unable to query results:", err)
- }
-
- tx, err = db.Begin()
- if err != nil {
- t.Fatal("Failed to begin transaction:", err)
- }
-
- _, err = tx.Exec("INSERT INTO foo(id) VALUES(1)")
- if err != nil {
- t.Fatal("Failed to insert null:", err)
- }
-
- err = tx.Commit()
- if err != nil {
- t.Fatal("Failed to commit transaction:", err)
- }
-
- rows, err = tx.Query("SELECT id from foo")
- if err == nil {
- t.Fatal("Expected failure to query")
- }
-}
-
-func TestWAL(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- if _, err = db.Exec("PRAGMA journal_mode=WAL;"); err != nil {
- t.Fatal("Failed to Exec PRAGMA journal_mode:", err)
- }
- if _, err = db.Exec("PRAGMA locking_mode=EXCLUSIVE;"); err != nil {
- t.Fatal("Failed to Exec PRAGMA locking_mode:", err)
- }
- if _, err = db.Exec("CREATE TABLE test (id SERIAL, user TEXT NOT NULL, name TEXT NOT NULL);"); err != nil {
- t.Fatal("Failed to Exec CREATE TABLE:", err)
- }
- if _, err = db.Exec("INSERT INTO test (user, name) VALUES ('user','name');"); err != nil {
- t.Fatal("Failed to Exec INSERT:", err)
- }
-
- trans, err := db.Begin()
- if err != nil {
- t.Fatal("Failed to Begin:", err)
- }
- s, err := trans.Prepare("INSERT INTO test (user, name) VALUES (?, ?);")
- if err != nil {
- t.Fatal("Failed to Prepare:", err)
- }
-
- var count int
- if err = trans.QueryRow("SELECT count(user) FROM test;").Scan(&count); err != nil {
- t.Fatal("Failed to QueryRow:", err)
- }
- if _, err = s.Exec("bbbb", "aaaa"); err != nil {
- t.Fatal("Failed to Exec prepared statement:", err)
- }
- if err = s.Close(); err != nil {
- t.Fatal("Failed to Close prepared statement:", err)
- }
- if err = trans.Commit(); err != nil {
- t.Fatal("Failed to Commit:", err)
- }
-}
-
-func TestTimezoneConversion(t *testing.T) {
- zones := []string{"UTC", "US/Central", "US/Pacific", "Local"}
- for _, tz := range zones {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename+"?_loc="+url.QueryEscape(tz))
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("DROP TABLE foo")
- _, err = db.Exec("CREATE TABLE foo(id INTEGER, ts TIMESTAMP, dt DATETIME)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- loc, err := time.LoadLocation(tz)
- if err != nil {
- t.Fatal("Failed to load location:", err)
- }
-
- timestamp1 := time.Date(2012, time.April, 6, 22, 50, 0, 0, time.UTC)
- timestamp2 := time.Date(2006, time.January, 2, 15, 4, 5, 123456789, time.UTC)
- timestamp3 := time.Date(2012, time.November, 4, 0, 0, 0, 0, time.UTC)
- tests := []struct {
- value interface{}
- expected time.Time
- }{
- {"nonsense", time.Time{}.In(loc)},
- {"0000-00-00 00:00:00", time.Time{}.In(loc)},
- {timestamp1, timestamp1.In(loc)},
- {timestamp1.Unix(), timestamp1.In(loc)},
- {timestamp1.In(time.FixedZone("TEST", -7*3600)), timestamp1.In(loc)},
- {timestamp1.Format("2006-01-02 15:04:05.000"), timestamp1.In(loc)},
- {timestamp1.Format("2006-01-02T15:04:05.000"), timestamp1.In(loc)},
- {timestamp1.Format("2006-01-02 15:04:05"), timestamp1.In(loc)},
- {timestamp1.Format("2006-01-02T15:04:05"), timestamp1.In(loc)},
- {timestamp2, timestamp2.In(loc)},
- {"2006-01-02 15:04:05.123456789", timestamp2.In(loc)},
- {"2006-01-02T15:04:05.123456789", timestamp2.In(loc)},
- {"2012-11-04", timestamp3.In(loc)},
- {"2012-11-04 00:00", timestamp3.In(loc)},
- {"2012-11-04 00:00:00", timestamp3.In(loc)},
- {"2012-11-04 00:00:00.000", timestamp3.In(loc)},
- {"2012-11-04T00:00", timestamp3.In(loc)},
- {"2012-11-04T00:00:00", timestamp3.In(loc)},
- {"2012-11-04T00:00:00.000", timestamp3.In(loc)},
- }
- for i := range tests {
- _, err = db.Exec("INSERT INTO foo(id, ts, dt) VALUES(?, ?, ?)", i, tests[i].value, tests[i].value)
- if err != nil {
- t.Fatal("Failed to insert timestamp:", err)
- }
- }
-
- rows, err := db.Query("SELECT id, ts, dt FROM foo ORDER BY id ASC")
- if err != nil {
- t.Fatal("Unable to query foo table:", err)
- }
- defer rows.Close()
-
- seen := 0
- for rows.Next() {
- var id int
- var ts, dt time.Time
-
- if err := rows.Scan(&id, &ts, &dt); err != nil {
- t.Error("Unable to scan results:", err)
- continue
- }
- if id < 0 || id >= len(tests) {
- t.Error("Bad row id: ", id)
- continue
- }
- seen++
- if !tests[id].expected.Equal(ts) {
- t.Errorf("Timestamp value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, ts)
- }
- if !tests[id].expected.Equal(dt) {
- t.Errorf("Datetime value for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected, dt)
- }
- if tests[id].expected.Location().String() != ts.Location().String() {
- t.Errorf("Location for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected.Location().String(), ts.Location().String())
- }
- if tests[id].expected.Location().String() != dt.Location().String() {
- t.Errorf("Location for id %v (%v) should be %v, not %v", id, tests[id].value, tests[id].expected.Location().String(), dt.Location().String())
- }
- }
-
- if seen != len(tests) {
- t.Errorf("Expected to see %d rows", len(tests))
- }
- }
-}
-
-func TestSuite(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename+"?_busy_timeout=99999")
- if err != nil {
- t.Fatal(err)
- }
- defer db.Close()
-
- sqlite3_test.RunTests(t, db, sqlite3_test.SQLITE)
-}
-
-// TODO: Execer & Queryer currently disabled
-// https://github.com/mattn/go-sqlite3/issues/82
-func TestExecer(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec(`
- create table foo (id integer); -- one comment
- insert into foo(id) values(?);
- insert into foo(id) values(?);
- insert into foo(id) values(?); -- another comment
- `, 1, 2, 3)
- if err != nil {
- t.Error("Failed to call db.Exec:", err)
- }
-}
-
-func TestQueryer(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec(`
- create table foo (id integer);
- `)
- if err != nil {
- t.Error("Failed to call db.Query:", err)
- }
-
- rows, err := db.Query(`
- insert into foo(id) values(?);
- insert into foo(id) values(?);
- insert into foo(id) values(?);
- select id from foo order by id;
- `, 3, 2, 1)
- if err != nil {
- t.Error("Failed to call db.Query:", err)
- }
- defer rows.Close()
- n := 1
- if rows != nil {
- for rows.Next() {
- var id int
- err = rows.Scan(&id)
- if err != nil {
- t.Error("Failed to db.Query:", err)
- }
- if id != n {
- t.Error("Failed to db.Query: not matched results")
- }
- }
- }
-}
-
-func TestStress(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- db.Exec("CREATE TABLE foo (id int);")
- db.Exec("INSERT INTO foo VALUES(1);")
- db.Exec("INSERT INTO foo VALUES(2);")
- db.Close()
-
- for i := 0; i < 10000; i++ {
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
-
- for j := 0; j < 3; j++ {
- rows, err := db.Query("select * from foo where id=1;")
- if err != nil {
- t.Error("Failed to call db.Query:", err)
- }
- for rows.Next() {
- var i int
- if err := rows.Scan(&i); err != nil {
- t.Errorf("Scan failed: %v\n", err)
- }
- }
- if err := rows.Err(); err != nil {
- t.Errorf("Post-scan failed: %v\n", err)
- }
- rows.Close()
- }
- db.Close()
- }
-}
-
-func TestDateTimeLocal(t *testing.T) {
- zone := "Asia/Tokyo"
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename+"?_loc="+zone)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- db.Exec("CREATE TABLE foo (dt datetime);")
- db.Exec("INSERT INTO foo VALUES('2015-03-05 15:16:17');")
-
- row := db.QueryRow("select * from foo")
- var d time.Time
- err = row.Scan(&d)
- if err != nil {
- t.Fatal("Failed to scan datetime:", err)
- }
- if d.Hour() == 15 || !strings.Contains(d.String(), "JST") {
- t.Fatal("Result should have timezone", d)
- }
- db.Close()
-
- db, err = sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
-
- row = db.QueryRow("select * from foo")
- err = row.Scan(&d)
- if err != nil {
- t.Fatal("Failed to scan datetime:", err)
- }
- if d.UTC().Hour() != 15 || !strings.Contains(d.String(), "UTC") {
- t.Fatalf("Result should not have timezone %v %v", zone, d.String())
- }
-
- _, err = db.Exec("DELETE FROM foo")
- if err != nil {
- t.Fatal("Failed to delete table:", err)
- }
- dt, err := time.Parse("2006/1/2 15/4/5 -0700 MST", "2015/3/5 15/16/17 +0900 JST")
- if err != nil {
- t.Fatal("Failed to parse datetime:", err)
- }
- db.Exec("INSERT INTO foo VALUES(?);", dt)
-
- db.Close()
- db, err = sql.Open("sqlite3", tempFilename+"?_loc="+zone)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
-
- row = db.QueryRow("select * from foo")
- err = row.Scan(&d)
- if err != nil {
- t.Fatal("Failed to scan datetime:", err)
- }
- if d.Hour() != 15 || !strings.Contains(d.String(), "JST") {
- t.Fatalf("Result should have timezone %v %v", zone, d.String())
- }
-}
-
-func TestVersion(t *testing.T) {
- s, n, id := Version()
- if s == "" || n == 0 || id == "" {
- t.Errorf("Version failed %q, %d, %q\n", s, n, id)
- }
-}
-
-func TestNumberNamedParams(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec(`
- create table foo (id integer, name text, extra text);
- `)
- if err != nil {
- t.Error("Failed to call db.Query:", err)
- }
-
- _, err = db.Exec(`insert into foo(id, name, extra) values($1, $2, $2)`, 1, "foo")
- if err != nil {
- t.Error("Failed to call db.Exec:", err)
- }
-
- row := db.QueryRow(`select id, extra from foo where id = $1 and extra = $2`, 1, "foo")
- if row == nil {
- t.Error("Failed to call db.QueryRow")
- }
- var id int
- var extra string
- err = row.Scan(&id, &extra)
- if err != nil {
- t.Error("Failed to db.Scan:", err)
- }
- if id != 1 || extra != "foo" {
- t.Error("Failed to db.QueryRow: not matched results")
- }
-}
-
-func TestStringContainingZero(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec(`
- create table foo (id integer, name, extra text);
- `)
- if err != nil {
- t.Error("Failed to call db.Query:", err)
- }
-
- const text = "foo\x00bar"
-
- _, err = db.Exec(`insert into foo(id, name, extra) values($1, $2, $2)`, 1, text)
- if err != nil {
- t.Error("Failed to call db.Exec:", err)
- }
-
- row := db.QueryRow(`select id, extra from foo where id = $1 and extra = $2`, 1, text)
- if row == nil {
- t.Error("Failed to call db.QueryRow")
- }
-
- var id int
- var extra string
- err = row.Scan(&id, &extra)
- if err != nil {
- t.Error("Failed to db.Scan:", err)
- }
- if id != 1 || extra != text {
- t.Error("Failed to db.QueryRow: not matched results")
- }
-}
-
-const CurrentTimeStamp = "2006-01-02 15:04:05"
-
-type TimeStamp struct{ *time.Time }
-
-func (t TimeStamp) Scan(value interface{}) error {
- var err error
- switch v := value.(type) {
- case string:
- *t.Time, err = time.Parse(CurrentTimeStamp, v)
- case []byte:
- *t.Time, err = time.Parse(CurrentTimeStamp, string(v))
- default:
- err = errors.New("invalid type for current_timestamp")
- }
- return err
-}
-
-func (t TimeStamp) Value() (driver.Value, error) {
- return t.Time.Format(CurrentTimeStamp), nil
-}
-
-func TestDateTimeNow(t *testing.T) {
- tempFilename := TempFilename(t)
- defer os.Remove(tempFilename)
- db, err := sql.Open("sqlite3", tempFilename)
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- var d time.Time
- err = db.QueryRow("SELECT datetime('now')").Scan(TimeStamp{&d})
- if err != nil {
- t.Fatal("Failed to scan datetime:", err)
- }
-}
-
-func TestFunctionRegistration(t *testing.T) {
- addi_8_16_32 := func(a int8, b int16) int32 { return int32(a) + int32(b) }
- addi_64 := func(a, b int64) int64 { return a + b }
- addu_8_16_32 := func(a uint8, b uint16) uint32 { return uint32(a) + uint32(b) }
- addu_64 := func(a, b uint64) uint64 { return a + b }
- addiu := func(a int, b uint) int64 { return int64(a) + int64(b) }
- addf_32_64 := func(a float32, b float64) float64 { return float64(a) + b }
- not := func(a bool) bool { return !a }
- regex := func(re, s string) (bool, error) {
- return regexp.MatchString(re, s)
- }
- generic := func(a interface{}) int64 {
- switch a.(type) {
- case int64:
- return 1
- case float64:
- return 2
- case []byte:
- return 3
- case string:
- return 4
- default:
- panic("unreachable")
- }
- }
- variadic := func(a, b int64, c ...int64) int64 {
- ret := a + b
- for _, d := range c {
- ret += d
- }
- return ret
- }
- variadicGeneric := func(a ...interface{}) int64 {
- return int64(len(a))
- }
-
- sql.Register("sqlite3_FunctionRegistration", &SQLiteDriver{
- ConnectHook: func(conn *SQLiteConn) error {
- if err := conn.RegisterFunc("addi_8_16_32", addi_8_16_32, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("addi_64", addi_64, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("addu_8_16_32", addu_8_16_32, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("addu_64", addu_64, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("addiu", addiu, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("addf_32_64", addf_32_64, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("not", not, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("regex", regex, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("generic", generic, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("variadic", variadic, true); err != nil {
- return err
- }
- if err := conn.RegisterFunc("variadicGeneric", variadicGeneric, true); err != nil {
- return err
- }
- return nil
- },
- })
- db, err := sql.Open("sqlite3_FunctionRegistration", ":memory:")
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- ops := []struct {
- query string
- expected interface{}
- }{
- {"SELECT addi_8_16_32(1,2)", int32(3)},
- {"SELECT addi_64(1,2)", int64(3)},
- {"SELECT addu_8_16_32(1,2)", uint32(3)},
- {"SELECT addu_64(1,2)", uint64(3)},
- {"SELECT addiu(1,2)", int64(3)},
- {"SELECT addf_32_64(1.5,1.5)", float64(3)},
- {"SELECT not(1)", false},
- {"SELECT not(0)", true},
- {`SELECT regex("^foo.*", "foobar")`, true},
- {`SELECT regex("^foo.*", "barfoobar")`, false},
- {"SELECT generic(1)", int64(1)},
- {"SELECT generic(1.1)", int64(2)},
- {`SELECT generic(NULL)`, int64(3)},
- {`SELECT generic("foo")`, int64(4)},
- {"SELECT variadic(1,2)", int64(3)},
- {"SELECT variadic(1,2,3,4)", int64(10)},
- {"SELECT variadic(1,1,1,1,1,1,1,1,1,1)", int64(10)},
- {`SELECT variadicGeneric(1,"foo",2.3, NULL)`, int64(4)},
- }
-
- for _, op := range ops {
- ret := reflect.New(reflect.TypeOf(op.expected))
- err = db.QueryRow(op.query).Scan(ret.Interface())
- if err != nil {
- t.Errorf("Query %q failed: %s", op.query, err)
- } else if !reflect.DeepEqual(ret.Elem().Interface(), op.expected) {
- t.Errorf("Query %q returned wrong value: got %v (%T), want %v (%T)", op.query, ret.Elem().Interface(), ret.Elem().Interface(), op.expected, op.expected)
- }
- }
-}
-
-type sumAggregator int64
-
-func (s *sumAggregator) Step(x int64) {
- *s += sumAggregator(x)
-}
-
-func (s *sumAggregator) Done() int64 {
- return int64(*s)
-}
-
-func TestAggregatorRegistration(t *testing.T) {
- customSum := func() *sumAggregator {
- var ret sumAggregator
- return &ret
- }
-
- sql.Register("sqlite3_AggregatorRegistration", &SQLiteDriver{
- ConnectHook: func(conn *SQLiteConn) error {
- if err := conn.RegisterAggregator("customSum", customSum, true); err != nil {
- return err
- }
- return nil
- },
- })
- db, err := sql.Open("sqlite3_AggregatorRegistration", ":memory:")
- if err != nil {
- t.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- _, err = db.Exec("create table foo (department integer, profits integer)")
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- _, err = db.Exec("insert into foo values (1, 10), (1, 20), (2, 42)")
- if err != nil {
- t.Fatal("Failed to insert records:", err)
- }
-
- tests := []struct {
- dept, sum int64
- }{
- {1, 30},
- {2, 42},
- }
-
- for _, test := range tests {
- var ret int64
- err = db.QueryRow("select customSum(profits) from foo where department = $1 group by department", test.dept).Scan(&ret)
- if err != nil {
- t.Fatal("Query failed:", err)
- }
- if ret != test.sum {
- t.Fatalf("Custom sum returned wrong value, got %d, want %d", ret, test.sum)
- }
- }
-}
-
-func TestDeclTypes(t *testing.T) {
-
- d := SQLiteDriver{}
-
- conn, err := d.Open(":memory:")
- if err != nil {
- t.Fatal("Failed to begin transaction:", err)
- }
- defer conn.Close()
-
- sqlite3conn := conn.(*SQLiteConn)
-
- _, err = sqlite3conn.Exec("create table foo (id integer not null primary key, name text)", nil)
- if err != nil {
- t.Fatal("Failed to create table:", err)
- }
-
- _, err = sqlite3conn.Exec("insert into foo(name) values(\"bar\")", nil)
- if err != nil {
- t.Fatal("Failed to insert:", err)
- }
-
- rs, err := sqlite3conn.Query("select * from foo", nil)
- if err != nil {
- t.Fatal("Failed to select:", err)
- }
- defer rs.Close()
-
- declTypes := rs.(*SQLiteRows).DeclTypes()
-
- if !reflect.DeepEqual(declTypes, []string{"integer", "text"}) {
- t.Fatal("Unexpected declTypes:", declTypes)
- }
-}
-
-var customFunctionOnce sync.Once
-
-func BenchmarkCustomFunctions(b *testing.B) {
- customFunctionOnce.Do(func() {
- custom_add := func(a, b int64) int64 {
- return a + b
- }
-
- sql.Register("sqlite3_BenchmarkCustomFunctions", &SQLiteDriver{
- ConnectHook: func(conn *SQLiteConn) error {
- // Impure function to force sqlite to reexecute it each time.
- if err := conn.RegisterFunc("custom_add", custom_add, false); err != nil {
- return err
- }
- return nil
- },
- })
- })
-
- db, err := sql.Open("sqlite3_BenchmarkCustomFunctions", ":memory:")
- if err != nil {
- b.Fatal("Failed to open database:", err)
- }
- defer db.Close()
-
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- var i int64
- err = db.QueryRow("SELECT custom_add(1,2)").Scan(&i)
- if err != nil {
- b.Fatal("Failed to run custom add:", err)
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test/sqltest.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test/sqltest.go b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test/sqltest.go
deleted file mode 100644
index 84b65d9..0000000
--- a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_test/sqltest.go
+++ /dev/null
@@ -1,409 +0,0 @@
-package sqlite3_test
-
-import (
- "database/sql"
- "fmt"
- "math/rand"
- "regexp"
- "strconv"
- "sync"
- "testing"
- "time"
-)
-
-type Dialect int
-
-const (
- SQLITE Dialect = iota
- POSTGRESQL
- MYSQL
-)
-
-type DB struct {
- *testing.T
- *sql.DB
- dialect Dialect
- once sync.Once
-}
-
-var db *DB
-
-// the following tables will be created and dropped during the test
-var testTables = []string{"foo", "bar", "t", "bench"}
-
-var tests = []testing.InternalTest{
- {"TestBlobs", TestBlobs},
- {"TestManyQueryRow", TestManyQueryRow},
- {"TestTxQuery", TestTxQuery},
- {"TestPreparedStmt", TestPreparedStmt},
-}
-
-var benchmarks = []testing.InternalBenchmark{
- {"BenchmarkExec", BenchmarkExec},
- {"BenchmarkQuery", BenchmarkQuery},
- {"BenchmarkParams", BenchmarkParams},
- {"BenchmarkStmt", BenchmarkStmt},
- {"BenchmarkRows", BenchmarkRows},
- {"BenchmarkStmtRows", BenchmarkStmtRows},
-}
-
-// RunTests runs the SQL test suite
-func RunTests(t *testing.T, d *sql.DB, dialect Dialect) {
- db = &DB{t, d, dialect, sync.Once{}}
- testing.RunTests(func(string, string) (bool, error) { return true, nil }, tests)
-
- if !testing.Short() {
- for _, b := range benchmarks {
- fmt.Printf("%-20s", b.Name)
- r := testing.Benchmark(b.F)
- fmt.Printf("%10d %10.0f req/s\n", r.N, float64(r.N)/r.T.Seconds())
- }
- }
- db.tearDown()
-}
-
-func (db *DB) mustExec(sql string, args ...interface{}) sql.Result {
- res, err := db.Exec(sql, args...)
- if err != nil {
- db.Fatalf("Error running %q: %v", sql, err)
- }
- return res
-}
-
-func (db *DB) tearDown() {
- for _, tbl := range testTables {
- switch db.dialect {
- case SQLITE:
- db.mustExec("drop table if exists " + tbl)
- case MYSQL, POSTGRESQL:
- db.mustExec("drop table if exists " + tbl)
- default:
- db.Fatal("unkown dialect")
- }
- }
-}
-
-// q replaces ? parameters if needed
-func (db *DB) q(sql string) string {
- switch db.dialect {
- case POSTGRESQL: // repace with $1, $2, ..
- qrx := regexp.MustCompile(`\?`)
- n := 0
- return qrx.ReplaceAllStringFunc(sql, func(string) string {
- n++
- return "$" + strconv.Itoa(n)
- })
- }
- return sql
-}
-
-func (db *DB) blobType(size int) string {
- switch db.dialect {
- case SQLITE:
- return fmt.Sprintf("blob[%d]", size)
- case POSTGRESQL:
- return "bytea"
- case MYSQL:
- return fmt.Sprintf("VARBINARY(%d)", size)
- }
- panic("unkown dialect")
-}
-
-func (db *DB) serialPK() string {
- switch db.dialect {
- case SQLITE:
- return "integer primary key autoincrement"
- case POSTGRESQL:
- return "serial primary key"
- case MYSQL:
- return "integer primary key auto_increment"
- }
- panic("unkown dialect")
-}
-
-func (db *DB) now() string {
- switch db.dialect {
- case SQLITE:
- return "datetime('now')"
- case POSTGRESQL:
- return "now()"
- case MYSQL:
- return "now()"
- }
- panic("unkown dialect")
-}
-
-func makeBench() {
- if _, err := db.Exec("create table bench (n varchar(32), i integer, d double, s varchar(32), t datetime)"); err != nil {
- panic(err)
- }
- st, err := db.Prepare("insert into bench values (?, ?, ?, ?, ?)")
- if err != nil {
- panic(err)
- }
- defer st.Close()
- for i := 0; i < 100; i++ {
- if _, err = st.Exec(nil, i, float64(i), fmt.Sprintf("%d", i), time.Now()); err != nil {
- panic(err)
- }
- }
-}
-
-func TestResult(t *testing.T) {
- db.tearDown()
- db.mustExec("create temporary table test (id " + db.serialPK() + ", name varchar(10))")
-
- for i := 1; i < 3; i++ {
- r := db.mustExec(db.q("insert into test (name) values (?)"), fmt.Sprintf("row %d", i))
- n, err := r.RowsAffected()
- if err != nil {
- t.Fatal(err)
- }
- if n != 1 {
- t.Errorf("got %v, want %v", n, 1)
- }
- n, err = r.LastInsertId()
- if err != nil {
- t.Fatal(err)
- }
- if n != int64(i) {
- t.Errorf("got %v, want %v", n, i)
- }
- }
- if _, err := db.Exec("error!"); err == nil {
- t.Fatalf("expected error")
- }
-}
-
-func TestBlobs(t *testing.T) {
- db.tearDown()
- var blob = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
- db.mustExec("create table foo (id integer primary key, bar " + db.blobType(16) + ")")
- db.mustExec(db.q("insert into foo (id, bar) values(?,?)"), 0, blob)
-
- want := fmt.Sprintf("%x", blob)
-
- b := make([]byte, 16)
- err := db.QueryRow(db.q("select bar from foo where id = ?"), 0).Scan(&b)
- got := fmt.Sprintf("%x", b)
- if err != nil {
- t.Errorf("[]byte scan: %v", err)
- } else if got != want {
- t.Errorf("for []byte, got %q; want %q", got, want)
- }
-
- err = db.QueryRow(db.q("select bar from foo where id = ?"), 0).Scan(&got)
- want = string(blob)
- if err != nil {
- t.Errorf("string scan: %v", err)
- } else if got != want {
- t.Errorf("for string, got %q; want %q", got, want)
- }
-}
-
-func TestManyQueryRow(t *testing.T) {
- if testing.Short() {
- t.Log("skipping in short mode")
- return
- }
- db.tearDown()
- db.mustExec("create table foo (id integer primary key, name varchar(50))")
- db.mustExec(db.q("insert into foo (id, name) values(?,?)"), 1, "bob")
- var name string
- for i := 0; i < 10000; i++ {
- err := db.QueryRow(db.q("select name from foo where id = ?"), 1).Scan(&name)
- if err != nil || name != "bob" {
- t.Fatalf("on query %d: err=%v, name=%q", i, err, name)
- }
- }
-}
-
-func TestTxQuery(t *testing.T) {
- db.tearDown()
- tx, err := db.Begin()
- if err != nil {
- t.Fatal(err)
- }
- defer tx.Rollback()
-
- _, err = tx.Exec("create table foo (id integer primary key, name varchar(50))")
- if err != nil {
- t.Fatal(err)
- }
-
- _, err = tx.Exec(db.q("insert into foo (id, name) values(?,?)"), 1, "bob")
- if err != nil {
- t.Fatal(err)
- }
-
- r, err := tx.Query(db.q("select name from foo where id = ?"), 1)
- if err != nil {
- t.Fatal(err)
- }
- defer r.Close()
-
- if !r.Next() {
- if r.Err() != nil {
- t.Fatal(err)
- }
- t.Fatal("expected one rows")
- }
-
- var name string
- err = r.Scan(&name)
- if err != nil {
- t.Fatal(err)
- }
-}
-
-func TestPreparedStmt(t *testing.T) {
- db.tearDown()
- db.mustExec("CREATE TABLE t (count INT)")
- sel, err := db.Prepare("SELECT count FROM t ORDER BY count DESC")
- if err != nil {
- t.Fatalf("prepare 1: %v", err)
- }
- ins, err := db.Prepare(db.q("INSERT INTO t (count) VALUES (?)"))
- if err != nil {
- t.Fatalf("prepare 2: %v", err)
- }
-
- for n := 1; n <= 3; n++ {
- if _, err := ins.Exec(n); err != nil {
- t.Fatalf("insert(%d) = %v", n, err)
- }
- }
-
- const nRuns = 10
- var wg sync.WaitGroup
- for i := 0; i < nRuns; i++ {
- wg.Add(1)
- go func() {
- defer wg.Done()
- for j := 0; j < 10; j++ {
- count := 0
- if err := sel.QueryRow().Scan(&count); err != nil && err != sql.ErrNoRows {
- t.Errorf("Query: %v", err)
- return
- }
- if _, err := ins.Exec(rand.Intn(100)); err != nil {
- t.Errorf("Insert: %v", err)
- return
- }
- }
- }()
- }
- wg.Wait()
-}
-
-// Benchmarks need to use panic() since b.Error errors are lost when
-// running via testing.Benchmark() I would like to run these via go
-// test -bench but calling Benchmark() from a benchmark test
-// currently hangs go.
-
-func BenchmarkExec(b *testing.B) {
- for i := 0; i < b.N; i++ {
- if _, err := db.Exec("select 1"); err != nil {
- panic(err)
- }
- }
-}
-
-func BenchmarkQuery(b *testing.B) {
- for i := 0; i < b.N; i++ {
- var n sql.NullString
- var i int
- var f float64
- var s string
- // var t time.Time
- if err := db.QueryRow("select null, 1, 1.1, 'foo'").Scan(&n, &i, &f, &s); err != nil {
- panic(err)
- }
- }
-}
-
-func BenchmarkParams(b *testing.B) {
- for i := 0; i < b.N; i++ {
- var n sql.NullString
- var i int
- var f float64
- var s string
- // var t time.Time
- if err := db.QueryRow("select ?, ?, ?, ?", nil, 1, 1.1, "foo").Scan(&n, &i, &f, &s); err != nil {
- panic(err)
- }
- }
-}
-
-func BenchmarkStmt(b *testing.B) {
- st, err := db.Prepare("select ?, ?, ?, ?")
- if err != nil {
- panic(err)
- }
- defer st.Close()
-
- for n := 0; n < b.N; n++ {
- var n sql.NullString
- var i int
- var f float64
- var s string
- // var t time.Time
- if err := st.QueryRow(nil, 1, 1.1, "foo").Scan(&n, &i, &f, &s); err != nil {
- panic(err)
- }
- }
-}
-
-func BenchmarkRows(b *testing.B) {
- db.once.Do(makeBench)
-
- for n := 0; n < b.N; n++ {
- var n sql.NullString
- var i int
- var f float64
- var s string
- var t time.Time
- r, err := db.Query("select * from bench")
- if err != nil {
- panic(err)
- }
- for r.Next() {
- if err = r.Scan(&n, &i, &f, &s, &t); err != nil {
- panic(err)
- }
- }
- if err = r.Err(); err != nil {
- panic(err)
- }
- }
-}
-
-func BenchmarkStmtRows(b *testing.B) {
- db.once.Do(makeBench)
-
- st, err := db.Prepare("select * from bench")
- if err != nil {
- panic(err)
- }
- defer st.Close()
-
- for n := 0; n < b.N; n++ {
- var n sql.NullString
- var i int
- var f float64
- var s string
- var t time.Time
- r, err := st.Query()
- if err != nil {
- panic(err)
- }
- for r.Next() {
- if err = r.Scan(&n, &i, &f, &s, &t); err != nil {
- panic(err)
- }
- }
- if err = r.Err(); err != nil {
- panic(err)
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_windows.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_windows.go b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_windows.go
deleted file mode 100644
index 163e8f7..0000000
--- a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/sqlite3_windows.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (C) 2014 Yasuhiro Matsumoto <ma...@gmail.com>.
-//
-// Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-// +build windows
-
-package sqlite3
-
-/*
-#cgo CFLAGS: -I. -fno-stack-check -fno-stack-protector -mno-stack-arg-probe
-#cgo windows,386 CFLAGS: -D_USE_32BIT_TIME_T
-#cgo LDFLAGS: -lmingwex -lmingw32
-*/
-import "C"
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/.travis.yml
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/.travis.yml b/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/.travis.yml
deleted file mode 100644
index 7f3fe9a..0000000
--- a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/.travis.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-language: go
-
-go:
- - 1.4
-
-script:
- - go test
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/LICENSE
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/LICENSE b/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/LICENSE
deleted file mode 100644
index f9c841a..0000000
--- a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013 Mitchell Hashimoto
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/README.md
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/README.md b/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/README.md
deleted file mode 100644
index 659d688..0000000
--- a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# mapstructure
-
-mapstructure is a Go library for decoding generic map values to structures
-and vice versa, while providing helpful error handling.
-
-This library is most useful when decoding values from some data stream (JSON,
-Gob, etc.) where you don't _quite_ know the structure of the underlying data
-until you read a part of it. You can therefore read a `map[string]interface{}`
-and use this library to decode it into the proper underlying native Go
-structure.
-
-## Installation
-
-Standard `go get`:
-
-```
-$ go get github.com/mitchellh/mapstructure
-```
-
-## Usage & Example
-
-For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/mapstructure).
-
-The `Decode` function has examples associated with it there.
-
-## But Why?!
-
-Go offers fantastic standard libraries for decoding formats such as JSON.
-The standard method is to have a struct pre-created, and populate that struct
-from the bytes of the encoded format. This is great, but the problem is if
-you have configuration or an encoding that changes slightly depending on
-specific fields. For example, consider this JSON:
-
-```json
-{
- "type": "person",
- "name": "Mitchell"
-}
-```
-
-Perhaps we can't populate a specific structure without first reading
-the "type" field from the JSON. We could always do two passes over the
-decoding of the JSON (reading the "type" first, and the rest later).
-However, it is much simpler to just decode this into a `map[string]interface{}`
-structure, read the "type" key, then use something like this library
-to decode it into the proper structure.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/decode_hooks.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/decode_hooks.go b/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/decode_hooks.go
deleted file mode 100644
index aa91f76..0000000
--- a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/decode_hooks.go
+++ /dev/null
@@ -1,151 +0,0 @@
-package mapstructure
-
-import (
- "errors"
- "reflect"
- "strconv"
- "strings"
- "time"
-)
-
-// typedDecodeHook takes a raw DecodeHookFunc (an interface{}) and turns
-// it into the proper DecodeHookFunc type, such as DecodeHookFuncType.
-func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
- // Create variables here so we can reference them with the reflect pkg
- var f1 DecodeHookFuncType
- var f2 DecodeHookFuncKind
-
- // Fill in the variables into this interface and the rest is done
- // automatically using the reflect package.
- potential := []interface{}{f1, f2}
-
- v := reflect.ValueOf(h)
- vt := v.Type()
- for _, raw := range potential {
- pt := reflect.ValueOf(raw).Type()
- if vt.ConvertibleTo(pt) {
- return v.Convert(pt).Interface()
- }
- }
-
- return nil
-}
-
-// DecodeHookExec executes the given decode hook. This should be used
-// since it'll naturally degrade to the older backwards compatible DecodeHookFunc
-// that took reflect.Kind instead of reflect.Type.
-func DecodeHookExec(
- raw DecodeHookFunc,
- from reflect.Type, to reflect.Type,
- data interface{}) (interface{}, error) {
- // Build our arguments that reflect expects
- argVals := make([]reflect.Value, 3)
- argVals[0] = reflect.ValueOf(from)
- argVals[1] = reflect.ValueOf(to)
- argVals[2] = reflect.ValueOf(data)
-
- switch f := typedDecodeHook(raw).(type) {
- case DecodeHookFuncType:
- return f(from, to, data)
- case DecodeHookFuncKind:
- return f(from.Kind(), to.Kind(), data)
- default:
- return nil, errors.New("invalid decode hook signature")
- }
-}
-
-// ComposeDecodeHookFunc creates a single DecodeHookFunc that
-// automatically composes multiple DecodeHookFuncs.
-//
-// The composed funcs are called in order, with the result of the
-// previous transformation.
-func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
- return func(
- f reflect.Type,
- t reflect.Type,
- data interface{}) (interface{}, error) {
- var err error
- for _, f1 := range fs {
- data, err = DecodeHookExec(f1, f, t, data)
- if err != nil {
- return nil, err
- }
-
- // Modify the from kind to be correct with the new data
- f = reflect.ValueOf(data).Type()
- }
-
- return data, nil
- }
-}
-
-// StringToSliceHookFunc returns a DecodeHookFunc that converts
-// string to []string by splitting on the given sep.
-func StringToSliceHookFunc(sep string) DecodeHookFunc {
- return func(
- f reflect.Kind,
- t reflect.Kind,
- data interface{}) (interface{}, error) {
- if f != reflect.String || t != reflect.Slice {
- return data, nil
- }
-
- raw := data.(string)
- if raw == "" {
- return []string{}, nil
- }
-
- return strings.Split(raw, sep), nil
- }
-}
-
-// StringToTimeDurationHookFunc returns a DecodeHookFunc that converts
-// strings to time.Duration.
-func StringToTimeDurationHookFunc() DecodeHookFunc {
- return func(
- f reflect.Type,
- t reflect.Type,
- data interface{}) (interface{}, error) {
- if f.Kind() != reflect.String {
- return data, nil
- }
- if t != reflect.TypeOf(time.Duration(5)) {
- return data, nil
- }
-
- // Convert it by parsing
- return time.ParseDuration(data.(string))
- }
-}
-
-func WeaklyTypedHook(
- f reflect.Kind,
- t reflect.Kind,
- data interface{}) (interface{}, error) {
- dataVal := reflect.ValueOf(data)
- switch t {
- case reflect.String:
- switch f {
- case reflect.Bool:
- if dataVal.Bool() {
- return "1", nil
- } else {
- return "0", nil
- }
- case reflect.Float32:
- return strconv.FormatFloat(dataVal.Float(), 'f', -1, 64), nil
- case reflect.Int:
- return strconv.FormatInt(dataVal.Int(), 10), nil
- case reflect.Slice:
- dataType := dataVal.Type()
- elemKind := dataType.Elem().Kind()
- if elemKind == reflect.Uint8 {
- return string(dataVal.Interface().([]uint8)), nil
- }
- case reflect.Uint:
- return strconv.FormatUint(dataVal.Uint(), 10), nil
- }
- }
-
- return data, nil
-}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/decode_hooks_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/decode_hooks_test.go b/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/decode_hooks_test.go
deleted file mode 100644
index 53289af..0000000
--- a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/decode_hooks_test.go
+++ /dev/null
@@ -1,229 +0,0 @@
-package mapstructure
-
-import (
- "errors"
- "reflect"
- "testing"
- "time"
-)
-
-func TestComposeDecodeHookFunc(t *testing.T) {
- f1 := func(
- f reflect.Kind,
- t reflect.Kind,
- data interface{}) (interface{}, error) {
- return data.(string) + "foo", nil
- }
-
- f2 := func(
- f reflect.Kind,
- t reflect.Kind,
- data interface{}) (interface{}, error) {
- return data.(string) + "bar", nil
- }
-
- f := ComposeDecodeHookFunc(f1, f2)
-
- result, err := DecodeHookExec(
- f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), "")
- if err != nil {
- t.Fatalf("bad: %s", err)
- }
- if result.(string) != "foobar" {
- t.Fatalf("bad: %#v", result)
- }
-}
-
-func TestComposeDecodeHookFunc_err(t *testing.T) {
- f1 := func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error) {
- return nil, errors.New("foo")
- }
-
- f2 := func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error) {
- panic("NOPE")
- }
-
- f := ComposeDecodeHookFunc(f1, f2)
-
- _, err := DecodeHookExec(
- f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), 42)
- if err.Error() != "foo" {
- t.Fatalf("bad: %s", err)
- }
-}
-
-func TestComposeDecodeHookFunc_kinds(t *testing.T) {
- var f2From reflect.Kind
-
- f1 := func(
- f reflect.Kind,
- t reflect.Kind,
- data interface{}) (interface{}, error) {
- return int(42), nil
- }
-
- f2 := func(
- f reflect.Kind,
- t reflect.Kind,
- data interface{}) (interface{}, error) {
- f2From = f
- return data, nil
- }
-
- f := ComposeDecodeHookFunc(f1, f2)
-
- _, err := DecodeHookExec(
- f, reflect.TypeOf(""), reflect.TypeOf([]byte("")), "")
- if err != nil {
- t.Fatalf("bad: %s", err)
- }
- if f2From != reflect.Int {
- t.Fatalf("bad: %#v", f2From)
- }
-}
-
-func TestStringToSliceHookFunc(t *testing.T) {
- f := StringToSliceHookFunc(",")
-
- strType := reflect.TypeOf("")
- sliceType := reflect.TypeOf([]byte(""))
- cases := []struct {
- f, t reflect.Type
- data interface{}
- result interface{}
- err bool
- }{
- {sliceType, sliceType, 42, 42, false},
- {strType, strType, 42, 42, false},
- {
- strType,
- sliceType,
- "foo,bar,baz",
- []string{"foo", "bar", "baz"},
- false,
- },
- {
- strType,
- sliceType,
- "",
- []string{},
- false,
- },
- }
-
- for i, tc := range cases {
- actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
- if tc.err != (err != nil) {
- t.Fatalf("case %d: expected err %#v", i, tc.err)
- }
- if !reflect.DeepEqual(actual, tc.result) {
- t.Fatalf(
- "case %d: expected %#v, got %#v",
- i, tc.result, actual)
- }
- }
-}
-
-func TestStringToTimeDurationHookFunc(t *testing.T) {
- f := StringToTimeDurationHookFunc()
-
- strType := reflect.TypeOf("")
- timeType := reflect.TypeOf(time.Duration(5))
- cases := []struct {
- f, t reflect.Type
- data interface{}
- result interface{}
- err bool
- }{
- {strType, timeType, "5s", 5 * time.Second, false},
- {strType, timeType, "5", time.Duration(0), true},
- {strType, strType, "5", "5", false},
- }
-
- for i, tc := range cases {
- actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
- if tc.err != (err != nil) {
- t.Fatalf("case %d: expected err %#v", i, tc.err)
- }
- if !reflect.DeepEqual(actual, tc.result) {
- t.Fatalf(
- "case %d: expected %#v, got %#v",
- i, tc.result, actual)
- }
- }
-}
-
-func TestWeaklyTypedHook(t *testing.T) {
- var f DecodeHookFunc = WeaklyTypedHook
-
- boolType := reflect.TypeOf(true)
- strType := reflect.TypeOf("")
- sliceType := reflect.TypeOf([]byte(""))
- cases := []struct {
- f, t reflect.Type
- data interface{}
- result interface{}
- err bool
- }{
- // TO STRING
- {
- boolType,
- strType,
- false,
- "0",
- false,
- },
-
- {
- boolType,
- strType,
- true,
- "1",
- false,
- },
-
- {
- reflect.TypeOf(float32(1)),
- strType,
- float32(7),
- "7",
- false,
- },
-
- {
- reflect.TypeOf(int(1)),
- strType,
- int(7),
- "7",
- false,
- },
-
- {
- sliceType,
- strType,
- []uint8("foo"),
- "foo",
- false,
- },
-
- {
- reflect.TypeOf(uint(1)),
- strType,
- uint(7),
- "7",
- false,
- },
- }
-
- for i, tc := range cases {
- actual, err := DecodeHookExec(f, tc.f, tc.t, tc.data)
- if tc.err != (err != nil) {
- t.Fatalf("case %d: expected err %#v", i, tc.err)
- }
- if !reflect.DeepEqual(actual, tc.result) {
- t.Fatalf(
- "case %d: expected %#v, got %#v",
- i, tc.result, actual)
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/error.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/error.go b/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/error.go
deleted file mode 100644
index 47a99e5..0000000
--- a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/error.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package mapstructure
-
-import (
- "errors"
- "fmt"
- "sort"
- "strings"
-)
-
-// Error implements the error interface and can represents multiple
-// errors that occur in the course of a single decode.
-type Error struct {
- Errors []string
-}
-
-func (e *Error) Error() string {
- points := make([]string, len(e.Errors))
- for i, err := range e.Errors {
- points[i] = fmt.Sprintf("* %s", err)
- }
-
- sort.Strings(points)
- return fmt.Sprintf(
- "%d error(s) decoding:\n\n%s",
- len(e.Errors), strings.Join(points, "\n"))
-}
-
-// WrappedErrors implements the errwrap.Wrapper interface to make this
-// return value more useful with the errwrap and go-multierror libraries.
-func (e *Error) WrappedErrors() []error {
- if e == nil {
- return nil
- }
-
- result := make([]error, len(e.Errors))
- for i, e := range e.Errors {
- result[i] = errors.New(e)
- }
-
- return result
-}
-
-func appendErrors(errors []string, err error) []string {
- switch e := err.(type) {
- case *Error:
- return append(errors, e.Errors...)
- default:
- return append(errors, e.Error())
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/mapstructure.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/mapstructure.go b/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/mapstructure.go
deleted file mode 100644
index a367a95..0000000
--- a/newt/Godeps/_workspace/src/github.com/mitchellh/mapstructure/mapstructure.go
+++ /dev/null
@@ -1,767 +0,0 @@
-// The mapstructure package exposes functionality to convert an
-// abitrary map[string]interface{} into a native Go structure.
-//
-// The Go structure can be arbitrarily complex, containing slices,
-// other structs, etc. and the decoder will properly decode nested
-// maps and so on into the proper structures in the native Go struct.
-// See the examples to see what the decoder is capable of.
-package mapstructure
-
-import (
- "errors"
- "fmt"
- "reflect"
- "sort"
- "strconv"
- "strings"
-)
-
-// DecodeHookFunc is the callback function that can be used for
-// data transformations. See "DecodeHook" in the DecoderConfig
-// struct.
-//
-// The type should be DecodeHookFuncType or DecodeHookFuncKind.
-// Either is accepted. Types are a superset of Kinds (Types can return
-// Kinds) and are generally a richer thing to use, but Kinds are simpler
-// if you only need those.
-//
-// The reason DecodeHookFunc is multi-typed is for backwards compatibility:
-// we started with Kinds and then realized Types were the better solution,
-// but have a promise to not break backwards compat so we now support
-// both.
-type DecodeHookFunc interface{}
-
-type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)
-type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)
-
-// DecoderConfig is the configuration that is used to create a new decoder
-// and allows customization of various aspects of decoding.
-type DecoderConfig struct {
- // DecodeHook, if set, will be called before any decoding and any
- // type conversion (if WeaklyTypedInput is on). This lets you modify
- // the values before they're set down onto the resulting struct.
- //
- // If an error is returned, the entire decode will fail with that
- // error.
- DecodeHook DecodeHookFunc
-
- // If ErrorUnused is true, then it is an error for there to exist
- // keys in the original map that were unused in the decoding process
- // (extra keys).
- ErrorUnused bool
-
- // ZeroFields, if set to true, will zero fields before writing them.
- // For example, a map will be emptied before decoded values are put in
- // it. If this is false, a map will be merged.
- ZeroFields bool
-
- // If WeaklyTypedInput is true, the decoder will make the following
- // "weak" conversions:
- //
- // - bools to string (true = "1", false = "0")
- // - numbers to string (base 10)
- // - bools to int/uint (true = 1, false = 0)
- // - strings to int/uint (base implied by prefix)
- // - int to bool (true if value != 0)
- // - string to bool (accepts: 1, t, T, TRUE, true, True, 0, f, F,
- // FALSE, false, False. Anything else is an error)
- // - empty array = empty map and vice versa
- // - negative numbers to overflowed uint values (base 10)
- // - slice of maps to a merged map
- //
- WeaklyTypedInput bool
-
- // Metadata is the struct that will contain extra metadata about
- // the decoding. If this is nil, then no metadata will be tracked.
- Metadata *Metadata
-
- // Result is a pointer to the struct that will contain the decoded
- // value.
- Result interface{}
-
- // The tag name that mapstructure reads for field names. This
- // defaults to "mapstructure"
- TagName string
-}
-
-// A Decoder takes a raw interface value and turns it into structured
-// data, keeping track of rich error information along the way in case
-// anything goes wrong. Unlike the basic top-level Decode method, you can
-// more finely control how the Decoder behaves using the DecoderConfig
-// structure. The top-level Decode method is just a convenience that sets
-// up the most basic Decoder.
-type Decoder struct {
- config *DecoderConfig
-}
-
-// Metadata contains information about decoding a structure that
-// is tedious or difficult to get otherwise.
-type Metadata struct {
- // Keys are the keys of the structure which were successfully decoded
- Keys []string
-
- // Unused is a slice of keys that were found in the raw value but
- // weren't decoded since there was no matching field in the result interface
- Unused []string
-}
-
-// Decode takes a map and uses reflection to convert it into the
-// given Go native structure. val must be a pointer to a struct.
-func Decode(m interface{}, rawVal interface{}) error {
- config := &DecoderConfig{
- Metadata: nil,
- Result: rawVal,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- return err
- }
-
- return decoder.Decode(m)
-}
-
-// WeakDecode is the same as Decode but is shorthand to enable
-// WeaklyTypedInput. See DecoderConfig for more info.
-func WeakDecode(input, output interface{}) error {
- config := &DecoderConfig{
- Metadata: nil,
- Result: output,
- WeaklyTypedInput: true,
- }
-
- decoder, err := NewDecoder(config)
- if err != nil {
- return err
- }
-
- return decoder.Decode(input)
-}
-
-// NewDecoder returns a new decoder for the given configuration. Once
-// a decoder has been returned, the same configuration must not be used
-// again.
-func NewDecoder(config *DecoderConfig) (*Decoder, error) {
- val := reflect.ValueOf(config.Result)
- if val.Kind() != reflect.Ptr {
- return nil, errors.New("result must be a pointer")
- }
-
- val = val.Elem()
- if !val.CanAddr() {
- return nil, errors.New("result must be addressable (a pointer)")
- }
-
- if config.Metadata != nil {
- if config.Metadata.Keys == nil {
- config.Metadata.Keys = make([]string, 0)
- }
-
- if config.Metadata.Unused == nil {
- config.Metadata.Unused = make([]string, 0)
- }
- }
-
- if config.TagName == "" {
- config.TagName = "mapstructure"
- }
-
- result := &Decoder{
- config: config,
- }
-
- return result, nil
-}
-
-// Decode decodes the given raw interface to the target pointer specified
-// by the configuration.
-func (d *Decoder) Decode(raw interface{}) error {
- return d.decode("", raw, reflect.ValueOf(d.config.Result).Elem())
-}
-
-// Decodes an unknown data type into a specific reflection value.
-func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error {
- if data == nil {
- // If the data is nil, then we don't set anything.
- return nil
- }
-
- dataVal := reflect.ValueOf(data)
- if !dataVal.IsValid() {
- // If the data value is invalid, then we just set the value
- // to be the zero value.
- val.Set(reflect.Zero(val.Type()))
- return nil
- }
-
- if d.config.DecodeHook != nil {
- // We have a DecodeHook, so let's pre-process the data.
- var err error
- data, err = DecodeHookExec(
- d.config.DecodeHook,
- dataVal.Type(), val.Type(), data)
- if err != nil {
- return err
- }
- }
-
- var err error
- dataKind := getKind(val)
- switch dataKind {
- case reflect.Bool:
- err = d.decodeBool(name, data, val)
- case reflect.Interface:
- err = d.decodeBasic(name, data, val)
- case reflect.String:
- err = d.decodeString(name, data, val)
- case reflect.Int:
- err = d.decodeInt(name, data, val)
- case reflect.Uint:
- err = d.decodeUint(name, data, val)
- case reflect.Float32:
- err = d.decodeFloat(name, data, val)
- case reflect.Struct:
- err = d.decodeStruct(name, data, val)
- case reflect.Map:
- err = d.decodeMap(name, data, val)
- case reflect.Ptr:
- err = d.decodePtr(name, data, val)
- case reflect.Slice:
- err = d.decodeSlice(name, data, val)
- default:
- // If we reached this point then we weren't able to decode it
- return fmt.Errorf("%s: unsupported type: %s", name, dataKind)
- }
-
- // If we reached here, then we successfully decoded SOMETHING, so
- // mark the key as used if we're tracking metadata.
- if d.config.Metadata != nil && name != "" {
- d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
- }
-
- return err
-}
-
-// This decodes a basic type (bool, int, string, etc.) and sets the
-// value to "data" of that type.
-func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {
- dataVal := reflect.ValueOf(data)
- dataValType := dataVal.Type()
- if !dataValType.AssignableTo(val.Type()) {
- return fmt.Errorf(
- "'%s' expected type '%s', got '%s'",
- name, val.Type(), dataValType)
- }
-
- val.Set(dataVal)
- return nil
-}
-
-func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) error {
- dataVal := reflect.ValueOf(data)
- dataKind := getKind(dataVal)
-
- converted := true
- switch {
- case dataKind == reflect.String:
- val.SetString(dataVal.String())
- case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
- if dataVal.Bool() {
- val.SetString("1")
- } else {
- val.SetString("0")
- }
- case dataKind == reflect.Int && d.config.WeaklyTypedInput:
- val.SetString(strconv.FormatInt(dataVal.Int(), 10))
- case dataKind == reflect.Uint && d.config.WeaklyTypedInput:
- val.SetString(strconv.FormatUint(dataVal.Uint(), 10))
- case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
- val.SetString(strconv.FormatFloat(dataVal.Float(), 'f', -1, 64))
- case dataKind == reflect.Slice && d.config.WeaklyTypedInput:
- dataType := dataVal.Type()
- elemKind := dataType.Elem().Kind()
- switch {
- case elemKind == reflect.Uint8:
- val.SetString(string(dataVal.Interface().([]uint8)))
- default:
- converted = false
- }
- default:
- converted = false
- }
-
- if !converted {
- return fmt.Errorf(
- "'%s' expected type '%s', got unconvertible type '%s'",
- name, val.Type(), dataVal.Type())
- }
-
- return nil
-}
-
-func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {
- dataVal := reflect.ValueOf(data)
- dataKind := getKind(dataVal)
-
- switch {
- case dataKind == reflect.Int:
- val.SetInt(dataVal.Int())
- case dataKind == reflect.Uint:
- val.SetInt(int64(dataVal.Uint()))
- case dataKind == reflect.Float32:
- val.SetInt(int64(dataVal.Float()))
- case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
- if dataVal.Bool() {
- val.SetInt(1)
- } else {
- val.SetInt(0)
- }
- case dataKind == reflect.String && d.config.WeaklyTypedInput:
- i, err := strconv.ParseInt(dataVal.String(), 0, val.Type().Bits())
- if err == nil {
- val.SetInt(i)
- } else {
- return fmt.Errorf("cannot parse '%s' as int: %s", name, err)
- }
- default:
- return fmt.Errorf(
- "'%s' expected type '%s', got unconvertible type '%s'",
- name, val.Type(), dataVal.Type())
- }
-
- return nil
-}
-
-func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) error {
- dataVal := reflect.ValueOf(data)
- dataKind := getKind(dataVal)
-
- switch {
- case dataKind == reflect.Int:
- i := dataVal.Int()
- if i < 0 && !d.config.WeaklyTypedInput {
- return fmt.Errorf("cannot parse '%s', %d overflows uint",
- name, i)
- }
- val.SetUint(uint64(i))
- case dataKind == reflect.Uint:
- val.SetUint(dataVal.Uint())
- case dataKind == reflect.Float32:
- f := dataVal.Float()
- if f < 0 && !d.config.WeaklyTypedInput {
- return fmt.Errorf("cannot parse '%s', %f overflows uint",
- name, f)
- }
- val.SetUint(uint64(f))
- case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
- if dataVal.Bool() {
- val.SetUint(1)
- } else {
- val.SetUint(0)
- }
- case dataKind == reflect.String && d.config.WeaklyTypedInput:
- i, err := strconv.ParseUint(dataVal.String(), 0, val.Type().Bits())
- if err == nil {
- val.SetUint(i)
- } else {
- return fmt.Errorf("cannot parse '%s' as uint: %s", name, err)
- }
- default:
- return fmt.Errorf(
- "'%s' expected type '%s', got unconvertible type '%s'",
- name, val.Type(), dataVal.Type())
- }
-
- return nil
-}
-
-func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) error {
- dataVal := reflect.ValueOf(data)
- dataKind := getKind(dataVal)
-
- switch {
- case dataKind == reflect.Bool:
- val.SetBool(dataVal.Bool())
- case dataKind == reflect.Int && d.config.WeaklyTypedInput:
- val.SetBool(dataVal.Int() != 0)
- case dataKind == reflect.Uint && d.config.WeaklyTypedInput:
- val.SetBool(dataVal.Uint() != 0)
- case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
- val.SetBool(dataVal.Float() != 0)
- case dataKind == reflect.String && d.config.WeaklyTypedInput:
- b, err := strconv.ParseBool(dataVal.String())
- if err == nil {
- val.SetBool(b)
- } else if dataVal.String() == "" {
- val.SetBool(false)
- } else {
- return fmt.Errorf("cannot parse '%s' as bool: %s", name, err)
- }
- default:
- return fmt.Errorf(
- "'%s' expected type '%s', got unconvertible type '%s'",
- name, val.Type(), dataVal.Type())
- }
-
- return nil
-}
-
-func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value) error {
- dataVal := reflect.ValueOf(data)
- dataKind := getKind(dataVal)
-
- switch {
- case dataKind == reflect.Int:
- val.SetFloat(float64(dataVal.Int()))
- case dataKind == reflect.Uint:
- val.SetFloat(float64(dataVal.Uint()))
- case dataKind == reflect.Float32:
- val.SetFloat(float64(dataVal.Float()))
- case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
- if dataVal.Bool() {
- val.SetFloat(1)
- } else {
- val.SetFloat(0)
- }
- case dataKind == reflect.String && d.config.WeaklyTypedInput:
- f, err := strconv.ParseFloat(dataVal.String(), val.Type().Bits())
- if err == nil {
- val.SetFloat(f)
- } else {
- return fmt.Errorf("cannot parse '%s' as float: %s", name, err)
- }
- default:
- return fmt.Errorf(
- "'%s' expected type '%s', got unconvertible type '%s'",
- name, val.Type(), dataVal.Type())
- }
-
- return nil
-}
-
-func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) error {
- valType := val.Type()
- valKeyType := valType.Key()
- valElemType := valType.Elem()
-
- // By default we overwrite keys in the current map
- valMap := val
-
- // If the map is nil or we're purposely zeroing fields, make a new map
- if valMap.IsNil() || d.config.ZeroFields {
- // Make a new map to hold our result
- mapType := reflect.MapOf(valKeyType, valElemType)
- valMap = reflect.MakeMap(mapType)
- }
-
- // Check input type
- dataVal := reflect.Indirect(reflect.ValueOf(data))
- if dataVal.Kind() != reflect.Map {
- // In weak mode, we accept a slice of maps as an input...
- if d.config.WeaklyTypedInput {
- switch dataVal.Kind() {
- case reflect.Array, reflect.Slice:
- // Special case for BC reasons (covered by tests)
- if dataVal.Len() == 0 {
- val.Set(valMap)
- return nil
- }
-
- for i := 0; i < dataVal.Len(); i++ {
- err := d.decode(
- fmt.Sprintf("%s[%d]", name, i),
- dataVal.Index(i).Interface(), val)
- if err != nil {
- return err
- }
- }
-
- return nil
- }
- }
-
- return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
- }
-
- // Accumulate errors
- errors := make([]string, 0)
-
- for _, k := range dataVal.MapKeys() {
- fieldName := fmt.Sprintf("%s[%s]", name, k)
-
- // First decode the key into the proper type
- currentKey := reflect.Indirect(reflect.New(valKeyType))
- if err := d.decode(fieldName, k.Interface(), currentKey); err != nil {
- errors = appendErrors(errors, err)
- continue
- }
-
- // Next decode the data into the proper type
- v := dataVal.MapIndex(k).Interface()
- currentVal := reflect.Indirect(reflect.New(valElemType))
- if err := d.decode(fieldName, v, currentVal); err != nil {
- errors = appendErrors(errors, err)
- continue
- }
-
- valMap.SetMapIndex(currentKey, currentVal)
- }
-
- // Set the built up map to the value
- val.Set(valMap)
-
- // If we had errors, return those
- if len(errors) > 0 {
- return &Error{errors}
- }
-
- return nil
-}
-
-func (d *Decoder) decodePtr(name string, data interface{}, val reflect.Value) error {
- // Create an element of the concrete (non pointer) type and decode
- // into that. Then set the value of the pointer to this type.
- valType := val.Type()
- valElemType := valType.Elem()
- realVal := reflect.New(valElemType)
- if err := d.decode(name, data, reflect.Indirect(realVal)); err != nil {
- return err
- }
-
- val.Set(realVal)
- return nil
-}
-
-func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value) error {
- dataVal := reflect.Indirect(reflect.ValueOf(data))
- dataValKind := dataVal.Kind()
- valType := val.Type()
- valElemType := valType.Elem()
- sliceType := reflect.SliceOf(valElemType)
-
- // Check input type
- if dataValKind != reflect.Array && dataValKind != reflect.Slice {
- // Accept empty map instead of array/slice in weakly typed mode
- if d.config.WeaklyTypedInput && dataVal.Kind() == reflect.Map && dataVal.Len() == 0 {
- val.Set(reflect.MakeSlice(sliceType, 0, 0))
- return nil
- } else {
- return fmt.Errorf(
- "'%s': source data must be an array or slice, got %s", name, dataValKind)
- }
- }
-
- // Make a new slice to hold our result, same size as the original data.
- valSlice := reflect.MakeSlice(sliceType, dataVal.Len(), dataVal.Len())
-
- // Accumulate any errors
- errors := make([]string, 0)
-
- for i := 0; i < dataVal.Len(); i++ {
- currentData := dataVal.Index(i).Interface()
- currentField := valSlice.Index(i)
-
- fieldName := fmt.Sprintf("%s[%d]", name, i)
- if err := d.decode(fieldName, currentData, currentField); err != nil {
- errors = appendErrors(errors, err)
- }
- }
-
- // Finally, set the value to the slice we built up
- val.Set(valSlice)
-
- // If there were errors, we return those
- if len(errors) > 0 {
- return &Error{errors}
- }
-
- return nil
-}
-
-func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value) error {
- dataVal := reflect.Indirect(reflect.ValueOf(data))
-
- // If the type of the value to write to and the data match directly,
- // then we just set it directly instead of recursing into the structure.
- if dataVal.Type() == val.Type() {
- val.Set(dataVal)
- return nil
- }
-
- dataValKind := dataVal.Kind()
- if dataValKind != reflect.Map {
- return fmt.Errorf("'%s' expected a map, got '%s'", name, dataValKind)
- }
-
- dataValType := dataVal.Type()
- if kind := dataValType.Key().Kind(); kind != reflect.String && kind != reflect.Interface {
- return fmt.Errorf(
- "'%s' needs a map with string keys, has '%s' keys",
- name, dataValType.Key().Kind())
- }
-
- dataValKeys := make(map[reflect.Value]struct{})
- dataValKeysUnused := make(map[interface{}]struct{})
- for _, dataValKey := range dataVal.MapKeys() {
- dataValKeys[dataValKey] = struct{}{}
- dataValKeysUnused[dataValKey.Interface()] = struct{}{}
- }
-
- errors := make([]string, 0)
-
- // This slice will keep track of all the structs we'll be decoding.
- // There can be more than one struct if there are embedded structs
- // that are squashed.
- structs := make([]reflect.Value, 1, 5)
- structs[0] = val
-
- // Compile the list of all the fields that we're going to be decoding
- // from all the structs.
- fields := make(map[*reflect.StructField]reflect.Value)
- for len(structs) > 0 {
- structVal := structs[0]
- structs = structs[1:]
-
- structType := structVal.Type()
-
- for i := 0; i < structType.NumField(); i++ {
- fieldType := structType.Field(i)
- fieldKind := fieldType.Type.Kind()
-
- if fieldType.Anonymous {
- if fieldKind != reflect.Struct {
- errors = appendErrors(errors,
- fmt.Errorf("%s: unsupported type: %s", fieldType.Name, fieldKind))
- continue
- }
- }
-
- // If "squash" is specified in the tag, we squash the field down.
- squash := false
- tagParts := strings.Split(fieldType.Tag.Get(d.config.TagName), ",")
- for _, tag := range tagParts[1:] {
- if tag == "squash" {
- squash = true
- break
- }
- }
-
- if squash {
- if fieldKind != reflect.Struct {
- errors = appendErrors(errors,
- fmt.Errorf("%s: unsupported type for squash: %s", fieldType.Name, fieldKind))
- } else {
- structs = append(structs, val.FieldByName(fieldType.Name))
- }
- continue
- }
-
- // Normal struct field, store it away
- fields[&fieldType] = structVal.Field(i)
- }
- }
-
- for fieldType, field := range fields {
- fieldName := fieldType.Name
-
- tagValue := fieldType.Tag.Get(d.config.TagName)
- tagValue = strings.SplitN(tagValue, ",", 2)[0]
- if tagValue != "" {
- fieldName = tagValue
- }
-
- rawMapKey := reflect.ValueOf(fieldName)
- rawMapVal := dataVal.MapIndex(rawMapKey)
- if !rawMapVal.IsValid() {
- // Do a slower search by iterating over each key and
- // doing case-insensitive search.
- for dataValKey, _ := range dataValKeys {
- mK, ok := dataValKey.Interface().(string)
- if !ok {
- // Not a string key
- continue
- }
-
- if strings.EqualFold(mK, fieldName) {
- rawMapKey = dataValKey
- rawMapVal = dataVal.MapIndex(dataValKey)
- break
- }
- }
-
- if !rawMapVal.IsValid() {
- // There was no matching key in the map for the value in
- // the struct. Just ignore.
- continue
- }
- }
-
- // Delete the key we're using from the unused map so we stop tracking
- delete(dataValKeysUnused, rawMapKey.Interface())
-
- if !field.IsValid() {
- // This should never happen
- panic("field is not valid")
- }
-
- // If we can't set the field, then it is unexported or something,
- // and we just continue onwards.
- if !field.CanSet() {
- continue
- }
-
- // If the name is empty string, then we're at the root, and we
- // don't dot-join the fields.
- if name != "" {
- fieldName = fmt.Sprintf("%s.%s", name, fieldName)
- }
-
- if err := d.decode(fieldName, rawMapVal.Interface(), field); err != nil {
- errors = appendErrors(errors, err)
- }
- }
-
- if d.config.ErrorUnused && len(dataValKeysUnused) > 0 {
- keys := make([]string, 0, len(dataValKeysUnused))
- for rawKey, _ := range dataValKeysUnused {
- keys = append(keys, rawKey.(string))
- }
- sort.Strings(keys)
-
- err := fmt.Errorf("'%s' has invalid keys: %s", name, strings.Join(keys, ", "))
- errors = appendErrors(errors, err)
- }
-
- if len(errors) > 0 {
- return &Error{errors}
- }
-
- // Add the unused keys to the list of unused keys if we're tracking metadata
- if d.config.Metadata != nil {
- for rawKey, _ := range dataValKeysUnused {
- key := rawKey.(string)
- if name != "" {
- key = fmt.Sprintf("%s.%s", name, key)
- }
-
- d.config.Metadata.Unused = append(d.config.Metadata.Unused, key)
- }
- }
-
- return nil
-}
-
-func getKind(val reflect.Value) reflect.Kind {
- kind := val.Kind()
-
- switch {
- case kind >= reflect.Int && kind <= reflect.Int64:
- return reflect.Int
- case kind >= reflect.Uint && kind <= reflect.Uint64:
- return reflect.Uint
- case kind >= reflect.Float32 && kind <= reflect.Float64:
- return reflect.Float32
- default:
- return kind
- }
-}