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 2015/11/21 01:42:41 UTC
[16/42] incubator-mynewt-newt git commit: Move newt source into a
"newt" subdirectory.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties_test.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties_test.go
new file mode 100644
index 0000000..36ff293
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/magiconair/properties/properties_test.go
@@ -0,0 +1,846 @@
+// Copyright 2013-2014 Frank Schroeder. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package properties
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "math"
+ "os"
+ "strings"
+ "testing"
+ "time"
+
+ . "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type TestSuite struct {
+ prevHandler ErrorHandlerFunc
+}
+
+var (
+ _ = Suite(&TestSuite{})
+ verbose = flag.Bool("verbose", false, "Verbose output")
+)
+
+// --------------------------------------------------------------------
+
+func (s *TestSuite) SetUpSuite(c *C) {
+ s.prevHandler = ErrorHandler
+ ErrorHandler = PanicHandler
+}
+
+// --------------------------------------------------------------------
+
+func (s *TestSuite) TearDownSuite(c *C) {
+ ErrorHandler = s.prevHandler
+}
+
+// ----------------------------------------------------------------------------
+
+// define test cases in the form of
+// {"input", "key1", "value1", "key2", "value2", ...}
+var complexTests = [][]string{
+ // whitespace prefix
+ {" key=value", "key", "value"}, // SPACE prefix
+ {"\fkey=value", "key", "value"}, // FF prefix
+ {"\tkey=value", "key", "value"}, // TAB prefix
+ {" \f\tkey=value", "key", "value"}, // mix prefix
+
+ // multiple keys
+ {"key1=value1\nkey2=value2\n", "key1", "value1", "key2", "value2"},
+ {"key1=value1\rkey2=value2\r", "key1", "value1", "key2", "value2"},
+ {"key1=value1\r\nkey2=value2\r\n", "key1", "value1", "key2", "value2"},
+
+ // blank lines
+ {"\nkey=value\n", "key", "value"},
+ {"\rkey=value\r", "key", "value"},
+ {"\r\nkey=value\r\n", "key", "value"},
+
+ // escaped chars in key
+ {"k\\ ey = value", "k ey", "value"},
+ {"k\\:ey = value", "k:ey", "value"},
+ {"k\\=ey = value", "k=ey", "value"},
+ {"k\\fey = value", "k\fey", "value"},
+ {"k\\ney = value", "k\ney", "value"},
+ {"k\\rey = value", "k\rey", "value"},
+ {"k\\tey = value", "k\tey", "value"},
+
+ // escaped chars in value
+ {"key = v\\ alue", "key", "v alue"},
+ {"key = v\\:alue", "key", "v:alue"},
+ {"key = v\\=alue", "key", "v=alue"},
+ {"key = v\\falue", "key", "v\falue"},
+ {"key = v\\nalue", "key", "v\nalue"},
+ {"key = v\\ralue", "key", "v\ralue"},
+ {"key = v\\talue", "key", "v\talue"},
+
+ // silently dropped escape character
+ {"k\\zey = value", "kzey", "value"},
+ {"key = v\\zalue", "key", "vzalue"},
+
+ // unicode literals
+ {"key\\u2318 = value", "key⌘", "value"},
+ {"k\\u2318ey = value", "k⌘ey", "value"},
+ {"key = value\\u2318", "key", "value⌘"},
+ {"key = valu\\u2318e", "key", "valu⌘e"},
+
+ // multiline values
+ {"key = valueA,\\\n valueB", "key", "valueA,valueB"}, // SPACE indent
+ {"key = valueA,\\\n\f\f\fvalueB", "key", "valueA,valueB"}, // FF indent
+ {"key = valueA,\\\n\t\t\tvalueB", "key", "valueA,valueB"}, // TAB indent
+ {"key = valueA,\\\n \f\tvalueB", "key", "valueA,valueB"}, // mix indent
+
+ // comments
+ {"# this is a comment\n! and so is this\nkey1=value1\nkey#2=value#2\n\nkey!3=value!3\n# and another one\n! and the final one", "key1", "value1", "key#2", "value#2", "key!3", "value!3"},
+
+ // expansion tests
+ {"key=value\nkey2=${key}", "key", "value", "key2", "value"},
+ {"key=value\nkey2=aa${key}", "key", "value", "key2", "aavalue"},
+ {"key=value\nkey2=${key}bb", "key", "value", "key2", "valuebb"},
+ {"key=value\nkey2=aa${key}bb", "key", "value", "key2", "aavaluebb"},
+ {"key=value\nkey2=${key}\nkey3=${key2}", "key", "value", "key2", "value", "key3", "value"},
+ {"key=${USER}", "key", os.Getenv("USER")},
+ {"key=${USER}\nUSER=value", "key", "value", "USER", "value"},
+}
+
+// ----------------------------------------------------------------------------
+
+var commentTests = []struct {
+ input, key, value string
+ comments []string
+}{
+ {"key=value", "key", "value", nil},
+ {"#\nkey=value", "key", "value", []string{""}},
+ {"#comment\nkey=value", "key", "value", []string{"comment"}},
+ {"# comment\nkey=value", "key", "value", []string{"comment"}},
+ {"# comment\nkey=value", "key", "value", []string{"comment"}},
+ {"# comment\n\nkey=value", "key", "value", []string{"comment"}},
+ {"# comment1\n# comment2\nkey=value", "key", "value", []string{"comment1", "comment2"}},
+ {"# comment1\n\n# comment2\n\nkey=value", "key", "value", []string{"comment1", "comment2"}},
+ {"!comment\nkey=value", "key", "value", []string{"comment"}},
+ {"! comment\nkey=value", "key", "value", []string{"comment"}},
+ {"! comment\nkey=value", "key", "value", []string{"comment"}},
+ {"! comment\n\nkey=value", "key", "value", []string{"comment"}},
+ {"! comment1\n! comment2\nkey=value", "key", "value", []string{"comment1", "comment2"}},
+ {"! comment1\n\n! comment2\n\nkey=value", "key", "value", []string{"comment1", "comment2"}},
+}
+
+// ----------------------------------------------------------------------------
+
+var errorTests = []struct {
+ input, msg string
+}{
+ // unicode literals
+ {"key\\u1 = value", "invalid unicode literal"},
+ {"key\\u12 = value", "invalid unicode literal"},
+ {"key\\u123 = value", "invalid unicode literal"},
+ {"key\\u123g = value", "invalid unicode literal"},
+ {"key\\u123", "invalid unicode literal"},
+
+ // circular references
+ {"key=${key}", "circular reference"},
+ {"key1=${key2}\nkey2=${key1}", "circular reference"},
+
+ // malformed expressions
+ {"key=${ke", "malformed expression"},
+ {"key=valu${ke", "malformed expression"},
+}
+
+// ----------------------------------------------------------------------------
+
+var writeTests = []struct {
+ input, output, encoding string
+}{
+ // ISO-8859-1 tests
+ {"key = value", "key = value\n", "ISO-8859-1"},
+ {"key = value \\\n continued", "key = value continued\n", "ISO-8859-1"},
+ {"key⌘ = value", "key\\u2318 = value\n", "ISO-8859-1"},
+ {"ke\\ \\:y = value", "ke\\ \\:y = value\n", "ISO-8859-1"},
+
+ // UTF-8 tests
+ {"key = value", "key = value\n", "UTF-8"},
+ {"key = value \\\n continued", "key = value continued\n", "UTF-8"},
+ {"key⌘ = value⌘", "key⌘ = value⌘\n", "UTF-8"},
+ {"ke\\ \\:y = value", "ke\\ \\:y = value\n", "UTF-8"},
+}
+
+// ----------------------------------------------------------------------------
+
+var writeCommentTests = []struct {
+ input, output, encoding string
+}{
+ // ISO-8859-1 tests
+ {"key = value", "key = value\n", "ISO-8859-1"},
+ {"#\nkey = value", "key = value\n", "ISO-8859-1"},
+ {"#\n#\n#\nkey = value", "key = value\n", "ISO-8859-1"},
+ {"# comment\nkey = value", "# comment\nkey = value\n", "ISO-8859-1"},
+ {"\n# comment\nkey = value", "# comment\nkey = value\n", "ISO-8859-1"},
+ {"# comment\n\nkey = value", "# comment\nkey = value\n", "ISO-8859-1"},
+ {"# comment1\n# comment2\nkey = value", "# comment1\n# comment2\nkey = value\n", "ISO-8859-1"},
+ {"#comment1\nkey1 = value1\n#comment2\nkey2 = value2", "# comment1\nkey1 = value1\n\n# comment2\nkey2 = value2\n", "ISO-8859-1"},
+
+ // UTF-8 tests
+ {"key = value", "key = value\n", "UTF-8"},
+ {"# comment⌘\nkey = value⌘", "# comment⌘\nkey = value⌘\n", "UTF-8"},
+ {"\n# comment⌘\nkey = value⌘", "# comment⌘\nkey = value⌘\n", "UTF-8"},
+ {"# comment⌘\n\nkey = value⌘", "# comment⌘\nkey = value⌘\n", "UTF-8"},
+ {"# comment1⌘\n# comment2⌘\nkey = value⌘", "# comment1⌘\n# comment2⌘\nkey = value⌘\n", "UTF-8"},
+ {"#comment1⌘\nkey1 = value1⌘\n#comment2⌘\nkey2 = value2⌘", "# comment1⌘\nkey1 = value1⌘\n\n# comment2⌘\nkey2 = value2⌘\n", "UTF-8"},
+}
+
+// ----------------------------------------------------------------------------
+
+var boolTests = []struct {
+ input, key string
+ def, value bool
+}{
+ // valid values for TRUE
+ {"key = 1", "key", false, true},
+ {"key = on", "key", false, true},
+ {"key = On", "key", false, true},
+ {"key = ON", "key", false, true},
+ {"key = true", "key", false, true},
+ {"key = True", "key", false, true},
+ {"key = TRUE", "key", false, true},
+ {"key = yes", "key", false, true},
+ {"key = Yes", "key", false, true},
+ {"key = YES", "key", false, true},
+
+ // valid values for FALSE (all other)
+ {"key = 0", "key", true, false},
+ {"key = off", "key", true, false},
+ {"key = false", "key", true, false},
+ {"key = no", "key", true, false},
+
+ // non existent key
+ {"key = true", "key2", false, false},
+}
+
+// ----------------------------------------------------------------------------
+
+var durationTests = []struct {
+ input, key string
+ def, value time.Duration
+}{
+ // valid values
+ {"key = 1", "key", 999, 1},
+ {"key = 0", "key", 999, 0},
+ {"key = -1", "key", 999, -1},
+ {"key = 0123", "key", 999, 123},
+
+ // invalid values
+ {"key = 0xff", "key", 999, 999},
+ {"key = 1.0", "key", 999, 999},
+ {"key = a", "key", 999, 999},
+
+ // non existent key
+ {"key = 1", "key2", 999, 999},
+}
+
+// ----------------------------------------------------------------------------
+
+var parsedDurationTests = []struct {
+ input, key string
+ def, value time.Duration
+}{
+ // valid values
+ {"key = -1ns", "key", 999, -1 * time.Nanosecond},
+ {"key = 300ms", "key", 999, 300 * time.Millisecond},
+ {"key = 5s", "key", 999, 5 * time.Second},
+ {"key = 3h", "key", 999, 3 * time.Hour},
+ {"key = 2h45m", "key", 999, 2*time.Hour + 45*time.Minute},
+
+ // invalid values
+ {"key = 0xff", "key", 999, 999},
+ {"key = 1.0", "key", 999, 999},
+ {"key = a", "key", 999, 999},
+ {"key = 1", "key", 999, 999},
+ {"key = 0", "key", 999, 0},
+
+ // non existent key
+ {"key = 1", "key2", 999, 999},
+}
+
+// ----------------------------------------------------------------------------
+
+var floatTests = []struct {
+ input, key string
+ def, value float64
+}{
+ // valid values
+ {"key = 1.0", "key", 999, 1.0},
+ {"key = 0.0", "key", 999, 0.0},
+ {"key = -1.0", "key", 999, -1.0},
+ {"key = 1", "key", 999, 1},
+ {"key = 0", "key", 999, 0},
+ {"key = -1", "key", 999, -1},
+ {"key = 0123", "key", 999, 123},
+
+ // invalid values
+ {"key = 0xff", "key", 999, 999},
+ {"key = a", "key", 999, 999},
+
+ // non existent key
+ {"key = 1", "key2", 999, 999},
+}
+
+// ----------------------------------------------------------------------------
+
+var int64Tests = []struct {
+ input, key string
+ def, value int64
+}{
+ // valid values
+ {"key = 1", "key", 999, 1},
+ {"key = 0", "key", 999, 0},
+ {"key = -1", "key", 999, -1},
+ {"key = 0123", "key", 999, 123},
+
+ // invalid values
+ {"key = 0xff", "key", 999, 999},
+ {"key = 1.0", "key", 999, 999},
+ {"key = a", "key", 999, 999},
+
+ // non existent key
+ {"key = 1", "key2", 999, 999},
+}
+
+// ----------------------------------------------------------------------------
+
+var uint64Tests = []struct {
+ input, key string
+ def, value uint64
+}{
+ // valid values
+ {"key = 1", "key", 999, 1},
+ {"key = 0", "key", 999, 0},
+ {"key = 0123", "key", 999, 123},
+
+ // invalid values
+ {"key = -1", "key", 999, 999},
+ {"key = 0xff", "key", 999, 999},
+ {"key = 1.0", "key", 999, 999},
+ {"key = a", "key", 999, 999},
+
+ // non existent key
+ {"key = 1", "key2", 999, 999},
+}
+
+// ----------------------------------------------------------------------------
+
+var stringTests = []struct {
+ input, key string
+ def, value string
+}{
+ // valid values
+ {"key = abc", "key", "def", "abc"},
+
+ // non existent key
+ {"key = abc", "key2", "def", "def"},
+}
+
+// ----------------------------------------------------------------------------
+
+var keysTests = []struct {
+ input string
+ keys []string
+}{
+ {"", []string{}},
+ {"key = abc", []string{"key"}},
+ {"key = abc\nkey2=def", []string{"key", "key2"}},
+ {"key2 = abc\nkey=def", []string{"key2", "key"}},
+ {"key = abc\nkey=def", []string{"key"}},
+}
+
+// ----------------------------------------------------------------------------
+
+var filterTests = []struct {
+ input string
+ pattern string
+ keys []string
+ err string
+}{
+ {"", "", []string{}, ""},
+ {"", "abc", []string{}, ""},
+ {"key=value", "", []string{"key"}, ""},
+ {"key=value", "key=", []string{}, ""},
+ {"key=value\nfoo=bar", "", []string{"foo", "key"}, ""},
+ {"key=value\nfoo=bar", "f", []string{"foo"}, ""},
+ {"key=value\nfoo=bar", "fo", []string{"foo"}, ""},
+ {"key=value\nfoo=bar", "foo", []string{"foo"}, ""},
+ {"key=value\nfoo=bar", "fooo", []string{}, ""},
+ {"key=value\nkey2=value2\nfoo=bar", "ey", []string{"key", "key2"}, ""},
+ {"key=value\nkey2=value2\nfoo=bar", "key", []string{"key", "key2"}, ""},
+ {"key=value\nkey2=value2\nfoo=bar", "^key", []string{"key", "key2"}, ""},
+ {"key=value\nkey2=value2\nfoo=bar", "^(key|foo)", []string{"foo", "key", "key2"}, ""},
+ {"key=value\nkey2=value2\nfoo=bar", "[ abc", nil, "error parsing regexp.*"},
+}
+
+// ----------------------------------------------------------------------------
+
+var filterPrefixTests = []struct {
+ input string
+ prefix string
+ keys []string
+}{
+ {"", "", []string{}},
+ {"", "abc", []string{}},
+ {"key=value", "", []string{"key"}},
+ {"key=value", "key=", []string{}},
+ {"key=value\nfoo=bar", "", []string{"foo", "key"}},
+ {"key=value\nfoo=bar", "f", []string{"foo"}},
+ {"key=value\nfoo=bar", "fo", []string{"foo"}},
+ {"key=value\nfoo=bar", "foo", []string{"foo"}},
+ {"key=value\nfoo=bar", "fooo", []string{}},
+ {"key=value\nkey2=value2\nfoo=bar", "key", []string{"key", "key2"}},
+}
+
+// ----------------------------------------------------------------------------
+
+var setTests = []struct {
+ input string
+ key, value string
+ prev string
+ ok bool
+ err string
+ keys []string
+}{
+ {"", "", "", "", false, "", []string{}},
+ {"", "key", "value", "", false, "", []string{"key"}},
+ {"key=value", "key2", "value2", "", false, "", []string{"key", "key2"}},
+ {"key=value", "abc", "value3", "", false, "", []string{"key", "abc"}},
+ {"key=value", "key", "value3", "value", true, "", []string{"key"}},
+}
+
+// ----------------------------------------------------------------------------
+
+// TestBasic tests basic single key/value combinations with all possible
+// whitespace, delimiter and newline permutations.
+func (s *TestSuite) TestBasic(c *C) {
+ testWhitespaceAndDelimiterCombinations(c, "key", "")
+ testWhitespaceAndDelimiterCombinations(c, "key", "value")
+ testWhitespaceAndDelimiterCombinations(c, "key", "value ")
+}
+
+func (s *TestSuite) TestComplex(c *C) {
+ for _, test := range complexTests {
+ testKeyValue(c, test[0], test[1:]...)
+ }
+}
+
+func (s *TestSuite) TestErrors(c *C) {
+ for _, test := range errorTests {
+ _, err := Load([]byte(test.input), ISO_8859_1)
+ c.Assert(err, NotNil)
+ c.Assert(strings.Contains(err.Error(), test.msg), Equals, true, Commentf("Expected %q got %q", test.msg, err.Error()))
+ }
+}
+
+func (s *TestSuite) TestMustGet(c *C) {
+ input := "key = value\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGet("key"), Equals, "value")
+ c.Assert(func() { p.MustGet("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetBool(c *C) {
+ for _, test := range boolTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetBool(test.key, test.def), Equals, test.value)
+ }
+}
+
+func (s *TestSuite) TestMustGetBool(c *C) {
+ input := "key = true\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetBool("key"), Equals, true)
+ c.Assert(func() { p.MustGetBool("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetDuration(c *C) {
+ for _, test := range durationTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetDuration(test.key, test.def), Equals, test.value)
+ }
+}
+
+func (s *TestSuite) TestMustGetDuration(c *C) {
+ input := "key = 123\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetDuration("key"), Equals, time.Duration(123))
+ c.Assert(func() { p.MustGetDuration("key2") }, PanicMatches, "strconv.ParseInt: parsing.*")
+ c.Assert(func() { p.MustGetDuration("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetParsedDuration(c *C) {
+ for _, test := range parsedDurationTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetParsedDuration(test.key, test.def), Equals, test.value)
+ }
+}
+
+func (s *TestSuite) TestMustGetParsedDuration(c *C) {
+ input := "key = 123ms\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetParsedDuration("key"), Equals, 123*time.Millisecond)
+ c.Assert(func() { p.MustGetParsedDuration("key2") }, PanicMatches, "time: invalid duration ghi")
+ c.Assert(func() { p.MustGetParsedDuration("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetFloat64(c *C) {
+ for _, test := range floatTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetFloat64(test.key, test.def), Equals, test.value)
+ }
+}
+
+func (s *TestSuite) TestMustGetFloat64(c *C) {
+ input := "key = 123\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetFloat64("key"), Equals, float64(123))
+ c.Assert(func() { p.MustGetFloat64("key2") }, PanicMatches, "strconv.ParseFloat: parsing.*")
+ c.Assert(func() { p.MustGetFloat64("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetInt(c *C) {
+ for _, test := range int64Tests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetInt(test.key, int(test.def)), Equals, int(test.value))
+ }
+}
+
+func (s *TestSuite) TestMustGetInt(c *C) {
+ input := "key = 123\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetInt("key"), Equals, int(123))
+ c.Assert(func() { p.MustGetInt("key2") }, PanicMatches, "strconv.ParseInt: parsing.*")
+ c.Assert(func() { p.MustGetInt("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetInt64(c *C) {
+ for _, test := range int64Tests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetInt64(test.key, test.def), Equals, test.value)
+ }
+}
+
+func (s *TestSuite) TestMustGetInt64(c *C) {
+ input := "key = 123\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetInt64("key"), Equals, int64(123))
+ c.Assert(func() { p.MustGetInt64("key2") }, PanicMatches, "strconv.ParseInt: parsing.*")
+ c.Assert(func() { p.MustGetInt64("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetUint(c *C) {
+ for _, test := range uint64Tests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetUint(test.key, uint(test.def)), Equals, uint(test.value))
+ }
+}
+
+func (s *TestSuite) TestMustGetUint(c *C) {
+ input := "key = 123\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetUint("key"), Equals, uint(123))
+ c.Assert(func() { p.MustGetUint64("key2") }, PanicMatches, "strconv.ParseUint: parsing.*")
+ c.Assert(func() { p.MustGetUint64("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetUint64(c *C) {
+ for _, test := range uint64Tests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetUint64(test.key, test.def), Equals, test.value)
+ }
+}
+
+func (s *TestSuite) TestMustGetUint64(c *C) {
+ input := "key = 123\nkey2 = ghi"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetUint64("key"), Equals, uint64(123))
+ c.Assert(func() { p.MustGetUint64("key2") }, PanicMatches, "strconv.ParseUint: parsing.*")
+ c.Assert(func() { p.MustGetUint64("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestGetString(c *C) {
+ for _, test := range stringTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, 1)
+ c.Assert(p.GetString(test.key, test.def), Equals, test.value)
+ }
+}
+
+func (s *TestSuite) TestMustGetString(c *C) {
+ input := `key = value`
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetString("key"), Equals, "value")
+ c.Assert(func() { p.MustGetString("invalid") }, PanicMatches, "unknown property: invalid")
+}
+
+func (s *TestSuite) TestComment(c *C) {
+ for _, test := range commentTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetString(test.key), Equals, test.value)
+ c.Assert(p.GetComments(test.key), DeepEquals, test.comments)
+ if test.comments != nil {
+ c.Assert(p.GetComment(test.key), Equals, test.comments[len(test.comments)-1])
+ } else {
+ c.Assert(p.GetComment(test.key), Equals, "")
+ }
+
+ // test setting comments
+ if len(test.comments) > 0 {
+ // set single comment
+ p.ClearComments()
+ c.Assert(len(p.c), Equals, 0)
+ p.SetComment(test.key, test.comments[0])
+ c.Assert(p.GetComment(test.key), Equals, test.comments[0])
+
+ // set multiple comments
+ p.ClearComments()
+ c.Assert(len(p.c), Equals, 0)
+ p.SetComments(test.key, test.comments)
+ c.Assert(p.GetComments(test.key), DeepEquals, test.comments)
+
+ // clear comments for a key
+ p.SetComments(test.key, nil)
+ c.Assert(p.GetComment(test.key), Equals, "")
+ c.Assert(p.GetComments(test.key), IsNil)
+ }
+ }
+}
+
+func (s *TestSuite) TestFilter(c *C) {
+ for _, test := range filterTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ pp, err := p.Filter(test.pattern)
+ if err != nil {
+ c.Assert(err, ErrorMatches, test.err)
+ continue
+ }
+ c.Assert(pp, NotNil)
+ c.Assert(pp.Len(), Equals, len(test.keys))
+ for _, key := range test.keys {
+ v1, ok1 := p.Get(key)
+ v2, ok2 := pp.Get(key)
+ c.Assert(ok1, Equals, true)
+ c.Assert(ok2, Equals, true)
+ c.Assert(v1, Equals, v2)
+ }
+ }
+}
+
+func (s *TestSuite) TestFilterPrefix(c *C) {
+ for _, test := range filterPrefixTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ pp := p.FilterPrefix(test.prefix)
+ c.Assert(pp, NotNil)
+ c.Assert(pp.Len(), Equals, len(test.keys))
+ for _, key := range test.keys {
+ v1, ok1 := p.Get(key)
+ v2, ok2 := pp.Get(key)
+ c.Assert(ok1, Equals, true)
+ c.Assert(ok2, Equals, true)
+ c.Assert(v1, Equals, v2)
+ }
+ }
+}
+
+func (s *TestSuite) TestKeys(c *C) {
+ for _, test := range keysTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ c.Assert(p.Len(), Equals, len(test.keys))
+ c.Assert(len(p.Keys()), Equals, len(test.keys))
+ c.Assert(p.Keys(), DeepEquals, test.keys)
+ }
+}
+
+func (s *TestSuite) TestSet(c *C) {
+ for _, test := range setTests {
+ p, err := parse(test.input)
+ c.Assert(err, IsNil)
+ prev, ok, err := p.Set(test.key, test.value)
+ if test.err != "" {
+ c.Assert(err, ErrorMatches, test.err)
+ continue
+ }
+
+ c.Assert(err, IsNil)
+ c.Assert(ok, Equals, test.ok)
+ if ok {
+ c.Assert(prev, Equals, test.prev)
+ }
+ c.Assert(p.Keys(), DeepEquals, test.keys)
+ }
+}
+
+func (s *TestSuite) TestMustSet(c *C) {
+ input := "key=${key}"
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(func() { p.MustSet("key", "${key}") }, PanicMatches, "circular reference .*")
+}
+
+func (s *TestSuite) TestWrite(c *C) {
+ for _, test := range writeTests {
+ p, err := parse(test.input)
+
+ buf := new(bytes.Buffer)
+ var n int
+ switch test.encoding {
+ case "UTF-8":
+ n, err = p.Write(buf, UTF8)
+ case "ISO-8859-1":
+ n, err = p.Write(buf, ISO_8859_1)
+ }
+ c.Assert(err, IsNil)
+ s := string(buf.Bytes())
+ c.Assert(n, Equals, len(test.output), Commentf("input=%q expected=%q obtained=%q", test.input, test.output, s))
+ c.Assert(s, Equals, test.output, Commentf("input=%q expected=%q obtained=%q", test.input, test.output, s))
+ }
+}
+
+func (s *TestSuite) TestWriteComment(c *C) {
+ for _, test := range writeCommentTests {
+ p, err := parse(test.input)
+
+ buf := new(bytes.Buffer)
+ var n int
+ switch test.encoding {
+ case "UTF-8":
+ n, err = p.WriteComment(buf, "# ", UTF8)
+ case "ISO-8859-1":
+ n, err = p.WriteComment(buf, "# ", ISO_8859_1)
+ }
+ c.Assert(err, IsNil)
+ s := string(buf.Bytes())
+ c.Assert(n, Equals, len(test.output), Commentf("input=%q expected=%q obtained=%q", test.input, test.output, s))
+ c.Assert(s, Equals, test.output, Commentf("input=%q expected=%q obtained=%q", test.input, test.output, s))
+ }
+}
+
+func (s *TestSuite) TestCustomExpansionExpression(c *C) {
+ testKeyValuePrePostfix(c, "*[", "]*", "key=value\nkey2=*[key]*", "key", "value", "key2", "value")
+}
+
+func (s *TestSuite) TestPanicOn32BitIntOverflow(c *C) {
+ is32Bit = true
+ var min, max int64 = math.MinInt32 - 1, math.MaxInt32 + 1
+ input := fmt.Sprintf("min=%d\nmax=%d", min, max)
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetInt64("min"), Equals, min)
+ c.Assert(p.MustGetInt64("max"), Equals, max)
+ c.Assert(func() { p.MustGetInt("min") }, PanicMatches, ".* out of range")
+ c.Assert(func() { p.MustGetInt("max") }, PanicMatches, ".* out of range")
+}
+
+func (s *TestSuite) TestPanicOn32BitUintOverflow(c *C) {
+ is32Bit = true
+ var max = math.MaxUint32 + 1
+ input := fmt.Sprintf("max=%d", max)
+ p, err := parse(input)
+ c.Assert(err, IsNil)
+ c.Assert(p.MustGetUint64("max"), Equals, uint64(max))
+ c.Assert(func() { p.MustGetUint("max") }, PanicMatches, ".* out of range")
+}
+
+// ----------------------------------------------------------------------------
+
+// tests all combinations of delimiters, leading and/or trailing whitespace and newlines.
+func testWhitespaceAndDelimiterCombinations(c *C, key, value string) {
+ whitespace := []string{"", " ", "\f", "\t"}
+ delimiters := []string{"", " ", "=", ":"}
+ newlines := []string{"", "\r", "\n", "\r\n"}
+ for _, dl := range delimiters {
+ for _, ws1 := range whitespace {
+ for _, ws2 := range whitespace {
+ for _, nl := range newlines {
+ // skip the one case where there is nothing between a key and a value
+ if ws1 == "" && dl == "" && ws2 == "" && value != "" {
+ continue
+ }
+
+ input := fmt.Sprintf("%s%s%s%s%s%s", key, ws1, dl, ws2, value, nl)
+ testKeyValue(c, input, key, value)
+ }
+ }
+ }
+ }
+}
+
+// tests whether key/value pairs exist for a given input.
+// keyvalues is expected to be an even number of strings of "key", "value", ...
+func testKeyValue(c *C, input string, keyvalues ...string) {
+ testKeyValuePrePostfix(c, "${", "}", input, keyvalues...)
+}
+
+// tests whether key/value pairs exist for a given input.
+// keyvalues is expected to be an even number of strings of "key", "value", ...
+func testKeyValuePrePostfix(c *C, prefix, postfix, input string, keyvalues ...string) {
+ printf("%q\n", input)
+
+ p, err := Load([]byte(input), ISO_8859_1)
+ c.Assert(err, IsNil)
+ p.Prefix = prefix
+ p.Postfix = postfix
+ assertKeyValues(c, input, p, keyvalues...)
+}
+
+// tests whether key/value pairs exist for a given input.
+// keyvalues is expected to be an even number of strings of "key", "value", ...
+func assertKeyValues(c *C, input string, p *Properties, keyvalues ...string) {
+ c.Assert(p, NotNil)
+ c.Assert(2*p.Len(), Equals, len(keyvalues), Commentf("Odd number of key/value pairs."))
+
+ for i := 0; i < len(keyvalues); i += 2 {
+ key, value := keyvalues[i], keyvalues[i+1]
+ v, ok := p.Get(key)
+ c.Assert(ok, Equals, true, Commentf("No key %q found (input=%q)", key, input))
+ c.Assert(v, Equals, value, Commentf("Value %q does not match %q (input=%q)", v, value, input))
+ }
+}
+
+// prints to stderr if the -verbose flag was given.
+func printf(format string, args ...interface{}) {
+ if *verbose {
+ fmt.Fprintf(os.Stderr, format, args...)
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/magiconair/properties/rangecheck.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/magiconair/properties/rangecheck.go b/newt/Godeps/_workspace/src/github.com/magiconair/properties/rangecheck.go
new file mode 100644
index 0000000..6df4e6c
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/magiconair/properties/rangecheck.go
@@ -0,0 +1,31 @@
+// Copyright 2013-2014 Frank Schroeder. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package properties
+
+import (
+ "fmt"
+ "math"
+)
+
+// make this a var to overwrite it in a test
+var is32Bit = ^uint(0) == math.MaxUint32
+
+// intRangeCheck checks if the value fits into the int type and
+// panics if it does not.
+func intRangeCheck(key string, v int64) int {
+ if is32Bit && (v < math.MinInt32 || v > math.MaxInt32) {
+ panic(fmt.Sprintf("Value %d for key %s out of range", v, key))
+ }
+ return int(v)
+}
+
+// uintRangeCheck checks if the value fits into the uint type and
+// panics if it does not.
+func uintRangeCheck(key string, v uint64) uint {
+ if is32Bit && v > math.MaxUint32 {
+ panic(fmt.Sprintf("Value %d for key %s out of range", v, key))
+ }
+ return uint(v)
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.gitignore
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.gitignore b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.gitignore
new file mode 100644
index 0000000..bf90dfd
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.gitignore
@@ -0,0 +1,3 @@
+*.db
+*.exe
+*.dll
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml
new file mode 100644
index 0000000..ac7bfea
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+go:
+ - tip
+before_install:
+ - go get github.com/axw/gocov/gocov
+ - go get github.com/mattn/goveralls
+ - go get golang.org/x/tools/cmd/cover
+script:
+ - $HOME/gopath/bin/goveralls -repotoken 3qJVUE0iQwqnCbmNcDsjYu1nh4J4KIFXx
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/LICENSE
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/LICENSE b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/LICENSE
new file mode 100644
index 0000000..ca458bb
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Yasuhiro Matsumoto
+
+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/e95057f4/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/README.md
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/README.md b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/README.md
new file mode 100644
index 0000000..4383f0c
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/README.md
@@ -0,0 +1,62 @@
+go-sqlite3
+==========
+
+[](https://travis-ci.org/mattn/go-sqlite3)
+[](https://coveralls.io/r/mattn/go-sqlite3?branch=master)
+
+Description
+-----------
+
+sqlite3 driver conforming to the built-in database/sql interface
+
+Installation
+------------
+
+This package can be installed with the go get command:
+
+ go get github.com/mattn/go-sqlite3
+
+Documentation
+-------------
+
+API documentation can be found here: http://godoc.org/github.com/mattn/go-sqlite3
+
+Examples can be found under the `./_example` directory
+
+FAQ
+---
+
+* Can't build go-sqlite3 on windows 64bit.
+
+ > Probably, you are using go 1.0, go1.0 has a problem when it comes to compiling/linking on windows 64bit.
+ > See: https://github.com/mattn/go-sqlite3/issues/27
+
+* Getting insert error while query is opened.
+
+ > You can pass some arguments into the connection string, for example, a URI.
+ > See: https://github.com/mattn/go-sqlite3/issues/39
+
+* Do you want cross compiling? mingw on Linux or Mac?
+
+ > See: https://github.com/mattn/go-sqlite3/issues/106
+ > See also: http://www.limitlessfx.com/cross-compile-golang-app-for-windows-from-linux.html
+
+* Want to get time.Time with current locale
+
+ Use `loc=auto` in SQLite3 filename schema like `file:foo.db?loc=auto`.
+
+License
+-------
+
+MIT: http://mattn.mit-license.org/2012
+
+sqlite3-binding.c, sqlite3-binding.h, sqlite3ext.h
+
+The -binding suffix was added to avoid build failures under gccgo.
+
+In this repository, those files are amalgamation code that copied from SQLite3. The license of those codes are depend on the license of SQLite3.
+
+Author
+------
+
+Yasuhiro Matsumoto (a.k.a mattn)
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/backup.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/backup.go b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/backup.go
new file mode 100644
index 0000000..3807c60
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/backup.go
@@ -0,0 +1,70 @@
+// 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
+
+/*
+#include <sqlite3-binding.h>
+#include <stdlib.h>
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+type SQLiteBackup struct {
+ b *C.sqlite3_backup
+}
+
+func (c *SQLiteConn) Backup(dest string, conn *SQLiteConn, src string) (*SQLiteBackup, error) {
+ destptr := C.CString(dest)
+ defer C.free(unsafe.Pointer(destptr))
+ srcptr := C.CString(src)
+ defer C.free(unsafe.Pointer(srcptr))
+
+ if b := C.sqlite3_backup_init(c.db, destptr, conn.db, srcptr); b != nil {
+ bb := &SQLiteBackup{b: b}
+ runtime.SetFinalizer(bb, (*SQLiteBackup).Finish)
+ return bb, nil
+ }
+ return nil, c.lastError()
+}
+
+// Backs up for one step. Calls the underlying `sqlite3_backup_step` function.
+// This function returns a boolean indicating if the backup is done and
+// an error signalling any other error. Done is returned if the underlying C
+// function returns SQLITE_DONE (Code 101)
+func (b *SQLiteBackup) Step(p int) (bool, error) {
+ ret := C.sqlite3_backup_step(b.b, C.int(p))
+ if ret == C.SQLITE_DONE {
+ return true, nil
+ } else if ret != 0 && ret != C.SQLITE_LOCKED && ret != C.SQLITE_BUSY {
+ return false, Error{Code: ErrNo(ret)}
+ }
+ return false, nil
+}
+
+func (b *SQLiteBackup) Remaining() int {
+ return int(C.sqlite3_backup_remaining(b.b))
+}
+
+func (b *SQLiteBackup) PageCount() int {
+ return int(C.sqlite3_backup_pagecount(b.b))
+}
+
+func (b *SQLiteBackup) Finish() error {
+ return b.Close()
+}
+
+func (b *SQLiteBackup) Close() error {
+ ret := C.sqlite3_backup_finish(b.b)
+ if ret != 0 {
+ return Error{Code: ErrNo(ret)}
+ }
+ b.b = nil
+ runtime.SetFinalizer(b, nil)
+ return nil
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/doc.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/doc.go b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/doc.go
new file mode 100644
index 0000000..51364c3
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/doc.go
@@ -0,0 +1,95 @@
+/*
+Package sqlite3 provides interface to SQLite3 databases.
+
+This works as driver for database/sql.
+
+Installation
+
+ go get github.com/mattn/go-sqlite3
+
+Supported Types
+
+Currently, go-sqlite3 support following data types.
+
+ +------------------------------+
+ |go | sqlite3 |
+ |----------|-------------------|
+ |nil | null |
+ |int | integer |
+ |int64 | integer |
+ |float64 | float |
+ |bool | integer |
+ |[]byte | blob |
+ |string | text |
+ |time.Time | timestamp/datetime|
+ +------------------------------+
+
+SQLite3 Extension
+
+You can write your own extension module for sqlite3. For example, below is a
+extension for Regexp matcher operation.
+
+ #include <pcre.h>
+ #include <string.h>
+ #include <stdio.h>
+ #include <sqlite3ext.h>
+
+ SQLITE_EXTENSION_INIT1
+ static void regexp_func(sqlite3_context *context, int argc, sqlite3_value **argv) {
+ if (argc >= 2) {
+ const char *target = (const char *)sqlite3_value_text(argv[1]);
+ const char *pattern = (const char *)sqlite3_value_text(argv[0]);
+ const char* errstr = NULL;
+ int erroff = 0;
+ int vec[500];
+ int n, rc;
+ pcre* re = pcre_compile(pattern, 0, &errstr, &erroff, NULL);
+ rc = pcre_exec(re, NULL, target, strlen(target), 0, 0, vec, 500);
+ if (rc <= 0) {
+ sqlite3_result_error(context, errstr, 0);
+ return;
+ }
+ sqlite3_result_int(context, 1);
+ }
+ }
+
+ #ifdef _WIN32
+ __declspec(dllexport)
+ #endif
+ int sqlite3_extension_init(sqlite3 *db, char **errmsg,
+ const sqlite3_api_routines *api) {
+ SQLITE_EXTENSION_INIT2(api);
+ return sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8,
+ (void*)db, regexp_func, NULL, NULL);
+ }
+
+It need to build as so/dll shared library. And you need to register
+extension module like below.
+
+ sql.Register("sqlite3_with_extensions",
+ &sqlite3.SQLiteDriver{
+ Extensions: []string{
+ "sqlite3_mod_regexp",
+ },
+ })
+
+Then, you can use this extension.
+
+ rows, err := db.Query("select text from mytable where name regexp '^golang'")
+
+Connection Hook
+
+You can hook and inject your codes when connection established. database/sql
+doesn't provide the way to get native go-sqlite3 interfaces. So if you want,
+you need to hook ConnectHook and get the SQLiteConn.
+
+ sql.Register("sqlite3_with_hook_example",
+ &sqlite3.SQLiteDriver{
+ ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+ sqlite3conn = append(sqlite3conn, conn)
+ return nil
+ },
+ })
+
+*/
+package sqlite3
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/error.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/error.go b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/error.go
new file mode 100644
index 0000000..b910108
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/error.go
@@ -0,0 +1,128 @@
+// 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 "C"
+
+type ErrNo int
+
+const ErrNoMask C.int = 0xff
+
+type ErrNoExtended int
+
+type Error struct {
+ Code ErrNo /* The error code returned by SQLite */
+ ExtendedCode ErrNoExtended /* The extended error code returned by SQLite */
+ err string /* The error string returned by sqlite3_errmsg(),
+ this usually contains more specific details. */
+}
+
+// result codes from http://www.sqlite.org/c3ref/c_abort.html
+var (
+ ErrError = ErrNo(1) /* SQL error or missing database */
+ ErrInternal = ErrNo(2) /* Internal logic error in SQLite */
+ ErrPerm = ErrNo(3) /* Access permission denied */
+ ErrAbort = ErrNo(4) /* Callback routine requested an abort */
+ ErrBusy = ErrNo(5) /* The database file is locked */
+ ErrLocked = ErrNo(6) /* A table in the database is locked */
+ ErrNomem = ErrNo(7) /* A malloc() failed */
+ ErrReadonly = ErrNo(8) /* Attempt to write a readonly database */
+ ErrInterrupt = ErrNo(9) /* Operation terminated by sqlite3_interrupt() */
+ ErrIoErr = ErrNo(10) /* Some kind of disk I/O error occurred */
+ ErrCorrupt = ErrNo(11) /* The database disk image is malformed */
+ ErrNotFound = ErrNo(12) /* Unknown opcode in sqlite3_file_control() */
+ ErrFull = ErrNo(13) /* Insertion failed because database is full */
+ ErrCantOpen = ErrNo(14) /* Unable to open the database file */
+ ErrProtocol = ErrNo(15) /* Database lock protocol error */
+ ErrEmpty = ErrNo(16) /* Database is empty */
+ ErrSchema = ErrNo(17) /* The database schema changed */
+ ErrTooBig = ErrNo(18) /* String or BLOB exceeds size limit */
+ ErrConstraint = ErrNo(19) /* Abort due to constraint violation */
+ ErrMismatch = ErrNo(20) /* Data type mismatch */
+ ErrMisuse = ErrNo(21) /* Library used incorrectly */
+ ErrNoLFS = ErrNo(22) /* Uses OS features not supported on host */
+ ErrAuth = ErrNo(23) /* Authorization denied */
+ ErrFormat = ErrNo(24) /* Auxiliary database format error */
+ ErrRange = ErrNo(25) /* 2nd parameter to sqlite3_bind out of range */
+ ErrNotADB = ErrNo(26) /* File opened that is not a database file */
+ ErrNotice = ErrNo(27) /* Notifications from sqlite3_log() */
+ ErrWarning = ErrNo(28) /* Warnings from sqlite3_log() */
+)
+
+func (err ErrNo) Error() string {
+ return Error{Code: err}.Error()
+}
+
+func (err ErrNo) Extend(by int) ErrNoExtended {
+ return ErrNoExtended(int(err) | (by << 8))
+}
+
+func (err ErrNoExtended) Error() string {
+ return Error{Code: ErrNo(C.int(err) & ErrNoMask), ExtendedCode: err}.Error()
+}
+
+func (err Error) Error() string {
+ if err.err != "" {
+ return err.err
+ }
+ return errorString(err)
+}
+
+// result codes from http://www.sqlite.org/c3ref/c_abort_rollback.html
+var (
+ ErrIoErrRead = ErrIoErr.Extend(1)
+ ErrIoErrShortRead = ErrIoErr.Extend(2)
+ ErrIoErrWrite = ErrIoErr.Extend(3)
+ ErrIoErrFsync = ErrIoErr.Extend(4)
+ ErrIoErrDirFsync = ErrIoErr.Extend(5)
+ ErrIoErrTruncate = ErrIoErr.Extend(6)
+ ErrIoErrFstat = ErrIoErr.Extend(7)
+ ErrIoErrUnlock = ErrIoErr.Extend(8)
+ ErrIoErrRDlock = ErrIoErr.Extend(9)
+ ErrIoErrDelete = ErrIoErr.Extend(10)
+ ErrIoErrBlocked = ErrIoErr.Extend(11)
+ ErrIoErrNoMem = ErrIoErr.Extend(12)
+ ErrIoErrAccess = ErrIoErr.Extend(13)
+ ErrIoErrCheckReservedLock = ErrIoErr.Extend(14)
+ ErrIoErrLock = ErrIoErr.Extend(15)
+ ErrIoErrClose = ErrIoErr.Extend(16)
+ ErrIoErrDirClose = ErrIoErr.Extend(17)
+ ErrIoErrSHMOpen = ErrIoErr.Extend(18)
+ ErrIoErrSHMSize = ErrIoErr.Extend(19)
+ ErrIoErrSHMLock = ErrIoErr.Extend(20)
+ ErrIoErrSHMMap = ErrIoErr.Extend(21)
+ ErrIoErrSeek = ErrIoErr.Extend(22)
+ ErrIoErrDeleteNoent = ErrIoErr.Extend(23)
+ ErrIoErrMMap = ErrIoErr.Extend(24)
+ ErrIoErrGetTempPath = ErrIoErr.Extend(25)
+ ErrIoErrConvPath = ErrIoErr.Extend(26)
+ ErrLockedSharedCache = ErrLocked.Extend(1)
+ ErrBusyRecovery = ErrBusy.Extend(1)
+ ErrBusySnapshot = ErrBusy.Extend(2)
+ ErrCantOpenNoTempDir = ErrCantOpen.Extend(1)
+ ErrCantOpenIsDir = ErrCantOpen.Extend(2)
+ ErrCantOpenFullPath = ErrCantOpen.Extend(3)
+ ErrCantOpenConvPath = ErrCantOpen.Extend(4)
+ ErrCorruptVTab = ErrCorrupt.Extend(1)
+ ErrReadonlyRecovery = ErrReadonly.Extend(1)
+ ErrReadonlyCantLock = ErrReadonly.Extend(2)
+ ErrReadonlyRollback = ErrReadonly.Extend(3)
+ ErrReadonlyDbMoved = ErrReadonly.Extend(4)
+ ErrAbortRollback = ErrAbort.Extend(2)
+ ErrConstraintCheck = ErrConstraint.Extend(1)
+ ErrConstraintCommitHook = ErrConstraint.Extend(2)
+ ErrConstraintForeignKey = ErrConstraint.Extend(3)
+ ErrConstraintFunction = ErrConstraint.Extend(4)
+ ErrConstraintNotNull = ErrConstraint.Extend(5)
+ ErrConstraintPrimaryKey = ErrConstraint.Extend(6)
+ ErrConstraintTrigger = ErrConstraint.Extend(7)
+ ErrConstraintUnique = ErrConstraint.Extend(8)
+ ErrConstraintVTab = ErrConstraint.Extend(9)
+ ErrConstraintRowId = ErrConstraint.Extend(10)
+ ErrNoticeRecoverWAL = ErrNotice.Extend(1)
+ ErrNoticeRecoverRollback = ErrNotice.Extend(2)
+ ErrWarningAutoIndex = ErrWarning.Extend(1)
+)
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/error_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/error_test.go b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/error_test.go
new file mode 100644
index 0000000..1ccbe5b
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/mattn/go-sqlite3/error_test.go
@@ -0,0 +1,242 @@
+// 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"
+ "io/ioutil"
+ "os"
+ "path"
+ "testing"
+)
+
+func TestSimpleError(t *testing.T) {
+ e := ErrError.Error()
+ if e != "SQL logic error or missing database" {
+ t.Error("wrong error code:" + e)
+ }
+}
+
+func TestCorruptDbErrors(t *testing.T) {
+ dirName, err := ioutil.TempDir("", "sqlite3")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer os.RemoveAll(dirName)
+
+ dbFileName := path.Join(dirName, "test.db")
+ f, err := os.Create(dbFileName)
+ if err != nil {
+ t.Error(err)
+ }
+ f.Write([]byte{1, 2, 3, 4, 5})
+ f.Close()
+
+ db, err := sql.Open("sqlite3", dbFileName)
+ if err == nil {
+ _, err = db.Exec("drop table foo")
+ }
+
+ sqliteErr := err.(Error)
+ if sqliteErr.Code != ErrNotADB {
+ t.Error("wrong error code for corrupted DB")
+ }
+ if err.Error() == "" {
+ t.Error("wrong error string for corrupted DB")
+ }
+ db.Close()
+}
+
+func TestSqlLogicErrors(t *testing.T) {
+ dirName, err := ioutil.TempDir("", "sqlite3")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer os.RemoveAll(dirName)
+
+ dbFileName := path.Join(dirName, "test.db")
+ db, err := sql.Open("sqlite3", dbFileName)
+ if err != nil {
+ t.Error(err)
+ }
+ defer db.Close()
+
+ _, err = db.Exec("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
+ if err != nil {
+ t.Error(err)
+ }
+
+ const expectedErr = "table Foo already exists"
+ _, err = db.Exec("CREATE TABLE Foo (id INTEGER PRIMARY KEY)")
+ if err.Error() != expectedErr {
+ t.Errorf("Unexpected error: %s, expected %s", err.Error(), expectedErr)
+ }
+
+}
+
+func TestExtendedErrorCodes_ForeignKey(t *testing.T) {
+ dirName, err := ioutil.TempDir("", "sqlite3-err")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer os.RemoveAll(dirName)
+
+ dbFileName := path.Join(dirName, "test.db")
+ db, err := sql.Open("sqlite3", dbFileName)
+ if err != nil {
+ t.Error(err)
+ }
+ defer db.Close()
+
+ _, err = db.Exec("PRAGMA foreign_keys=ON;")
+ if err != nil {
+ t.Errorf("PRAGMA foreign_keys=ON: %v", err)
+ }
+
+ _, err = db.Exec(`CREATE TABLE Foo (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ value INTEGER NOT NULL,
+ ref INTEGER NULL REFERENCES Foo (id),
+ UNIQUE(value)
+ );`)
+ if err != nil {
+ t.Error(err)
+ }
+
+ _, err = db.Exec("INSERT INTO Foo (ref, value) VALUES (100, 100);")
+ if err == nil {
+ t.Error("No error!")
+ } else {
+ sqliteErr := err.(Error)
+ if sqliteErr.Code != ErrConstraint {
+ t.Errorf("Wrong basic error code: %d != %d",
+ sqliteErr.Code, ErrConstraint)
+ }
+ if sqliteErr.ExtendedCode != ErrConstraintForeignKey {
+ t.Errorf("Wrong extended error code: %d != %d",
+ sqliteErr.ExtendedCode, ErrConstraintForeignKey)
+ }
+ }
+
+}
+
+func TestExtendedErrorCodes_NotNull(t *testing.T) {
+ dirName, err := ioutil.TempDir("", "sqlite3-err")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer os.RemoveAll(dirName)
+
+ dbFileName := path.Join(dirName, "test.db")
+ db, err := sql.Open("sqlite3", dbFileName)
+ if err != nil {
+ t.Error(err)
+ }
+ defer db.Close()
+
+ _, err = db.Exec("PRAGMA foreign_keys=ON;")
+ if err != nil {
+ t.Errorf("PRAGMA foreign_keys=ON: %v", err)
+ }
+
+ _, err = db.Exec(`CREATE TABLE Foo (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ value INTEGER NOT NULL,
+ ref INTEGER NULL REFERENCES Foo (id),
+ UNIQUE(value)
+ );`)
+ if err != nil {
+ t.Error(err)
+ }
+
+ res, err := db.Exec("INSERT INTO Foo (value) VALUES (100);")
+ if err != nil {
+ t.Fatalf("Creating first row: %v", err)
+ }
+
+ id, err := res.LastInsertId()
+ if err != nil {
+ t.Fatalf("Retrieving last insert id: %v", err)
+ }
+
+ _, err = db.Exec("INSERT INTO Foo (ref) VALUES (?);", id)
+ if err == nil {
+ t.Error("No error!")
+ } else {
+ sqliteErr := err.(Error)
+ if sqliteErr.Code != ErrConstraint {
+ t.Errorf("Wrong basic error code: %d != %d",
+ sqliteErr.Code, ErrConstraint)
+ }
+ if sqliteErr.ExtendedCode != ErrConstraintNotNull {
+ t.Errorf("Wrong extended error code: %d != %d",
+ sqliteErr.ExtendedCode, ErrConstraintNotNull)
+ }
+ }
+
+}
+
+func TestExtendedErrorCodes_Unique(t *testing.T) {
+ dirName, err := ioutil.TempDir("", "sqlite3-err")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer os.RemoveAll(dirName)
+
+ dbFileName := path.Join(dirName, "test.db")
+ db, err := sql.Open("sqlite3", dbFileName)
+ if err != nil {
+ t.Error(err)
+ }
+ defer db.Close()
+
+ _, err = db.Exec("PRAGMA foreign_keys=ON;")
+ if err != nil {
+ t.Errorf("PRAGMA foreign_keys=ON: %v", err)
+ }
+
+ _, err = db.Exec(`CREATE TABLE Foo (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ value INTEGER NOT NULL,
+ ref INTEGER NULL REFERENCES Foo (id),
+ UNIQUE(value)
+ );`)
+ if err != nil {
+ t.Error(err)
+ }
+
+ res, err := db.Exec("INSERT INTO Foo (value) VALUES (100);")
+ if err != nil {
+ t.Fatalf("Creating first row: %v", err)
+ }
+
+ id, err := res.LastInsertId()
+ if err != nil {
+ t.Fatalf("Retrieving last insert id: %v", err)
+ }
+
+ _, err = db.Exec("INSERT INTO Foo (ref, value) VALUES (?, 100);", id)
+ if err == nil {
+ t.Error("No error!")
+ } else {
+ sqliteErr := err.(Error)
+ if sqliteErr.Code != ErrConstraint {
+ t.Errorf("Wrong basic error code: %d != %d",
+ sqliteErr.Code, ErrConstraint)
+ }
+ if sqliteErr.ExtendedCode != ErrConstraintUnique {
+ t.Errorf("Wrong extended error code: %d != %d",
+ sqliteErr.ExtendedCode, ErrConstraintUnique)
+ }
+ extended := sqliteErr.Code.Extend(3).Error()
+ expected := "constraint failed"
+ if extended != expected {
+ t.Errorf("Wrong basic error code: %q != %q",
+ extended, expected)
+ }
+ }
+
+}