github.com/msteinert/pam = commit:02ccfbf | github.com/msteinert/pam = commit:02ccfbf | ||||
github.com/nfnt/resize = commit:4d93a29 | github.com/nfnt/resize = commit:4d93a29 | ||||
github.com/russross/blackfriday = commit:006144a | github.com/russross/blackfriday = commit:006144a | ||||
github.com/satori/go.uuid = | |||||
github.com/sergi/go-diff = commit:ec7fdbb | github.com/sergi/go-diff = commit:ec7fdbb | ||||
github.com/shurcooL/sanitized_anchor_name = commit:10ef21a | github.com/shurcooL/sanitized_anchor_name = commit:10ef21a | ||||
github.com/Unknwon/cae = commit:7f5e046 | github.com/Unknwon/cae = commit:7f5e046 |
"github.com/Unknwon/com" | "github.com/Unknwon/com" | ||||
"github.com/codegangsta/cli" | "github.com/codegangsta/cli" | ||||
gouuid "github.com/satori/go.uuid" | |||||
"github.com/gogits/gogs/models" | "github.com/gogits/gogs/models" | ||||
"github.com/gogits/gogs/modules/base" | "github.com/gogits/gogs/modules/base" | ||||
"github.com/gogits/gogs/modules/httplib" | "github.com/gogits/gogs/modules/httplib" | ||||
"github.com/gogits/gogs/modules/log" | "github.com/gogits/gogs/modules/log" | ||||
"github.com/gogits/gogs/modules/setting" | "github.com/gogits/gogs/modules/setting" | ||||
"github.com/gogits/gogs/modules/uuid" | |||||
) | ) | ||||
const ( | const ( | ||||
} | } | ||||
} | } | ||||
uuid := uuid.NewV4().String() | |||||
uuid := gouuid.NewV4().String() | |||||
os.Setenv("uuid", uuid) | os.Setenv("uuid", uuid) | ||||
// Special handle for Windows. | // Special handle for Windows. |
"github.com/Unknwon/com" | "github.com/Unknwon/com" | ||||
"github.com/go-xorm/xorm" | "github.com/go-xorm/xorm" | ||||
gouuid "github.com/satori/go.uuid" | |||||
"github.com/gogits/gogs/modules/base" | "github.com/gogits/gogs/modules/base" | ||||
"github.com/gogits/gogs/modules/log" | "github.com/gogits/gogs/modules/log" | ||||
"github.com/gogits/gogs/modules/setting" | "github.com/gogits/gogs/modules/setting" | ||||
gouuid "github.com/gogits/gogs/modules/uuid" | |||||
) | ) | ||||
var ( | var ( |
"github.com/Unknwon/com" | "github.com/Unknwon/com" | ||||
"github.com/go-xorm/xorm" | "github.com/go-xorm/xorm" | ||||
gouuid "github.com/satori/go.uuid" | |||||
"gopkg.in/ini.v1" | "gopkg.in/ini.v1" | ||||
"github.com/gogits/gogs/modules/base" | "github.com/gogits/gogs/modules/base" | ||||
"github.com/gogits/gogs/modules/log" | "github.com/gogits/gogs/modules/log" | ||||
"github.com/gogits/gogs/modules/setting" | "github.com/gogits/gogs/modules/setting" | ||||
gouuid "github.com/gogits/gogs/modules/uuid" | |||||
) | ) | ||||
const _MIN_DB_VER = 4 | const _MIN_DB_VER = 4 |
import ( | import ( | ||||
"time" | "time" | ||||
gouuid "github.com/satori/go.uuid" | |||||
"github.com/gogits/gogs/modules/base" | "github.com/gogits/gogs/modules/base" | ||||
"github.com/gogits/gogs/modules/uuid" | |||||
) | ) | ||||
// AccessToken represents a personal access token. | // AccessToken represents a personal access token. | ||||
// NewAccessToken creates new access token. | // NewAccessToken creates new access token. | ||||
func NewAccessToken(t *AccessToken) error { | func NewAccessToken(t *AccessToken) error { | ||||
t.Sha1 = base.EncodeSha1(uuid.NewV4().String()) | |||||
t.Sha1 = base.EncodeSha1(gouuid.NewV4().String()) | |||||
_, err := x.Insert(t) | _, err := x.Insert(t) | ||||
return err | return err | ||||
} | } |
"github.com/Unknwon/com" | "github.com/Unknwon/com" | ||||
"github.com/go-xorm/xorm" | "github.com/go-xorm/xorm" | ||||
gouuid "github.com/satori/go.uuid" | |||||
api "github.com/gogits/go-gogs-client" | api "github.com/gogits/go-gogs-client" | ||||
"github.com/gogits/gogs/modules/httplib" | "github.com/gogits/gogs/modules/httplib" | ||||
"github.com/gogits/gogs/modules/log" | "github.com/gogits/gogs/modules/log" | ||||
"github.com/gogits/gogs/modules/setting" | "github.com/gogits/gogs/modules/setting" | ||||
"github.com/gogits/gogs/modules/uuid" | |||||
) | ) | ||||
type HookContentType int | type HookContentType int | ||||
if err != nil { | if err != nil { | ||||
return err | return err | ||||
} | } | ||||
t.UUID = uuid.NewV4().String() | |||||
t.UUID = gouuid.NewV4().String() | |||||
t.PayloadContent = string(data) | t.PayloadContent = string(data) | ||||
_, err = x.Insert(t) | _, err = x.Insert(t) | ||||
return err | return err |
"github.com/Unknwon/com" | "github.com/Unknwon/com" | ||||
"github.com/go-macaron/binding" | "github.com/go-macaron/binding" | ||||
"github.com/go-macaron/session" | "github.com/go-macaron/session" | ||||
gouuid "github.com/satori/go.uuid" | |||||
"gopkg.in/macaron.v1" | "gopkg.in/macaron.v1" | ||||
"github.com/gogits/gogs/models" | "github.com/gogits/gogs/models" | ||||
"github.com/gogits/gogs/modules/base" | "github.com/gogits/gogs/modules/base" | ||||
"github.com/gogits/gogs/modules/log" | "github.com/gogits/gogs/modules/log" | ||||
"github.com/gogits/gogs/modules/setting" | "github.com/gogits/gogs/modules/setting" | ||||
"github.com/gogits/gogs/modules/uuid" | |||||
) | ) | ||||
func IsAPIPath(url string) bool { | func IsAPIPath(url string) bool { | ||||
if setting.Service.EnableReverseProxyAutoRegister { | if setting.Service.EnableReverseProxyAutoRegister { | ||||
u := &models.User{ | u := &models.User{ | ||||
Name: webAuthUser, | Name: webAuthUser, | ||||
Email: uuid.NewV4().String() + "@localhost", | |||||
Email: gouuid.NewV4().String() + "@localhost", | |||||
Passwd: webAuthUser, | Passwd: webAuthUser, | ||||
IsActive: true, | IsActive: true, | ||||
} | } |
# UUID package for Go language | |||||
[![Build Status](https://travis-ci.org/satori/go.uuid.png?branch=master)](https://travis-ci.org/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 any stable version of Go Programming Language. | |||||
It is tested against following versions of Go: 1.0, 1.1, 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 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. |
// Copyright (C) 2013 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 ( | |||||
"testing" | |||||
) | |||||
func BenchmarkFromBytes(b *testing.B) { | |||||
bytes := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8} | |||||
for i := 0; i < b.N; i++ { | |||||
FromBytes(bytes) | |||||
} | |||||
} | |||||
func BenchmarkFromString(b *testing.B) { | |||||
s := "6ba7b810-9dad-11d1-80b4-00c04fd430c8" | |||||
for i := 0; i < b.N; i++ { | |||||
FromString(s) | |||||
} | |||||
} | |||||
func BenchmarkFromStringUrn(b *testing.B) { | |||||
s := "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8" | |||||
for i := 0; i < b.N; i++ { | |||||
FromString(s) | |||||
} | |||||
} | |||||
func BenchmarkFromStringWithBrackets(b *testing.B) { | |||||
s := "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}" | |||||
for i := 0; i < b.N; i++ { | |||||
FromString(s) | |||||
} | |||||
} | |||||
func BenchmarkNewV1(b *testing.B) { | |||||
for i := 0; i < b.N; i++ { | |||||
NewV1() | |||||
} | |||||
} | |||||
func BenchmarkNewV2(b *testing.B) { | |||||
for i := 0; i < b.N; i++ { | |||||
NewV2(DomainPerson) | |||||
} | |||||
} | |||||
func BenchmarkNewV3(b *testing.B) { | |||||
for i := 0; i < b.N; i++ { | |||||
NewV3(NamespaceDNS, "www.example.com") | |||||
} | |||||
} | |||||
func BenchmarkNewV4(b *testing.B) { | |||||
for i := 0; i < b.N; i++ { | |||||
NewV4() | |||||
} | |||||
} | |||||
func BenchmarkNewV5(b *testing.B) { | |||||
for i := 0; i < b.N; i++ { | |||||
NewV5(NamespaceDNS, "www.example.com") | |||||
} | |||||
} |
// Copyright (C) 2013 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" | |||||
"crypto/md5" | |||||
"crypto/rand" | |||||
"crypto/sha1" | |||||
"encoding/binary" | |||||
"encoding/hex" | |||||
"fmt" | |||||
"hash" | |||||
"net" | |||||
"os" | |||||
"strings" | |||||
"sync" | |||||
"time" | |||||
) | |||||
// UUID layout variants. | |||||
const ( | |||||
VariantNCS = iota | |||||
VariantRFC4122 | |||||
VariantMicrosoft | |||||
VariantFuture | |||||
) | |||||
// UUID DCE domains. | |||||
const ( | |||||
DomainPerson = iota | |||||
DomainGroup | |||||
DomainOrg | |||||
) | |||||
// Difference in 100-nanosecond intervals between | |||||
// UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970). | |||||
const epochStart = 122192928000000000 | |||||
// UUID v1/v2 storage. | |||||
var ( | |||||
storageMutex sync.Mutex | |||||
clockSequence uint16 | |||||
lastTime uint64 | |||||
hardwareAddr [6]byte | |||||
posixUID = uint32(os.Getuid()) | |||||
posixGID = uint32(os.Getgid()) | |||||
) | |||||
// Epoch calculation function | |||||
var epochFunc func() uint64 | |||||
// Initialize storage | |||||
func init() { | |||||
buf := make([]byte, 2) | |||||
rand.Read(buf) | |||||
clockSequence = binary.BigEndian.Uint16(buf) | |||||
// Initialize hardwareAddr randomly in case | |||||
// of real network interfaces absence | |||||
rand.Read(hardwareAddr[:]) | |||||
// Set multicast bit as recommended in RFC 4122 | |||||
hardwareAddr[0] |= 0x01 | |||||
interfaces, err := net.Interfaces() | |||||
if err == nil { | |||||
for _, iface := range interfaces { | |||||
if len(iface.HardwareAddr) >= 6 { | |||||
copy(hardwareAddr[:], iface.HardwareAddr) | |||||
break | |||||
} | |||||
} | |||||
} | |||||
epochFunc = unixTimeFunc | |||||
} | |||||
// 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) | |||||
} | |||||
// UUID representation compliant with specification | |||||
// described in RFC 4122. | |||||
type UUID [16]byte | |||||
// Predefined namespace UUIDs. | |||||
var ( | |||||
NamespaceDNS, _ = FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8") | |||||
NamespaceURL, _ = FromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8") | |||||
NamespaceOID, _ = FromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8") | |||||
NamespaceX500, _ = FromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8") | |||||
) | |||||
// And returns result of binary AND of two UUIDs. | |||||
func And(u1 UUID, u2 UUID) UUID { | |||||
u := UUID{} | |||||
for i := 0; i < 16; i++ { | |||||
u[i] = u1[i] & u2[i] | |||||
} | |||||
return u | |||||
} | |||||
// Or returns result of binary OR of two UUIDs. | |||||
func Or(u1 UUID, u2 UUID) UUID { | |||||
u := UUID{} | |||||
for i := 0; i < 16; i++ { | |||||
u[i] = u1[i] | u2[i] | |||||
} | |||||
return u | |||||
} | |||||
// 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() uint { | |||||
return uint(u[6] >> 4) | |||||
} | |||||
// Variant returns UUID layout variant. | |||||
func (u UUID) Variant() uint { | |||||
switch { | |||||
case (u[8] & 0x80) == 0x00: | |||||
return VariantNCS | |||||
case (u[8]&0xc0)|0x80 == 0x80: | |||||
return VariantRFC4122 | |||||
case (u[8]&0xe0)|0xc0 == 0xc0: | |||||
return VariantMicrosoft | |||||
} | |||||
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 { | |||||
return fmt.Sprintf("%x-%x-%x-%x-%x", | |||||
u[:4], u[4:6], u[6:8], u[8:10], u[10:]) | |||||
} | |||||
// SetVersion sets version bits. | |||||
func (u *UUID) SetVersion(v byte) { | |||||
u[6] = (u[6] & 0x0f) | (v << 4) | |||||
} | |||||
// SetVariant sets variant bits as described in RFC 4122. | |||||
func (u *UUID) SetVariant() { | |||||
u[8] = (u[8] & 0xbf) | 0x80 | |||||
} | |||||
// 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. | |||||
// UUID is expected in a form accepted by FromString. | |||||
func (u *UUID) UnmarshalText(text []byte) error { | |||||
s := string(text) | |||||
u2, err := FromString(s) | |||||
if err != nil { | |||||
return err | |||||
} | |||||
*u = u2 | |||||
return nil | |||||
} | |||||
// MarshalBinary implements the encoding.BinaryMarshaler interface. | |||||
func (u UUID) MarshalBinary() (data []byte, err error) { | |||||
data = u.Bytes() | |||||
return | |||||
} | |||||
// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. | |||||
func (u *UUID) UnmarshalBinary(data []byte) error { | |||||
u2, err := FromBytes(data) | |||||
if err != nil { | |||||
return err | |||||
} | |||||
*u = u2 | |||||
return nil | |||||
} | |||||
// 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) { | |||||
if len(input) != 16 { | |||||
err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(input)) | |||||
return | |||||
} | |||||
copy(u[:], input) | |||||
return | |||||
} | |||||
// FromString returns UUID parsed from string input. | |||||
// Following formats are supported: | |||||
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8", | |||||
// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}", | |||||
// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8" | |||||
func FromString(input string) (u UUID, err error) { | |||||
s := strings.Replace(input, "-", "", -1) | |||||
if len(s) == 41 && s[:9] == "urn:uuid:" { | |||||
s = s[9:] | |||||
} else if len(s) == 34 && s[0] == '{' && s[33] == '}' { | |||||
s = s[1:33] | |||||
} | |||||
if len(s) != 32 { | |||||
err = fmt.Errorf("uuid: invalid UUID string: %s", input) | |||||
return | |||||
} | |||||
b := []byte(s) | |||||
_, err = hex.Decode(u[:], b) | |||||
return | |||||
} | |||||
// Returns UUID v1/v2 storage state. | |||||
// Returns epoch timestamp and clock sequence. | |||||
func getStorage() (uint64, uint16) { | |||||
storageMutex.Lock() | |||||
defer storageMutex.Unlock() | |||||
timeNow := epochFunc() | |||||
// Clock changed backwards since last UUID generation. | |||||
// Should increase clock sequence. | |||||
if timeNow <= lastTime { | |||||
clockSequence++ | |||||
} | |||||
lastTime = timeNow | |||||
return timeNow, clockSequence | |||||
} | |||||
// NewV1 returns UUID based on current timestamp and MAC address. | |||||
func NewV1() UUID { | |||||
u := UUID{} | |||||
timeNow, clockSeq := 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(1) | |||||
u.SetVariant() | |||||
return u | |||||
} | |||||
// NewV2 returns DCE Security UUID based on POSIX UID/GID. | |||||
func NewV2(domain byte) UUID { | |||||
u := UUID{} | |||||
switch domain { | |||||
case DomainPerson: | |||||
binary.BigEndian.PutUint32(u[0:], posixUID) | |||||
case DomainGroup: | |||||
binary.BigEndian.PutUint32(u[0:], posixGID) | |||||
} | |||||
timeNow, clockSeq := getStorage() | |||||
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(2) | |||||
u.SetVariant() | |||||
return u | |||||
} | |||||
// NewV3 returns UUID based on MD5 hash of namespace UUID and name. | |||||
func NewV3(ns UUID, name string) UUID { | |||||
u := newFromHash(md5.New(), ns, name) | |||||
u.SetVersion(3) | |||||
u.SetVariant() | |||||
return u | |||||
} | |||||
// NewV4 returns random generated UUID. | |||||
func NewV4() UUID { | |||||
u := UUID{} | |||||
rand.Read(u[:]) | |||||
u.SetVersion(4) | |||||
u.SetVariant() | |||||
return u | |||||
} | |||||
// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name. | |||||
func NewV5(ns UUID, name string) UUID { | |||||
u := newFromHash(sha1.New(), ns, name) | |||||
u.SetVersion(5) | |||||
u.SetVariant() | |||||
return u | |||||
} | |||||
// 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 | |||||
} |
// Copyright (C) 2013 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" | |||||
"testing" | |||||
) | |||||
func TestBytes(t *testing.T) { | |||||
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} | |||||
if !bytes.Equal(u.Bytes(), bytes1) { | |||||
t.Errorf("Incorrect bytes representation for UUID: %s", u) | |||||
} | |||||
} | |||||
func TestString(t *testing.T) { | |||||
if NamespaceDNS.String() != "6ba7b810-9dad-11d1-80b4-00c04fd430c8" { | |||||
t.Errorf("Incorrect string representation for UUID: %s", NamespaceDNS.String()) | |||||
} | |||||
} | |||||
func TestEqual(t *testing.T) { | |||||
if !Equal(NamespaceDNS, NamespaceDNS) { | |||||
t.Errorf("Incorrect comparison of %s and %s", NamespaceDNS, NamespaceDNS) | |||||
} | |||||
if Equal(NamespaceDNS, NamespaceURL) { | |||||
t.Errorf("Incorrect comparison of %s and %s", NamespaceDNS, NamespaceURL) | |||||
} | |||||
} | |||||
func TestOr(t *testing.T) { | |||||
u1 := UUID{0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff} | |||||
u2 := UUID{0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00} | |||||
u := UUID{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} | |||||
if !Equal(u, Or(u1, u2)) { | |||||
t.Errorf("Incorrect bitwise OR result %s", Or(u1, u2)) | |||||
} | |||||
} | |||||
func TestAnd(t *testing.T) { | |||||
u1 := UUID{0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff} | |||||
u2 := UUID{0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00} | |||||
u := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} | |||||
if !Equal(u, And(u1, u2)) { | |||||
t.Errorf("Incorrect bitwise AND result %s", And(u1, u2)) | |||||
} | |||||
} | |||||
func TestVersion(t *testing.T) { | |||||
u := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} | |||||
if u.Version() != 1 { | |||||
t.Errorf("Incorrect version for UUID: %d", u.Version()) | |||||
} | |||||
} | |||||
func TestSetVersion(t *testing.T) { | |||||
u := UUID{} | |||||
u.SetVersion(4) | |||||
if u.Version() != 4 { | |||||
t.Errorf("Incorrect version for UUID after u.setVersion(4): %d", u.Version()) | |||||
} | |||||
} | |||||
func TestVariant(t *testing.T) { | |||||
u1 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} | |||||
if u1.Variant() != VariantNCS { | |||||
t.Errorf("Incorrect variant for UUID variant %d: %d", VariantNCS, u1.Variant()) | |||||
} | |||||
u2 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} | |||||
if u2.Variant() != VariantRFC4122 { | |||||
t.Errorf("Incorrect variant for UUID variant %d: %d", VariantRFC4122, u2.Variant()) | |||||
} | |||||
u3 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} | |||||
if u3.Variant() != VariantMicrosoft { | |||||
t.Errorf("Incorrect variant for UUID variant %d: %d", VariantMicrosoft, u3.Variant()) | |||||
} | |||||
u4 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} | |||||
if u4.Variant() != VariantFuture { | |||||
t.Errorf("Incorrect variant for UUID variant %d: %d", VariantFuture, u4.Variant()) | |||||
} | |||||
} | |||||
func TestSetVariant(t *testing.T) { | |||||
u := new(UUID) | |||||
u.SetVariant() | |||||
if u.Variant() != VariantRFC4122 { | |||||
t.Errorf("Incorrect variant for UUID after u.setVariant(): %d", u.Variant()) | |||||
} | |||||
} | |||||
func TestFromBytes(t *testing.T) { | |||||
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) | |||||
if err != nil { | |||||
t.Errorf("Error parsing UUID from bytes: %s", err) | |||||
} | |||||
if !Equal(u, u1) { | |||||
t.Errorf("UUIDs should be equal: %s and %s", u, u1) | |||||
} | |||||
b2 := []byte{} | |||||
_, err = FromBytes(b2) | |||||
if err == nil { | |||||
t.Errorf("Should return error parsing from empty byte slice, got %s", err) | |||||
} | |||||
} | |||||
func TestMarshalBinary(t *testing.T) { | |||||
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() | |||||
if err != nil { | |||||
t.Errorf("Error marshaling UUID: %s", err) | |||||
} | |||||
if !bytes.Equal(b1, b2) { | |||||
t.Errorf("Marshaled UUID should be %s, got %s", b1, b2) | |||||
} | |||||
} | |||||
func TestUnmarshalBinary(t *testing.T) { | |||||
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) | |||||
if err != nil { | |||||
t.Errorf("Error unmarshaling UUID: %s", err) | |||||
} | |||||
if !Equal(u, u1) { | |||||
t.Errorf("UUIDs should be equal: %s and %s", u, u1) | |||||
} | |||||
b2 := []byte{} | |||||
u2 := UUID{} | |||||
err = u2.UnmarshalBinary(b2) | |||||
if err == nil { | |||||
t.Errorf("Should return error unmarshalling from empty byte slice, got %s", err) | |||||
} | |||||
} | |||||
func TestFromString(t *testing.T) { | |||||
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" | |||||
_, err := FromString("") | |||||
if err == nil { | |||||
t.Errorf("Should return error trying to parse empty string, got %s", err) | |||||
} | |||||
u1, err := FromString(s1) | |||||
if err != nil { | |||||
t.Errorf("Error parsing UUID from string: %s", err) | |||||
} | |||||
if !Equal(u, u1) { | |||||
t.Errorf("UUIDs should be equal: %s and %s", u, u1) | |||||
} | |||||
u2, err := FromString(s2) | |||||
if err != nil { | |||||
t.Errorf("Error parsing UUID from string: %s", err) | |||||
} | |||||
if !Equal(u, u2) { | |||||
t.Errorf("UUIDs should be equal: %s and %s", u, u2) | |||||
} | |||||
u3, err := FromString(s3) | |||||
if err != nil { | |||||
t.Errorf("Error parsing UUID from string: %s", err) | |||||
} | |||||
if !Equal(u, u3) { | |||||
t.Errorf("UUIDs should be equal: %s and %s", u, u3) | |||||
} | |||||
} | |||||
func TestMarshalText(t *testing.T) { | |||||
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() | |||||
if err != nil { | |||||
t.Errorf("Error marshaling UUID: %s", err) | |||||
} | |||||
if !bytes.Equal(b1, b2) { | |||||
t.Errorf("Marshaled UUID should be %s, got %s", b1, b2) | |||||
} | |||||
} | |||||
func TestUnmarshalText(t *testing.T) { | |||||
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) | |||||
if err != nil { | |||||
t.Errorf("Error unmarshaling UUID: %s", err) | |||||
} | |||||
if !Equal(u, u1) { | |||||
t.Errorf("UUIDs should be equal: %s and %s", u, u1) | |||||
} | |||||
b2 := []byte("") | |||||
u2 := UUID{} | |||||
err = u2.UnmarshalText(b2) | |||||
if err == nil { | |||||
t.Errorf("Should return error trying to unmarshal from empty string") | |||||
} | |||||
} | |||||
func TestNewV1(t *testing.T) { | |||||
u := NewV1() | |||||
if u.Version() != 1 { | |||||
t.Errorf("UUIDv1 generated with incorrect version: %d", u.Version()) | |||||
} | |||||
if u.Variant() != VariantRFC4122 { | |||||
t.Errorf("UUIDv1 generated with incorrect variant: %d", u.Variant()) | |||||
} | |||||
u1 := NewV1() | |||||
u2 := NewV1() | |||||
if Equal(u1, u2) { | |||||
t.Errorf("UUIDv1 generated two equal UUIDs: %s and %s", u1, u2) | |||||
} | |||||
oldFunc := epochFunc | |||||
epochFunc = func() uint64 { return 0 } | |||||
u3 := NewV1() | |||||
u4 := NewV1() | |||||
if Equal(u3, u4) { | |||||
t.Errorf("UUIDv1 generated two equal UUIDs: %s and %s", u3, u4) | |||||
} | |||||
epochFunc = oldFunc | |||||
} | |||||
func TestNewV2(t *testing.T) { | |||||
u1 := NewV2(DomainPerson) | |||||
if u1.Version() != 2 { | |||||
t.Errorf("UUIDv2 generated with incorrect version: %d", u1.Version()) | |||||
} | |||||
if u1.Variant() != VariantRFC4122 { | |||||
t.Errorf("UUIDv2 generated with incorrect variant: %d", u1.Variant()) | |||||
} | |||||
u2 := NewV2(DomainGroup) | |||||
if u2.Version() != 2 { | |||||
t.Errorf("UUIDv2 generated with incorrect version: %d", u2.Version()) | |||||
} | |||||
if u2.Variant() != VariantRFC4122 { | |||||
t.Errorf("UUIDv2 generated with incorrect variant: %d", u2.Variant()) | |||||
} | |||||
} | |||||
func TestNewV3(t *testing.T) { | |||||
u := NewV3(NamespaceDNS, "www.example.com") | |||||
if u.Version() != 3 { | |||||
t.Errorf("UUIDv3 generated with incorrect version: %d", u.Version()) | |||||
} | |||||
if u.Variant() != VariantRFC4122 { | |||||
t.Errorf("UUIDv3 generated with incorrect variant: %d", u.Variant()) | |||||
} | |||||
if u.String() != "5df41881-3aed-3515-88a7-2f4a814cf09e" { | |||||
t.Errorf("UUIDv3 generated incorrectly: %s", u.String()) | |||||
} | |||||
u = NewV3(NamespaceDNS, "python.org") | |||||
if u.String() != "6fa459ea-ee8a-3ca4-894e-db77e160355e" { | |||||
t.Errorf("UUIDv3 generated incorrectly: %s", u.String()) | |||||
} | |||||
u1 := NewV3(NamespaceDNS, "golang.org") | |||||
u2 := NewV3(NamespaceDNS, "golang.org") | |||||
if !Equal(u1, u2) { | |||||
t.Errorf("UUIDv3 generated different UUIDs for same namespace and name: %s and %s", u1, u2) | |||||
} | |||||
u3 := NewV3(NamespaceDNS, "example.com") | |||||
if Equal(u1, u3) { | |||||
t.Errorf("UUIDv3 generated same UUIDs for different names in same namespace: %s and %s", u1, u2) | |||||
} | |||||
u4 := NewV3(NamespaceURL, "golang.org") | |||||
if Equal(u1, u4) { | |||||
t.Errorf("UUIDv3 generated same UUIDs for sane names in different namespaces: %s and %s", u1, u4) | |||||
} | |||||
} | |||||
func TestNewV4(t *testing.T) { | |||||
u := NewV4() | |||||
if u.Version() != 4 { | |||||
t.Errorf("UUIDv4 generated with incorrect version: %d", u.Version()) | |||||
} | |||||
if u.Variant() != VariantRFC4122 { | |||||
t.Errorf("UUIDv4 generated with incorrect variant: %d", u.Variant()) | |||||
} | |||||
} | |||||
func TestNewV5(t *testing.T) { | |||||
u := NewV5(NamespaceDNS, "www.example.com") | |||||
if u.Version() != 5 { | |||||
t.Errorf("UUIDv5 generated with incorrect version: %d", u.Version()) | |||||
} | |||||
if u.Variant() != VariantRFC4122 { | |||||
t.Errorf("UUIDv5 generated with incorrect variant: %d", u.Variant()) | |||||
} | |||||
u = NewV5(NamespaceDNS, "python.org") | |||||
if u.String() != "886313e1-3b8a-5372-9b90-0c9aee199e5d" { | |||||
t.Errorf("UUIDv5 generated incorrectly: %s", u.String()) | |||||
} | |||||
u1 := NewV5(NamespaceDNS, "golang.org") | |||||
u2 := NewV5(NamespaceDNS, "golang.org") | |||||
if !Equal(u1, u2) { | |||||
t.Errorf("UUIDv5 generated different UUIDs for same namespace and name: %s and %s", u1, u2) | |||||
} | |||||
u3 := NewV5(NamespaceDNS, "example.com") | |||||
if Equal(u1, u3) { | |||||
t.Errorf("UUIDv5 generated same UUIDs for different names in same namespace: %s and %s", u1, u2) | |||||
} | |||||
u4 := NewV5(NamespaceURL, "golang.org") | |||||
if Equal(u1, u4) { | |||||
t.Errorf("UUIDv3 generated same UUIDs for sane names in different namespaces: %s and %s", u1, u4) | |||||
} | |||||
} |