pax_global_header00006660000000000000000000000064132231726120014511gustar00rootroot0000000000000052 comment=f58768cc1a7a7e77a3bd49e98cdd21419399b6a3 go.uuid-1.2.0/000077500000000000000000000000001322317261200130635ustar00rootroot00000000000000go.uuid-1.2.0/.travis.yml000066400000000000000000000005711322317261200151770ustar00rootroot00000000000000language: go sudo: false go: - 1.2 - 1.3 - 1.4 - 1.5 - 1.6 - 1.7 - 1.8 - 1.9 - 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 go.uuid-1.2.0/LICENSE000066400000000000000000000020721322317261200140710ustar00rootroot00000000000000Copyright (C) 2013-2018 by Maxim Bublis 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. go.uuid-1.2.0/README.md000066400000000000000000000035351322317261200143500ustar00rootroot00000000000000# UUID package for Go language [![Build Status](https://travis-ci.org/satori/go.uuid.png?branch=master)](https://travis-ci.org/satori/go.uuid) [![Coverage Status](https://coveralls.io/repos/github/satori/go.uuid/badge.svg?branch=master)](https://coveralls.io/github/satori/go.uuid) [![GoDoc](http://godoc.org/github.com/satori/go.uuid?status.png)](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 requires Go >= 1.2. ## Example ```go package main import ( "fmt" "github.com/satori/go.uuid" ) func main() { // Creating UUID Version 4 u1 := uuid.NewV4() fmt.Printf("UUIDv4: %s\n", u1) // Parsing UUID from string input u2, err := uuid.FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8") if err != nil { fmt.Printf("Something gone wrong: %s", err) } 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 . UUID package released under MIT License. See [LICENSE](https://github.com/satori/go.uuid/blob/master/LICENSE) for details. go.uuid-1.2.0/codec.go000066400000000000000000000136151322317261200144750ustar00rootroot00000000000000// Copyright (C) 2013-2018 by Maxim Bublis // // 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 } go.uuid-1.2.0/codec_test.go000066400000000000000000000156121322317261200155330ustar00rootroot00000000000000// Copyright (C) 2013-2018 by Maxim Bublis // // 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 := NewV4() 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 := NewV4() 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 := NewV4() for i := 0; i < c.N; i++ { sink = u.String() } } go.uuid-1.2.0/generator.go000066400000000000000000000135631322317261200154100ustar00rootroot00000000000000// Copyright (C) 2013-2018 by Maxim Bublis // // 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" "hash" "net" "os" "sync" "time" ) // Difference in 100-nanosecond intervals between // UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970). const epochStart = 122192928000000000 var ( global = newDefaultGenerator() epochFunc = unixTimeFunc posixUID = uint32(os.Getuid()) posixGID = uint32(os.Getgid()) ) // NewV1 returns UUID based on current timestamp and MAC address. func NewV1() UUID { return global.NewV1() } // NewV2 returns DCE Security UUID based on POSIX UID/GID. func NewV2(domain byte) UUID { 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 { 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 NewV2(domain byte) UUID NewV3(ns UUID, name string) UUID NewV4() UUID NewV5(ns UUID, name string) UUID } // Default generator implementation. type generator struct { storageOnce sync.Once storageMutex sync.Mutex lastTime uint64 clockSequence uint16 hardwareAddr [6]byte } func newDefaultGenerator() Generator { return &generator{} } // NewV1 returns UUID based on current timestamp and MAC address. func (g *generator) NewV1() UUID { u := UUID{} timeNow, clockSeq, hardwareAddr := g.getStorage() 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) copy(u[10:], hardwareAddr) u.SetVersion(V1) u.SetVariant(VariantRFC4122) return u } // NewV2 returns DCE Security UUID based on POSIX UID/GID. func (g *generator) NewV2(domain byte) UUID { u := UUID{} timeNow, clockSeq, hardwareAddr := g.getStorage() switch domain { case DomainPerson: binary.BigEndian.PutUint32(u[0:], posixUID) case DomainGroup: binary.BigEndian.PutUint32(u[0:], posixGID) } binary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32)) binary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48)) binary.BigEndian.PutUint16(u[8:], clockSeq) u[9] = domain copy(u[10:], hardwareAddr) u.SetVersion(V2) u.SetVariant(VariantRFC4122) return u } // NewV3 returns UUID based on MD5 hash of namespace UUID and name. func (g *generator) 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 *generator) NewV4() UUID { u := UUID{} g.safeRandom(u[:]) u.SetVersion(V4) u.SetVariant(VariantRFC4122) return u } // NewV5 returns UUID based on SHA-1 hash of namespace UUID and name. func (g *generator) NewV5(ns UUID, name string) UUID { u := newFromHash(sha1.New(), ns, name) u.SetVersion(V5) u.SetVariant(VariantRFC4122) return u } func (g *generator) initStorage() { g.initClockSequence() g.initHardwareAddr() } func (g *generator) initClockSequence() { buf := make([]byte, 2) g.safeRandom(buf) g.clockSequence = binary.BigEndian.Uint16(buf) } func (g *generator) initHardwareAddr() { interfaces, err := net.Interfaces() if err == nil { for _, iface := range interfaces { if len(iface.HardwareAddr) >= 6 { copy(g.hardwareAddr[:], iface.HardwareAddr) return } } } // Initialize hardwareAddr randomly in case // of real network interfaces absence g.safeRandom(g.hardwareAddr[:]) // Set multicast bit as recommended in RFC 4122 g.hardwareAddr[0] |= 0x01 } func (g *generator) safeRandom(dest []byte) { if _, err := rand.Read(dest); err != nil { panic(err) } } // Returns UUID v1/v2 storage state. // Returns epoch timestamp, clock sequence, and hardware address. func (g *generator) getStorage() (uint64, uint16, []byte) { g.storageOnce.Do(g.initStorage) g.storageMutex.Lock() defer g.storageMutex.Unlock() timeNow := epochFunc() // Clock changed backwards since last UUID generation. // Should increase clock sequence. if timeNow <= g.lastTime { g.clockSequence++ } g.lastTime = timeNow return timeNow, g.clockSequence, g.hardwareAddr[:] } // Returns difference in 100-nanosecond intervals between // UUID epoch (October 15, 1582) and current time. // This is default epoch calculation function. func unixTimeFunc() uint64 { return epochStart + uint64(time.Now().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 } go.uuid-1.2.0/generator_test.go000066400000000000000000000071271322317261200164460ustar00rootroot00000000000000// Copyright (C) 2013-2018 by Maxim Bublis // // 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 genTestSuite struct{} var _ = Suite(&genTestSuite{}) func (s *genTestSuite) TestNewV1(c *C) { u := NewV1() c.Assert(u.Version(), Equals, V1) c.Assert(u.Variant(), Equals, VariantRFC4122) u1 := NewV1() u2 := NewV1() c.Assert(u1, Not(Equals), u2) oldFunc := epochFunc epochFunc = func() uint64 { return 0 } u3 := NewV1() u4 := NewV1() c.Assert(u3, Not(Equals), u4) epochFunc = oldFunc } func (s *genTestSuite) BenchmarkNewV1(c *C) { for i := 0; i < c.N; i++ { NewV1() } } func (s *genTestSuite) TestNewV2(c *C) { u1 := NewV2(DomainPerson) c.Assert(u1.Version(), Equals, V2) c.Assert(u1.Variant(), Equals, VariantRFC4122) u2 := NewV2(DomainGroup) c.Assert(u2.Version(), Equals, V2) c.Assert(u2.Variant(), Equals, VariantRFC4122) } func (s *genTestSuite) BenchmarkNewV2(c *C) { for i := 0; i < c.N; i++ { NewV2(DomainPerson) } } func (s *genTestSuite) TestNewV3(c *C) { u := NewV3(NamespaceDNS, "www.example.com") c.Assert(u.Version(), Equals, V3) c.Assert(u.Variant(), Equals, VariantRFC4122) c.Assert(u.String(), Equals, "5df41881-3aed-3515-88a7-2f4a814cf09e") u = NewV3(NamespaceDNS, "python.org") c.Assert(u.String(), Equals, "6fa459ea-ee8a-3ca4-894e-db77e160355e") u1 := NewV3(NamespaceDNS, "golang.org") u2 := NewV3(NamespaceDNS, "golang.org") c.Assert(u1, Equals, u2) u3 := NewV3(NamespaceDNS, "example.com") c.Assert(u1, Not(Equals), u3) u4 := NewV3(NamespaceURL, "golang.org") c.Assert(u1, Not(Equals), u4) } func (s *genTestSuite) BenchmarkNewV3(c *C) { for i := 0; i < c.N; i++ { NewV3(NamespaceDNS, "www.example.com") } } func (s *genTestSuite) TestNewV4(c *C) { u := NewV4() c.Assert(u.Version(), Equals, V4) c.Assert(u.Variant(), Equals, VariantRFC4122) } func (s *genTestSuite) BenchmarkNewV4(c *C) { for i := 0; i < c.N; i++ { NewV4() } } func (s *genTestSuite) TestNewV5(c *C) { u := NewV5(NamespaceDNS, "www.example.com") c.Assert(u.Version(), Equals, V5) c.Assert(u.Variant(), Equals, VariantRFC4122) u = NewV5(NamespaceDNS, "python.org") c.Assert(u.String(), Equals, "886313e1-3b8a-5372-9b90-0c9aee199e5d") u1 := NewV5(NamespaceDNS, "golang.org") u2 := NewV5(NamespaceDNS, "golang.org") c.Assert(u1, Equals, u2) u3 := NewV5(NamespaceDNS, "example.com") c.Assert(u1, Not(Equals), u3) u4 := NewV5(NamespaceURL, "golang.org") c.Assert(u1, Not(Equals), u4) } func (s *genTestSuite) BenchmarkNewV5(c *C) { for i := 0; i < c.N; i++ { NewV5(NamespaceDNS, "www.example.com") } } go.uuid-1.2.0/sql.go000066400000000000000000000045161322317261200142170ustar00rootroot00000000000000// Copyright (C) 2013-2018 by Maxim Bublis // // 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) } go.uuid-1.2.0/sql_test.go000066400000000000000000000073371322317261200152620ustar00rootroot00000000000000// Copyright (C) 2013-2018 by Maxim Bublis // // 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) } go.uuid-1.2.0/uuid.go000066400000000000000000000101301322317261200143530ustar00rootroot00000000000000// Copyright (C) 2013-2018 by Maxim Bublis // // 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 } go.uuid-1.2.0/uuid_test.go000066400000000000000000000063211322317261200154210ustar00rootroot00000000000000// Copyright (C) 2013-2018 by Maxim Bublis // // 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" "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) }