first commit
This commit is contained in:
朱毅骏
commit
37ad08b2a4
21
.travis.yml
Normal file
21
.travis.yml
Normal file
@ -0,0 +1,21 @@
|
||||
language: go
|
||||
sudo: false
|
||||
go:
|
||||
- 1.6.x
|
||||
- 1.7.x
|
||||
- 1.8.x
|
||||
- 1.9.x
|
||||
- 1.10.x
|
||||
- 1.11.x
|
||||
- tip
|
||||
matrix:
|
||||
allow_failures:
|
||||
- go: tip
|
||||
fast_finish: true
|
||||
before_install:
|
||||
- go get github.com/mattn/goveralls
|
||||
- go get golang.org/x/tools/cmd/cover
|
||||
script:
|
||||
- $HOME/gopath/bin/goveralls -service=travis-ci
|
||||
notifications:
|
||||
email: false
|
||||
20
LICENSE
Normal file
20
LICENSE
Normal file
@ -0,0 +1,20 @@
|
||||
Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
|
||||
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.
|
||||
75
README.md
Normal file
75
README.md
Normal file
@ -0,0 +1,75 @@
|
||||
# UUID package for Go language
|
||||
|
||||
[](https://travis-ci.org/satori/go.uuid)
|
||||
[](https://coveralls.io/github/satori/go.uuid)
|
||||
[](http://godoc.org/github.com/satori/go.uuid)
|
||||
|
||||
This package provides pure Go implementation of Universally Unique Identifier (UUID). Supported both creation and parsing of UUIDs.
|
||||
|
||||
With 100% test coverage and benchmarks out of box.
|
||||
|
||||
Supported versions:
|
||||
* Version 1, based on timestamp and MAC address (RFC 4122)
|
||||
* Version 2, based on timestamp, MAC address and POSIX UID/GID (DCE 1.1)
|
||||
* Version 3, based on MD5 hashing (RFC 4122)
|
||||
* Version 4, based on random numbers (RFC 4122)
|
||||
* Version 5, based on SHA-1 hashing (RFC 4122)
|
||||
|
||||
## Installation
|
||||
|
||||
Use the `go` command:
|
||||
|
||||
$ go get github.com/satori/go.uuid
|
||||
|
||||
## Requirements
|
||||
|
||||
UUID package tested against Go >= 1.6.
|
||||
|
||||
## Example
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/satori/go.uuid"
|
||||
)
|
||||
|
||||
func main() {
|
||||
// Creating UUID Version 4
|
||||
// panic on error
|
||||
u1 := uuid.Must(uuid.NewV4())
|
||||
fmt.Printf("UUIDv4: %s\n", u1)
|
||||
|
||||
// or error handling
|
||||
u2, err := uuid.NewV4()
|
||||
if err != nil {
|
||||
fmt.Printf("Something went wrong: %s", err)
|
||||
return
|
||||
}
|
||||
fmt.Printf("UUIDv4: %s\n", u2)
|
||||
|
||||
// Parsing UUID from string input
|
||||
u2, err := uuid.FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
|
||||
if err != nil {
|
||||
fmt.Printf("Something went wrong: %s", err)
|
||||
return
|
||||
}
|
||||
fmt.Printf("Successfully parsed: %s", u2)
|
||||
}
|
||||
```
|
||||
|
||||
## Documentation
|
||||
|
||||
[Documentation](http://godoc.org/github.com/satori/go.uuid) is hosted at GoDoc project.
|
||||
|
||||
## Links
|
||||
* [RFC 4122](http://tools.ietf.org/html/rfc4122)
|
||||
* [DCE 1.1: Authentication and Security Services](http://pubs.opengroup.org/onlinepubs/9696989899/chap5.htm#tagcjh_08_02_01_01)
|
||||
|
||||
## Copyright
|
||||
|
||||
Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>.
|
||||
|
||||
UUID package released under MIT License.
|
||||
See [LICENSE](https://github.com/satori/go.uuid/blob/master/LICENSE) for details.
|
||||
206
codec.go
Normal file
206
codec.go
Normal file
@ -0,0 +1,206 @@
|
||||
// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
//
|
||||
// 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.
|
||||
|
||||
package uuid
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// FromBytes returns UUID converted from raw byte slice input.
|
||||
// It will return error if the slice isn't 16 bytes long.
|
||||
func FromBytes(input []byte) (u UUID, err error) {
|
||||
err = u.UnmarshalBinary(input)
|
||||
return
|
||||
}
|
||||
|
||||
// FromBytesOrNil returns UUID converted from raw byte slice input.
|
||||
// Same behavior as FromBytes, but returns a Nil UUID on error.
|
||||
func FromBytesOrNil(input []byte) UUID {
|
||||
uuid, err := FromBytes(input)
|
||||
if err != nil {
|
||||
return Nil
|
||||
}
|
||||
return uuid
|
||||
}
|
||||
|
||||
// FromString returns UUID parsed from string input.
|
||||
// Input is expected in a form accepted by UnmarshalText.
|
||||
func FromString(input string) (u UUID, err error) {
|
||||
err = u.UnmarshalText([]byte(input))
|
||||
return
|
||||
}
|
||||
|
||||
// FromStringOrNil returns UUID parsed from string input.
|
||||
// Same behavior as FromString, but returns a Nil UUID on error.
|
||||
func FromStringOrNil(input string) UUID {
|
||||
uuid, err := FromString(input)
|
||||
if err != nil {
|
||||
return Nil
|
||||
}
|
||||
return uuid
|
||||
}
|
||||
|
||||
// MarshalText implements the encoding.TextMarshaler interface.
|
||||
// The encoding is the same as returned by String.
|
||||
func (u UUID) MarshalText() (text []byte, err error) {
|
||||
text = []byte(u.String())
|
||||
return
|
||||
}
|
||||
|
||||
// UnmarshalText implements the encoding.TextUnmarshaler interface.
|
||||
// Following formats are supported:
|
||||
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
|
||||
// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
|
||||
// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
|
||||
// "6ba7b8109dad11d180b400c04fd430c8"
|
||||
// ABNF for supported UUID text representation follows:
|
||||
// uuid := canonical | hashlike | braced | urn
|
||||
// plain := canonical | hashlike
|
||||
// canonical := 4hexoct '-' 2hexoct '-' 2hexoct '-' 6hexoct
|
||||
// hashlike := 12hexoct
|
||||
// braced := '{' plain '}'
|
||||
// urn := URN ':' UUID-NID ':' plain
|
||||
// URN := 'urn'
|
||||
// UUID-NID := 'uuid'
|
||||
// 12hexoct := 6hexoct 6hexoct
|
||||
// 6hexoct := 4hexoct 2hexoct
|
||||
// 4hexoct := 2hexoct 2hexoct
|
||||
// 2hexoct := hexoct hexoct
|
||||
// hexoct := hexdig hexdig
|
||||
// hexdig := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |
|
||||
// 'a' | 'b' | 'c' | 'd' | 'e' | 'f' |
|
||||
// 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
|
||||
func (u *UUID) UnmarshalText(text []byte) (err error) {
|
||||
switch len(text) {
|
||||
case 32:
|
||||
return u.decodeHashLike(text)
|
||||
case 36:
|
||||
return u.decodeCanonical(text)
|
||||
case 38:
|
||||
return u.decodeBraced(text)
|
||||
case 41:
|
||||
fallthrough
|
||||
case 45:
|
||||
return u.decodeURN(text)
|
||||
default:
|
||||
return fmt.Errorf("uuid: incorrect UUID length: %s", text)
|
||||
}
|
||||
}
|
||||
|
||||
// decodeCanonical decodes UUID string in format
|
||||
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8".
|
||||
func (u *UUID) decodeCanonical(t []byte) (err error) {
|
||||
if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' {
|
||||
return fmt.Errorf("uuid: incorrect UUID format %s", t)
|
||||
}
|
||||
|
||||
src := t[:]
|
||||
dst := u[:]
|
||||
|
||||
for i, byteGroup := range byteGroups {
|
||||
if i > 0 {
|
||||
src = src[1:] // skip dash
|
||||
}
|
||||
_, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
src = src[byteGroup:]
|
||||
dst = dst[byteGroup/2:]
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// decodeHashLike decodes UUID string in format
|
||||
// "6ba7b8109dad11d180b400c04fd430c8".
|
||||
func (u *UUID) decodeHashLike(t []byte) (err error) {
|
||||
src := t[:]
|
||||
dst := u[:]
|
||||
|
||||
if _, err = hex.Decode(dst, src); err != nil {
|
||||
return err
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// decodeBraced decodes UUID string in format
|
||||
// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}" or in format
|
||||
// "{6ba7b8109dad11d180b400c04fd430c8}".
|
||||
func (u *UUID) decodeBraced(t []byte) (err error) {
|
||||
l := len(t)
|
||||
|
||||
if t[0] != '{' || t[l-1] != '}' {
|
||||
return fmt.Errorf("uuid: incorrect UUID format %s", t)
|
||||
}
|
||||
|
||||
return u.decodePlain(t[1 : l-1])
|
||||
}
|
||||
|
||||
// decodeURN decodes UUID string in format
|
||||
// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in format
|
||||
// "urn:uuid:6ba7b8109dad11d180b400c04fd430c8".
|
||||
func (u *UUID) decodeURN(t []byte) (err error) {
|
||||
total := len(t)
|
||||
|
||||
urn_uuid_prefix := t[:9]
|
||||
|
||||
if !bytes.Equal(urn_uuid_prefix, urnPrefix) {
|
||||
return fmt.Errorf("uuid: incorrect UUID format: %s", t)
|
||||
}
|
||||
|
||||
return u.decodePlain(t[9:total])
|
||||
}
|
||||
|
||||
// decodePlain decodes UUID string in canonical format
|
||||
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in hash-like format
|
||||
// "6ba7b8109dad11d180b400c04fd430c8".
|
||||
func (u *UUID) decodePlain(t []byte) (err error) {
|
||||
switch len(t) {
|
||||
case 32:
|
||||
return u.decodeHashLike(t)
|
||||
case 36:
|
||||
return u.decodeCanonical(t)
|
||||
default:
|
||||
return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
|
||||
}
|
||||
}
|
||||
|
||||
// MarshalBinary implements the encoding.BinaryMarshaler interface.
|
||||
func (u UUID) MarshalBinary() (data []byte, err error) {
|
||||
data = u.Bytes()
|
||||
return
|
||||
}
|
||||
|
||||
// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
|
||||
// It will return error if the slice isn't 16 bytes long.
|
||||
func (u *UUID) UnmarshalBinary(data []byte) (err error) {
|
||||
if len(data) != Size {
|
||||
err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
|
||||
return
|
||||
}
|
||||
copy(u[:], data)
|
||||
|
||||
return
|
||||
}
|
||||
251
codec_test.go
Normal file
251
codec_test.go
Normal file
@ -0,0 +1,251 @@
|
||||
// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
//
|
||||
// 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.
|
||||
|
||||
package uuid
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
|
||||
. "gopkg.in/check.v1"
|
||||
)
|
||||
|
||||
type codecTestSuite struct{}
|
||||
|
||||
var _ = Suite(&codecTestSuite{})
|
||||
|
||||
func (s *codecTestSuite) TestFromBytes(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
b1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
|
||||
u1, err := FromBytes(b1)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1, Equals, u)
|
||||
|
||||
b2 := []byte{}
|
||||
_, err = FromBytes(b2)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) BenchmarkFromBytes(c *C) {
|
||||
bytes := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
for i := 0; i < c.N; i++ {
|
||||
FromBytes(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestMarshalBinary(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
b1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
|
||||
b2, err := u.MarshalBinary()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(bytes.Equal(b1, b2), Equals, true)
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) BenchmarkMarshalBinary(c *C) {
|
||||
u, err := NewV4()
|
||||
c.Assert(err, IsNil)
|
||||
for i := 0; i < c.N; i++ {
|
||||
u.MarshalBinary()
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestUnmarshalBinary(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
b1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
|
||||
u1 := UUID{}
|
||||
err := u1.UnmarshalBinary(b1)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1, Equals, u)
|
||||
|
||||
b2 := []byte{}
|
||||
u2 := UUID{}
|
||||
err = u2.UnmarshalBinary(b2)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestFromString(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
|
||||
s1 := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
|
||||
s2 := "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}"
|
||||
s3 := "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
|
||||
s4 := "6ba7b8109dad11d180b400c04fd430c8"
|
||||
s5 := "urn:uuid:6ba7b8109dad11d180b400c04fd430c8"
|
||||
|
||||
_, err := FromString("")
|
||||
c.Assert(err, NotNil)
|
||||
|
||||
u1, err := FromString(s1)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1, Equals, u)
|
||||
|
||||
u2, err := FromString(s2)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u2, Equals, u)
|
||||
|
||||
u3, err := FromString(s3)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u3, Equals, u)
|
||||
|
||||
u4, err := FromString(s4)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u4, Equals, u)
|
||||
|
||||
u5, err := FromString(s5)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u5, Equals, u)
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) BenchmarkFromString(c *C) {
|
||||
str := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
|
||||
for i := 0; i < c.N; i++ {
|
||||
FromString(str)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) BenchmarkFromStringUrn(c *C) {
|
||||
str := "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
|
||||
for i := 0; i < c.N; i++ {
|
||||
FromString(str)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) BenchmarkFromStringWithBrackets(c *C) {
|
||||
str := "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}"
|
||||
for i := 0; i < c.N; i++ {
|
||||
FromString(str)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestFromStringShort(c *C) {
|
||||
// Invalid 35-character UUID string
|
||||
s1 := "6ba7b810-9dad-11d1-80b4-00c04fd430c"
|
||||
|
||||
for i := len(s1); i >= 0; i-- {
|
||||
_, err := FromString(s1[:i])
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestFromStringLong(c *C) {
|
||||
// Invalid 37+ character UUID string
|
||||
strings := []string{
|
||||
"6ba7b810-9dad-11d1-80b4-00c04fd430c8=",
|
||||
"6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
|
||||
"{6ba7b810-9dad-11d1-80b4-00c04fd430c8}f",
|
||||
"6ba7b810-9dad-11d1-80b4-00c04fd430c800c04fd430c8",
|
||||
}
|
||||
|
||||
for _, str := range strings {
|
||||
_, err := FromString(str)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestFromStringInvalid(c *C) {
|
||||
// Invalid UUID string formats
|
||||
strings := []string{
|
||||
"6ba7b8109dad11d180b400c04fd430c86ba7b8109dad11d180b400c04fd430c8",
|
||||
"urn:uuid:{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
|
||||
"uuid:urn:6ba7b810-9dad-11d1-80b4-00c04fd430c8",
|
||||
"uuid:urn:6ba7b8109dad11d180b400c04fd430c8",
|
||||
"6ba7b8109-dad-11d1-80b4-00c04fd430c8",
|
||||
"6ba7b810-9dad1-1d1-80b4-00c04fd430c8",
|
||||
"6ba7b810-9dad-11d18-0b4-00c04fd430c8",
|
||||
"6ba7b810-9dad-11d1-80b40-0c04fd430c8",
|
||||
"6ba7b810+9dad+11d1+80b4+00c04fd430c8",
|
||||
"(6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
|
||||
"{6ba7b810-9dad-11d1-80b4-00c04fd430c8>",
|
||||
"zba7b810-9dad-11d1-80b4-00c04fd430c8",
|
||||
"6ba7b810-9dad11d180b400c04fd430c8",
|
||||
"6ba7b8109dad-11d180b400c04fd430c8",
|
||||
"6ba7b8109dad11d1-80b400c04fd430c8",
|
||||
"6ba7b8109dad11d180b4-00c04fd430c8",
|
||||
}
|
||||
|
||||
for _, str := range strings {
|
||||
_, err := FromString(str)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestFromStringOrNil(c *C) {
|
||||
u := FromStringOrNil("")
|
||||
c.Assert(u, Equals, Nil)
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestFromBytesOrNil(c *C) {
|
||||
b := []byte{}
|
||||
u := FromBytesOrNil(b)
|
||||
c.Assert(u, Equals, Nil)
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestMarshalText(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
b1 := []byte("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
|
||||
|
||||
b2, err := u.MarshalText()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(bytes.Equal(b1, b2), Equals, true)
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) BenchmarkMarshalText(c *C) {
|
||||
u, err := NewV4()
|
||||
c.Assert(err, IsNil)
|
||||
for i := 0; i < c.N; i++ {
|
||||
u.MarshalText()
|
||||
}
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) TestUnmarshalText(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
b1 := []byte("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
|
||||
|
||||
u1 := UUID{}
|
||||
err := u1.UnmarshalText(b1)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1, Equals, u)
|
||||
|
||||
b2 := []byte("")
|
||||
u2 := UUID{}
|
||||
err = u2.UnmarshalText(b2)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
|
||||
func (s *codecTestSuite) BenchmarkUnmarshalText(c *C) {
|
||||
bytes := []byte("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
|
||||
u := UUID{}
|
||||
for i := 0; i < c.N; i++ {
|
||||
u.UnmarshalText(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
var sink string
|
||||
|
||||
func (s *codecTestSuite) BenchmarkMarshalToString(c *C) {
|
||||
u, err := NewV4()
|
||||
c.Assert(err, IsNil)
|
||||
for i := 0; i < c.N; i++ {
|
||||
sink = u.String()
|
||||
}
|
||||
}
|
||||
265
generator.go
Normal file
265
generator.go
Normal file
@ -0,0 +1,265 @@
|
||||
// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
//
|
||||
// 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.
|
||||
|
||||
package uuid
|
||||
|
||||
import (
|
||||
"crypto/md5"
|
||||
"crypto/rand"
|
||||
"crypto/sha1"
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"hash"
|
||||
"io"
|
||||
"net"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Difference in 100-nanosecond intervals between
|
||||
// UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970).
|
||||
const epochStart = 122192928000000000
|
||||
|
||||
type epochFunc func() time.Time
|
||||
type hwAddrFunc func() (net.HardwareAddr, error)
|
||||
|
||||
var (
|
||||
global = newRFC4122Generator()
|
||||
|
||||
posixUID = uint32(os.Getuid())
|
||||
posixGID = uint32(os.Getgid())
|
||||
)
|
||||
|
||||
// NewV1 returns UUID based on current timestamp and MAC address.
|
||||
func NewV1() (UUID, error) {
|
||||
return global.NewV1()
|
||||
}
|
||||
|
||||
// NewV2 returns DCE Security UUID based on POSIX UID/GID.
|
||||
func NewV2(domain byte) (UUID, error) {
|
||||
return global.NewV2(domain)
|
||||
}
|
||||
|
||||
// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
|
||||
func NewV3(ns UUID, name string) UUID {
|
||||
return global.NewV3(ns, name)
|
||||
}
|
||||
|
||||
// NewV4 returns random generated UUID.
|
||||
func NewV4() (UUID, error) {
|
||||
return global.NewV4()
|
||||
}
|
||||
|
||||
// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
|
||||
func NewV5(ns UUID, name string) UUID {
|
||||
return global.NewV5(ns, name)
|
||||
}
|
||||
|
||||
// Generator provides interface for generating UUIDs.
|
||||
type Generator interface {
|
||||
NewV1() (UUID, error)
|
||||
NewV2(domain byte) (UUID, error)
|
||||
NewV3(ns UUID, name string) UUID
|
||||
NewV4() (UUID, error)
|
||||
NewV5(ns UUID, name string) UUID
|
||||
}
|
||||
|
||||
// Default generator implementation.
|
||||
type rfc4122Generator struct {
|
||||
clockSequenceOnce sync.Once
|
||||
hardwareAddrOnce sync.Once
|
||||
storageMutex sync.Mutex
|
||||
|
||||
rand io.Reader
|
||||
|
||||
epochFunc epochFunc
|
||||
hwAddrFunc hwAddrFunc
|
||||
lastTime uint64
|
||||
clockSequence uint16
|
||||
hardwareAddr [6]byte
|
||||
}
|
||||
|
||||
func newRFC4122Generator() Generator {
|
||||
return &rfc4122Generator{
|
||||
epochFunc: time.Now,
|
||||
hwAddrFunc: defaultHWAddrFunc,
|
||||
rand: rand.Reader,
|
||||
}
|
||||
}
|
||||
|
||||
// NewV1 returns UUID based on current timestamp and MAC address.
|
||||
func (g *rfc4122Generator) NewV1() (UUID, error) {
|
||||
u := UUID{}
|
||||
|
||||
timeNow, clockSeq, err := g.getClockSequence()
|
||||
if err != nil {
|
||||
return Nil, err
|
||||
}
|
||||
binary.BigEndian.PutUint32(u[0:], uint32(timeNow))
|
||||
binary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32))
|
||||
binary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48))
|
||||
binary.BigEndian.PutUint16(u[8:], clockSeq)
|
||||
|
||||
hardwareAddr, err := g.getHardwareAddr()
|
||||
if err != nil {
|
||||
return Nil, err
|
||||
}
|
||||
copy(u[10:], hardwareAddr)
|
||||
|
||||
u.SetVersion(V1)
|
||||
u.SetVariant(VariantRFC4122)
|
||||
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// NewV2 returns DCE Security UUID based on POSIX UID/GID.
|
||||
func (g *rfc4122Generator) NewV2(domain byte) (UUID, error) {
|
||||
u, err := g.NewV1()
|
||||
if err != nil {
|
||||
return Nil, err
|
||||
}
|
||||
|
||||
switch domain {
|
||||
case DomainPerson:
|
||||
binary.BigEndian.PutUint32(u[:], posixUID)
|
||||
case DomainGroup:
|
||||
binary.BigEndian.PutUint32(u[:], posixGID)
|
||||
}
|
||||
|
||||
u[9] = domain
|
||||
|
||||
u.SetVersion(V2)
|
||||
u.SetVariant(VariantRFC4122)
|
||||
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
|
||||
func (g *rfc4122Generator) NewV3(ns UUID, name string) UUID {
|
||||
u := newFromHash(md5.New(), ns, name)
|
||||
u.SetVersion(V3)
|
||||
u.SetVariant(VariantRFC4122)
|
||||
|
||||
return u
|
||||
}
|
||||
|
||||
// NewV4 returns random generated UUID.
|
||||
func (g *rfc4122Generator) NewV4() (UUID, error) {
|
||||
u := UUID{}
|
||||
if _, err := io.ReadFull(g.rand, u[:]); err != nil {
|
||||
return Nil, err
|
||||
}
|
||||
u.SetVersion(V4)
|
||||
u.SetVariant(VariantRFC4122)
|
||||
|
||||
return u, nil
|
||||
}
|
||||
|
||||
// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
|
||||
func (g *rfc4122Generator) NewV5(ns UUID, name string) UUID {
|
||||
u := newFromHash(sha1.New(), ns, name)
|
||||
u.SetVersion(V5)
|
||||
u.SetVariant(VariantRFC4122)
|
||||
|
||||
return u
|
||||
}
|
||||
|
||||
// Returns epoch and clock sequence.
|
||||
func (g *rfc4122Generator) getClockSequence() (uint64, uint16, error) {
|
||||
var err error
|
||||
g.clockSequenceOnce.Do(func() {
|
||||
buf := make([]byte, 2)
|
||||
if _, err = io.ReadFull(g.rand, buf); err != nil {
|
||||
return
|
||||
}
|
||||
g.clockSequence = binary.BigEndian.Uint16(buf)
|
||||
})
|
||||
if err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
|
||||
g.storageMutex.Lock()
|
||||
defer g.storageMutex.Unlock()
|
||||
|
||||
timeNow := g.getEpoch()
|
||||
// Clock didn't change since last UUID generation.
|
||||
// Should increase clock sequence.
|
||||
if timeNow <= g.lastTime {
|
||||
g.clockSequence++
|
||||
}
|
||||
g.lastTime = timeNow
|
||||
|
||||
return timeNow, g.clockSequence, nil
|
||||
}
|
||||
|
||||
// Returns hardware address.
|
||||
func (g *rfc4122Generator) getHardwareAddr() ([]byte, error) {
|
||||
var err error
|
||||
g.hardwareAddrOnce.Do(func() {
|
||||
if hwAddr, err := g.hwAddrFunc(); err == nil {
|
||||
copy(g.hardwareAddr[:], hwAddr)
|
||||
return
|
||||
}
|
||||
|
||||
// Initialize hardwareAddr randomly in case
|
||||
// of real network interfaces absence.
|
||||
if _, err = io.ReadFull(g.rand, g.hardwareAddr[:]); err != nil {
|
||||
return
|
||||
}
|
||||
// Set multicast bit as recommended by RFC 4122
|
||||
g.hardwareAddr[0] |= 0x01
|
||||
})
|
||||
if err != nil {
|
||||
return []byte{}, err
|
||||
}
|
||||
return g.hardwareAddr[:], nil
|
||||
}
|
||||
|
||||
// Returns difference in 100-nanosecond intervals between
|
||||
// UUID epoch (October 15, 1582) and current time.
|
||||
func (g *rfc4122Generator) getEpoch() uint64 {
|
||||
return epochStart + uint64(g.epochFunc().UnixNano()/100)
|
||||
}
|
||||
|
||||
// Returns UUID based on hashing of namespace UUID and name.
|
||||
func newFromHash(h hash.Hash, ns UUID, name string) UUID {
|
||||
u := UUID{}
|
||||
h.Write(ns[:])
|
||||
h.Write([]byte(name))
|
||||
copy(u[:], h.Sum(nil))
|
||||
|
||||
return u
|
||||
}
|
||||
|
||||
// Returns hardware address.
|
||||
func defaultHWAddrFunc() (net.HardwareAddr, error) {
|
||||
ifaces, err := net.Interfaces()
|
||||
if err != nil {
|
||||
return []byte{}, err
|
||||
}
|
||||
for _, iface := range ifaces {
|
||||
if len(iface.HardwareAddr) >= 6 {
|
||||
return iface.HardwareAddr, nil
|
||||
}
|
||||
}
|
||||
return []byte{}, fmt.Errorf("uuid: no HW address found")
|
||||
}
|
||||
240
generator_test.go
Normal file
240
generator_test.go
Normal file
@ -0,0 +1,240 @@
|
||||
// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
//
|
||||
// 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.
|
||||
|
||||
package uuid
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/rand"
|
||||
"fmt"
|
||||
"net"
|
||||
"testing/iotest"
|
||||
"time"
|
||||
|
||||
. "gopkg.in/check.v1"
|
||||
)
|
||||
|
||||
type faultyReader struct {
|
||||
callsNum int
|
||||
readToFail int // Read call number to fail
|
||||
}
|
||||
|
||||
func (r *faultyReader) Read(dest []byte) (int, error) {
|
||||
r.callsNum++
|
||||
if (r.callsNum - 1) == r.readToFail {
|
||||
return 0, fmt.Errorf("io: reader is faulty")
|
||||
}
|
||||
return rand.Read(dest)
|
||||
}
|
||||
|
||||
type genTestSuite struct{}
|
||||
|
||||
var _ = Suite(&genTestSuite{})
|
||||
|
||||
func (s *genTestSuite) TestNewV1(c *C) {
|
||||
u1, err := NewV1()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1.Version(), Equals, V1)
|
||||
c.Assert(u1.Variant(), Equals, VariantRFC4122)
|
||||
|
||||
u2, err := NewV1()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1, Not(Equals), u2)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV1EpochStale(c *C) {
|
||||
g := &rfc4122Generator{
|
||||
epochFunc: func() time.Time {
|
||||
return time.Unix(0, 0)
|
||||
},
|
||||
hwAddrFunc: defaultHWAddrFunc,
|
||||
rand: rand.Reader,
|
||||
}
|
||||
u1, err := g.NewV1()
|
||||
c.Assert(err, IsNil)
|
||||
u2, err := g.NewV1()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1, Not(Equals), u2)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV1FaultyRand(c *C) {
|
||||
g := &rfc4122Generator{
|
||||
epochFunc: time.Now,
|
||||
hwAddrFunc: defaultHWAddrFunc,
|
||||
rand: &faultyReader{},
|
||||
}
|
||||
u1, err := g.NewV1()
|
||||
c.Assert(err, NotNil)
|
||||
c.Assert(u1, Equals, Nil)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV1MissingNetworkInterfaces(c *C) {
|
||||
g := &rfc4122Generator{
|
||||
epochFunc: time.Now,
|
||||
hwAddrFunc: func() (net.HardwareAddr, error) {
|
||||
return []byte{}, fmt.Errorf("uuid: no hw address found")
|
||||
},
|
||||
rand: rand.Reader,
|
||||
}
|
||||
_, err := g.NewV1()
|
||||
c.Assert(err, IsNil)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV1MissingNetInterfacesAndFaultyRand(c *C) {
|
||||
g := &rfc4122Generator{
|
||||
epochFunc: time.Now,
|
||||
hwAddrFunc: func() (net.HardwareAddr, error) {
|
||||
return []byte{}, fmt.Errorf("uuid: no hw address found")
|
||||
},
|
||||
rand: &faultyReader{
|
||||
readToFail: 1,
|
||||
},
|
||||
}
|
||||
u1, err := g.NewV1()
|
||||
c.Assert(err, NotNil)
|
||||
c.Assert(u1, Equals, Nil)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) BenchmarkNewV1(c *C) {
|
||||
for i := 0; i < c.N; i++ {
|
||||
NewV1()
|
||||
}
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV2(c *C) {
|
||||
u1, err := NewV2(DomainPerson)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1.Version(), Equals, V2)
|
||||
c.Assert(u1.Variant(), Equals, VariantRFC4122)
|
||||
|
||||
u2, err := NewV2(DomainGroup)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u2.Version(), Equals, V2)
|
||||
c.Assert(u2.Variant(), Equals, VariantRFC4122)
|
||||
|
||||
u3, err := NewV2(DomainOrg)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u3.Version(), Equals, V2)
|
||||
c.Assert(u3.Variant(), Equals, VariantRFC4122)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV2FaultyRand(c *C) {
|
||||
g := &rfc4122Generator{
|
||||
epochFunc: time.Now,
|
||||
hwAddrFunc: defaultHWAddrFunc,
|
||||
rand: &faultyReader{},
|
||||
}
|
||||
u1, err := g.NewV2(DomainPerson)
|
||||
c.Assert(err, NotNil)
|
||||
c.Assert(u1, Equals, Nil)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) BenchmarkNewV2(c *C) {
|
||||
for i := 0; i < c.N; i++ {
|
||||
NewV2(DomainPerson)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV3(c *C) {
|
||||
u1 := NewV3(NamespaceDNS, "www.example.com")
|
||||
c.Assert(u1.Version(), Equals, V3)
|
||||
c.Assert(u1.Variant(), Equals, VariantRFC4122)
|
||||
c.Assert(u1.String(), Equals, "5df41881-3aed-3515-88a7-2f4a814cf09e")
|
||||
|
||||
u2 := NewV3(NamespaceDNS, "example.com")
|
||||
c.Assert(u2, Not(Equals), u1)
|
||||
|
||||
u3 := NewV3(NamespaceDNS, "example.com")
|
||||
c.Assert(u3, Equals, u2)
|
||||
|
||||
u4 := NewV3(NamespaceURL, "example.com")
|
||||
c.Assert(u4, Not(Equals), u3)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) BenchmarkNewV3(c *C) {
|
||||
for i := 0; i < c.N; i++ {
|
||||
NewV3(NamespaceDNS, "www.example.com")
|
||||
}
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV4(c *C) {
|
||||
u1, err := NewV4()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1.Version(), Equals, V4)
|
||||
c.Assert(u1.Variant(), Equals, VariantRFC4122)
|
||||
|
||||
u2, err := NewV4()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1, Not(Equals), u2)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV4FaultyRand(c *C) {
|
||||
g := &rfc4122Generator{
|
||||
epochFunc: time.Now,
|
||||
hwAddrFunc: defaultHWAddrFunc,
|
||||
rand: &faultyReader{},
|
||||
}
|
||||
u1, err := g.NewV4()
|
||||
c.Assert(err, NotNil)
|
||||
c.Assert(u1, Equals, Nil)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV4PartialRead(c *C) {
|
||||
g := &rfc4122Generator{
|
||||
epochFunc: time.Now,
|
||||
hwAddrFunc: defaultHWAddrFunc,
|
||||
rand: iotest.OneByteReader(rand.Reader),
|
||||
}
|
||||
u1, err := g.NewV4()
|
||||
zeros := bytes.Count(u1.Bytes(), []byte{0})
|
||||
mostlyZeros := zeros >= 10
|
||||
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(mostlyZeros, Equals, false)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) BenchmarkNewV4(c *C) {
|
||||
for i := 0; i < c.N; i++ {
|
||||
NewV4()
|
||||
}
|
||||
}
|
||||
|
||||
func (s *genTestSuite) TestNewV5(c *C) {
|
||||
u1 := NewV5(NamespaceDNS, "www.example.com")
|
||||
c.Assert(u1.Version(), Equals, V5)
|
||||
c.Assert(u1.Variant(), Equals, VariantRFC4122)
|
||||
c.Assert(u1.String(), Equals, "2ed6657d-e927-568b-95e1-2665a8aea6a2")
|
||||
|
||||
u2 := NewV5(NamespaceDNS, "example.com")
|
||||
c.Assert(u2, Not(Equals), u1)
|
||||
|
||||
u3 := NewV5(NamespaceDNS, "example.com")
|
||||
c.Assert(u3, Equals, u2)
|
||||
|
||||
u4 := NewV5(NamespaceURL, "example.com")
|
||||
c.Assert(u4, Not(Equals), u3)
|
||||
}
|
||||
|
||||
func (s *genTestSuite) BenchmarkNewV5(c *C) {
|
||||
for i := 0; i < c.N; i++ {
|
||||
NewV5(NamespaceDNS, "www.example.com")
|
||||
}
|
||||
}
|
||||
78
sql.go
Normal file
78
sql.go
Normal file
@ -0,0 +1,78 @@
|
||||
// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
//
|
||||
// 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.
|
||||
|
||||
package uuid
|
||||
|
||||
import (
|
||||
"database/sql/driver"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
// Value implements the driver.Valuer interface.
|
||||
func (u UUID) Value() (driver.Value, error) {
|
||||
return u.String(), nil
|
||||
}
|
||||
|
||||
// Scan implements the sql.Scanner interface.
|
||||
// A 16-byte slice is handled by UnmarshalBinary, while
|
||||
// a longer byte slice or a string is handled by UnmarshalText.
|
||||
func (u *UUID) Scan(src interface{}) error {
|
||||
switch src := src.(type) {
|
||||
case []byte:
|
||||
if len(src) == Size {
|
||||
return u.UnmarshalBinary(src)
|
||||
}
|
||||
return u.UnmarshalText(src)
|
||||
|
||||
case string:
|
||||
return u.UnmarshalText([]byte(src))
|
||||
}
|
||||
|
||||
return fmt.Errorf("uuid: cannot convert %T to UUID", src)
|
||||
}
|
||||
|
||||
// NullUUID can be used with the standard sql package to represent a
|
||||
// UUID value that can be NULL in the database
|
||||
type NullUUID struct {
|
||||
UUID UUID
|
||||
Valid bool
|
||||
}
|
||||
|
||||
// Value implements the driver.Valuer interface.
|
||||
func (u NullUUID) Value() (driver.Value, error) {
|
||||
if !u.Valid {
|
||||
return nil, nil
|
||||
}
|
||||
// Delegate to UUID Value function
|
||||
return u.UUID.Value()
|
||||
}
|
||||
|
||||
// Scan implements the sql.Scanner interface.
|
||||
func (u *NullUUID) Scan(src interface{}) error {
|
||||
if src == nil {
|
||||
u.UUID, u.Valid = Nil, false
|
||||
return nil
|
||||
}
|
||||
|
||||
// Delegate to UUID Scan function
|
||||
u.Valid = true
|
||||
return u.UUID.Scan(src)
|
||||
}
|
||||
136
sql_test.go
Normal file
136
sql_test.go
Normal file
@ -0,0 +1,136 @@
|
||||
// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
//
|
||||
// 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.
|
||||
|
||||
package uuid
|
||||
|
||||
import (
|
||||
. "gopkg.in/check.v1"
|
||||
)
|
||||
|
||||
type sqlTestSuite struct{}
|
||||
|
||||
var _ = Suite(&sqlTestSuite{})
|
||||
|
||||
func (s *sqlTestSuite) TestValue(c *C) {
|
||||
u, err := FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
|
||||
c.Assert(err, IsNil)
|
||||
|
||||
val, err := u.Value()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(val, Equals, u.String())
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestValueNil(c *C) {
|
||||
u := UUID{}
|
||||
|
||||
val, err := u.Value()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(val, Equals, Nil.String())
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestNullUUIDValueNil(c *C) {
|
||||
u := NullUUID{}
|
||||
|
||||
val, err := u.Value()
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(val, IsNil)
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestScanBinary(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
b1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
|
||||
u1 := UUID{}
|
||||
err := u1.Scan(b1)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u, Equals, u1)
|
||||
|
||||
b2 := []byte{}
|
||||
u2 := UUID{}
|
||||
|
||||
err = u2.Scan(b2)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestScanString(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
s1 := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
|
||||
|
||||
u1 := UUID{}
|
||||
err := u1.Scan(s1)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u, Equals, u1)
|
||||
|
||||
s2 := ""
|
||||
u2 := UUID{}
|
||||
|
||||
err = u2.Scan(s2)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestScanText(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
b1 := []byte("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
|
||||
|
||||
u1 := UUID{}
|
||||
err := u1.Scan(b1)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u, Equals, u1)
|
||||
|
||||
b2 := []byte("")
|
||||
u2 := UUID{}
|
||||
err = u2.Scan(b2)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestScanUnsupported(c *C) {
|
||||
u := UUID{}
|
||||
|
||||
err := u.Scan(true)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestScanNil(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
|
||||
err := u.Scan(nil)
|
||||
c.Assert(err, NotNil)
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestNullUUIDScanValid(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
s1 := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
|
||||
|
||||
u1 := NullUUID{}
|
||||
err := u1.Scan(s1)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u1.Valid, Equals, true)
|
||||
c.Assert(u1.UUID, Equals, u)
|
||||
}
|
||||
|
||||
func (s *sqlTestSuite) TestNullUUIDScanNil(c *C) {
|
||||
u := NullUUID{UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}, true}
|
||||
|
||||
err := u.Scan(nil)
|
||||
c.Assert(err, IsNil)
|
||||
c.Assert(u.Valid, Equals, false)
|
||||
c.Assert(u.UUID, Equals, Nil)
|
||||
}
|
||||
161
uuid.go
Normal file
161
uuid.go
Normal file
@ -0,0 +1,161 @@
|
||||
// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
//
|
||||
// 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.
|
||||
|
||||
// Package uuid provides implementation of Universally Unique Identifier (UUID).
|
||||
// Supported versions are 1, 3, 4 and 5 (as specified in RFC 4122) and
|
||||
// version 2 (as specified in DCE 1.1).
|
||||
package uuid
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
)
|
||||
|
||||
// Size of a UUID in bytes.
|
||||
const Size = 16
|
||||
|
||||
// UUID representation compliant with specification
|
||||
// described in RFC 4122.
|
||||
type UUID [Size]byte
|
||||
|
||||
// UUID versions
|
||||
const (
|
||||
_ byte = iota
|
||||
V1
|
||||
V2
|
||||
V3
|
||||
V4
|
||||
V5
|
||||
)
|
||||
|
||||
// UUID layout variants.
|
||||
const (
|
||||
VariantNCS byte = iota
|
||||
VariantRFC4122
|
||||
VariantMicrosoft
|
||||
VariantFuture
|
||||
)
|
||||
|
||||
// UUID DCE domains.
|
||||
const (
|
||||
DomainPerson = iota
|
||||
DomainGroup
|
||||
DomainOrg
|
||||
)
|
||||
|
||||
// String parse helpers.
|
||||
var (
|
||||
urnPrefix = []byte("urn:uuid:")
|
||||
byteGroups = []int{8, 4, 4, 4, 12}
|
||||
)
|
||||
|
||||
// Nil is special form of UUID that is specified to have all
|
||||
// 128 bits set to zero.
|
||||
var Nil = UUID{}
|
||||
|
||||
// Predefined namespace UUIDs.
|
||||
var (
|
||||
NamespaceDNS = Must(FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8"))
|
||||
NamespaceURL = Must(FromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8"))
|
||||
NamespaceOID = Must(FromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
|
||||
NamespaceX500 = Must(FromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
|
||||
)
|
||||
|
||||
// Equal returns true if u1 and u2 equals, otherwise returns false.
|
||||
func Equal(u1 UUID, u2 UUID) bool {
|
||||
return bytes.Equal(u1[:], u2[:])
|
||||
}
|
||||
|
||||
// Version returns algorithm version used to generate UUID.
|
||||
func (u UUID) Version() byte {
|
||||
return u[6] >> 4
|
||||
}
|
||||
|
||||
// Variant returns UUID layout variant.
|
||||
func (u UUID) Variant() byte {
|
||||
switch {
|
||||
case (u[8] >> 7) == 0x00:
|
||||
return VariantNCS
|
||||
case (u[8] >> 6) == 0x02:
|
||||
return VariantRFC4122
|
||||
case (u[8] >> 5) == 0x06:
|
||||
return VariantMicrosoft
|
||||
case (u[8] >> 5) == 0x07:
|
||||
fallthrough
|
||||
default:
|
||||
return VariantFuture
|
||||
}
|
||||
}
|
||||
|
||||
// Bytes returns bytes slice representation of UUID.
|
||||
func (u UUID) Bytes() []byte {
|
||||
return u[:]
|
||||
}
|
||||
|
||||
// Returns canonical string representation of UUID:
|
||||
// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
|
||||
func (u UUID) String() string {
|
||||
buf := make([]byte, 36)
|
||||
|
||||
hex.Encode(buf[0:8], u[0:4])
|
||||
buf[8] = '-'
|
||||
hex.Encode(buf[9:13], u[4:6])
|
||||
buf[13] = '-'
|
||||
hex.Encode(buf[14:18], u[6:8])
|
||||
buf[18] = '-'
|
||||
hex.Encode(buf[19:23], u[8:10])
|
||||
buf[23] = '-'
|
||||
hex.Encode(buf[24:], u[10:])
|
||||
|
||||
return string(buf)
|
||||
}
|
||||
|
||||
// SetVersion sets version bits.
|
||||
func (u *UUID) SetVersion(v byte) {
|
||||
u[6] = (u[6] & 0x0f) | (v << 4)
|
||||
}
|
||||
|
||||
// SetVariant sets variant bits.
|
||||
func (u *UUID) SetVariant(v byte) {
|
||||
switch v {
|
||||
case VariantNCS:
|
||||
u[8] = (u[8]&(0xff>>1) | (0x00 << 7))
|
||||
case VariantRFC4122:
|
||||
u[8] = (u[8]&(0xff>>2) | (0x02 << 6))
|
||||
case VariantMicrosoft:
|
||||
u[8] = (u[8]&(0xff>>3) | (0x06 << 5))
|
||||
case VariantFuture:
|
||||
fallthrough
|
||||
default:
|
||||
u[8] = (u[8]&(0xff>>3) | (0x07 << 5))
|
||||
}
|
||||
}
|
||||
|
||||
// Must is a helper that wraps a call to a function returning (UUID, error)
|
||||
// and panics if the error is non-nil. It is intended for use in variable
|
||||
// initializations such as
|
||||
// var packageUUID = uuid.Must(uuid.FromString("123e4567-e89b-12d3-a456-426655440000"));
|
||||
func Must(u UUID, err error) UUID {
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return u
|
||||
}
|
||||
100
uuid_test.go
Normal file
100
uuid_test.go
Normal file
@ -0,0 +1,100 @@
|
||||
// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
|
||||
//
|
||||
// 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.
|
||||
|
||||
package uuid
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
. "gopkg.in/check.v1"
|
||||
)
|
||||
|
||||
// Hook up gocheck into the "go test" runner.
|
||||
func TestUUID(t *testing.T) { TestingT(t) }
|
||||
|
||||
type testSuite struct{}
|
||||
|
||||
var _ = Suite(&testSuite{})
|
||||
|
||||
func (s *testSuite) TestBytes(c *C) {
|
||||
u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
|
||||
bytes1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
|
||||
|
||||
c.Assert(bytes.Equal(u.Bytes(), bytes1), Equals, true)
|
||||
}
|
||||
|
||||
func (s *testSuite) TestString(c *C) {
|
||||
c.Assert(NamespaceDNS.String(), Equals, "6ba7b810-9dad-11d1-80b4-00c04fd430c8")
|
||||
}
|
||||
|
||||
func (s *testSuite) TestEqual(c *C) {
|
||||
c.Assert(Equal(NamespaceDNS, NamespaceDNS), Equals, true)
|
||||
c.Assert(Equal(NamespaceDNS, NamespaceURL), Equals, false)
|
||||
}
|
||||
|
||||
func (s *testSuite) TestVersion(c *C) {
|
||||
u := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
c.Assert(u.Version(), Equals, V1)
|
||||
}
|
||||
|
||||
func (s *testSuite) TestSetVersion(c *C) {
|
||||
u := UUID{}
|
||||
u.SetVersion(4)
|
||||
c.Assert(u.Version(), Equals, V4)
|
||||
}
|
||||
|
||||
func (s *testSuite) TestVariant(c *C) {
|
||||
u1 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
c.Assert(u1.Variant(), Equals, VariantNCS)
|
||||
|
||||
u2 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
c.Assert(u2.Variant(), Equals, VariantRFC4122)
|
||||
|
||||
u3 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
c.Assert(u3.Variant(), Equals, VariantMicrosoft)
|
||||
|
||||
u4 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
|
||||
c.Assert(u4.Variant(), Equals, VariantFuture)
|
||||
}
|
||||
|
||||
func (s *testSuite) TestSetVariant(c *C) {
|
||||
u := UUID{}
|
||||
u.SetVariant(VariantNCS)
|
||||
c.Assert(u.Variant(), Equals, VariantNCS)
|
||||
u.SetVariant(VariantRFC4122)
|
||||
c.Assert(u.Variant(), Equals, VariantRFC4122)
|
||||
u.SetVariant(VariantMicrosoft)
|
||||
c.Assert(u.Variant(), Equals, VariantMicrosoft)
|
||||
u.SetVariant(VariantFuture)
|
||||
c.Assert(u.Variant(), Equals, VariantFuture)
|
||||
}
|
||||
|
||||
func (s *testSuite) TestMust(c *C) {
|
||||
defer func() {
|
||||
c.Assert(recover(), NotNil)
|
||||
}()
|
||||
Must(func() (UUID, error) {
|
||||
return Nil, fmt.Errorf("uuid: expected error")
|
||||
}())
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user