Skip to content
GitLab
Projects
Groups
Snippets
Help
Loading...
Help
What's new
10
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Open sidebar
dms3
go-datastore
Commits
245a981a
Commit
245a981a
authored
May 29, 2015
by
Juan Batiz-Benet
Browse files
Options
Browse Files
Download
Plain Diff
Merge pull request #21 from cryptix/master
switch uuid implementation
parents
751a1b4a
8a5ce731
Changes
19
Hide whitespace changes
Inline
Side-by-side
Showing
19 changed files
with
1098 additions
and
1075 deletions
+1098
-1075
Godeps/Godeps.json
Godeps/Godeps.json
+5
-6
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/LICENSE
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/LICENSE
+0
-27
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/dce.go
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/dce.go
+0
-84
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/doc.go
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/doc.go
+0
-8
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/hash.go
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/hash.go
+0
-53
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/node.go
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/node.go
+0
-101
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/time.go
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/time.go
+0
-132
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/util.go
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/util.go
+0
-43
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/uuid.go
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/uuid.go
+0
-163
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/uuid_test.go
...workspace/src/code.google.com/p/go-uuid/uuid/uuid_test.go
+0
-390
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/version1.go
..._workspace/src/code.google.com/p/go-uuid/uuid/version1.go
+0
-41
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/version4.go
..._workspace/src/code.google.com/p/go-uuid/uuid/version4.go
+0
-25
Godeps/_workspace/src/github.com/satori/go.uuid/.travis.yml
Godeps/_workspace/src/github.com/satori/go.uuid/.travis.yml
+10
-0
Godeps/_workspace/src/github.com/satori/go.uuid/LICENSE
Godeps/_workspace/src/github.com/satori/go.uuid/LICENSE
+20
-0
Godeps/_workspace/src/github.com/satori/go.uuid/README.md
Godeps/_workspace/src/github.com/satori/go.uuid/README.md
+66
-0
Godeps/_workspace/src/github.com/satori/go.uuid/benchmarks_test.go
...orkspace/src/github.com/satori/go.uuid/benchmarks_test.go
+121
-0
Godeps/_workspace/src/github.com/satori/go.uuid/uuid.go
Godeps/_workspace/src/github.com/satori/go.uuid/uuid.go
+397
-0
Godeps/_workspace/src/github.com/satori/go.uuid/uuid_test.go
Godeps/_workspace/src/github.com/satori/go.uuid/uuid_test.go
+477
-0
key.go
key.go
+2
-2
No files found.
Godeps/Godeps.json
View file @
245a981a
{
"ImportPath"
:
"github.com/jbenet/go-datastore"
,
"GoVersion"
:
"go1.4"
,
"GoVersion"
:
"go1.4
.2
"
,
"Packages"
:
[
"./..."
],
"Deps"
:
[
{
"ImportPath"
:
"code.google.com/p/go-uuid/uuid"
,
"Comment"
:
"null-12"
,
"Rev"
:
"7dda39b2e7d5e265014674c5af696ba4186679e9"
},
{
"ImportPath"
:
"github.com/codahale/blake2"
,
"Rev"
:
"3fa823583afba430e8fc7cdbcc670dbf90bfacc4"
...
...
@@ -34,6 +29,10 @@
"ImportPath"
:
"github.com/jbenet/goprocess"
,
"Rev"
:
"5b02f8d275a2dd882fb06f8bbdf74347795ff3b1"
},
{
"ImportPath"
:
"github.com/satori/go.uuid"
,
"Rev"
:
"7c7f2020c4c9491594b85767967f4619c2fa75f9"
},
{
"ImportPath"
:
"github.com/mattbaird/elastigo/api"
,
"Rev"
:
"041b88c1fcf6489a5721ede24378ce1253b9159d"
...
...
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/LICENSE
deleted
100644 → 0
View file @
751a1b4a
Copyright (c) 2009 Google Inc. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/dce.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
import
(
"encoding/binary"
"fmt"
"os"
)
// A Domain represents a Version 2 domain
type
Domain
byte
// Domain constants for DCE Security (Version 2) UUIDs.
const
(
Person
=
Domain
(
0
)
Group
=
Domain
(
1
)
Org
=
Domain
(
2
)
)
// NewDCESecurity returns a DCE Security (Version 2) UUID.
//
// The domain should be one of Person, Group or Org.
// On a POSIX system the id should be the users UID for the Person
// domain and the users GID for the Group. The meaning of id for
// the domain Org or on non-POSIX systems is site defined.
//
// For a given domain/id pair the same token may be returned for up to
// 7 minutes and 10 seconds.
func
NewDCESecurity
(
domain
Domain
,
id
uint32
)
UUID
{
uuid
:=
NewUUID
()
if
uuid
!=
nil
{
uuid
[
6
]
=
(
uuid
[
6
]
&
0x0f
)
|
0x20
// Version 2
uuid
[
9
]
=
byte
(
domain
)
binary
.
BigEndian
.
PutUint32
(
uuid
[
0
:
],
id
)
}
return
uuid
}
// NewDCEPerson returns a DCE Security (Version 2) UUID in the person
// domain with the id returned by os.Getuid.
//
// NewDCEPerson(Person, uint32(os.Getuid()))
func
NewDCEPerson
()
UUID
{
return
NewDCESecurity
(
Person
,
uint32
(
os
.
Getuid
()))
}
// NewDCEGroup returns a DCE Security (Version 2) UUID in the group
// domain with the id returned by os.Getgid.
//
// NewDCEGroup(Group, uint32(os.Getgid()))
func
NewDCEGroup
()
UUID
{
return
NewDCESecurity
(
Group
,
uint32
(
os
.
Getgid
()))
}
// Domain returns the domain for a Version 2 UUID or false.
func
(
uuid
UUID
)
Domain
()
(
Domain
,
bool
)
{
if
v
,
_
:=
uuid
.
Version
();
v
!=
2
{
return
0
,
false
}
return
Domain
(
uuid
[
9
]),
true
}
// Id returns the id for a Version 2 UUID or false.
func
(
uuid
UUID
)
Id
()
(
uint32
,
bool
)
{
if
v
,
_
:=
uuid
.
Version
();
v
!=
2
{
return
0
,
false
}
return
binary
.
BigEndian
.
Uint32
(
uuid
[
0
:
4
]),
true
}
func
(
d
Domain
)
String
()
string
{
switch
d
{
case
Person
:
return
"Person"
case
Group
:
return
"Group"
case
Org
:
return
"Org"
}
return
fmt
.
Sprintf
(
"Domain%d"
,
int
(
d
))
}
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/doc.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// The uuid package generates and inspects UUIDs.
//
// UUIDs are based on RFC 4122 and DCE 1.1: Authentication and Security Services.
package
uuid
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/hash.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
import
(
"crypto/md5"
"crypto/sha1"
"hash"
)
// Well known Name Space IDs and UUIDs
var
(
NameSpace_DNS
=
Parse
(
"6ba7b810-9dad-11d1-80b4-00c04fd430c8"
)
NameSpace_URL
=
Parse
(
"6ba7b811-9dad-11d1-80b4-00c04fd430c8"
)
NameSpace_OID
=
Parse
(
"6ba7b812-9dad-11d1-80b4-00c04fd430c8"
)
NameSpace_X500
=
Parse
(
"6ba7b814-9dad-11d1-80b4-00c04fd430c8"
)
NIL
=
Parse
(
"00000000-0000-0000-0000-000000000000"
)
)
// NewHash returns a new UUID dervied from the hash of space concatenated with
// data generated by h. The hash should be at least 16 byte in length. The
// first 16 bytes of the hash are used to form the UUID. The version of the
// UUID will be the lower 4 bits of version. NewHash is used to implement
// NewMD5 and NewSHA1.
func
NewHash
(
h
hash
.
Hash
,
space
UUID
,
data
[]
byte
,
version
int
)
UUID
{
h
.
Reset
()
h
.
Write
(
space
)
h
.
Write
([]
byte
(
data
))
s
:=
h
.
Sum
(
nil
)
uuid
:=
make
([]
byte
,
16
)
copy
(
uuid
,
s
)
uuid
[
6
]
=
(
uuid
[
6
]
&
0x0f
)
|
uint8
((
version
&
0xf
)
<<
4
)
uuid
[
8
]
=
(
uuid
[
8
]
&
0x3f
)
|
0x80
// RFC 4122 variant
return
uuid
}
// NewMD5 returns a new MD5 (Version 3) UUID based on the
// supplied name space and data.
//
// NewHash(md5.New(), space, data, 3)
func
NewMD5
(
space
UUID
,
data
[]
byte
)
UUID
{
return
NewHash
(
md5
.
New
(),
space
,
data
,
3
)
}
// NewSHA1 returns a new SHA1 (Version 5) UUID based on the
// supplied name space and data.
//
// NewHash(sha1.New(), space, data, 5)
func
NewSHA1
(
space
UUID
,
data
[]
byte
)
UUID
{
return
NewHash
(
sha1
.
New
(),
space
,
data
,
5
)
}
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/node.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
import
"net"
var
(
interfaces
[]
net
.
Interface
// cached list of interfaces
ifname
string
// name of interface being used
nodeID
[]
byte
// hardware for version 1 UUIDs
)
// NodeInterface returns the name of the interface from which the NodeID was
// derived. The interface "user" is returned if the NodeID was set by
// SetNodeID.
func
NodeInterface
()
string
{
return
ifname
}
// SetNodeInterface selects the hardware address to be used for Version 1 UUIDs.
// If name is "" then the first usable interface found will be used or a random
// Node ID will be generated. If a named interface cannot be found then false
// is returned.
//
// SetNodeInterface never fails when name is "".
func
SetNodeInterface
(
name
string
)
bool
{
if
interfaces
==
nil
{
var
err
error
interfaces
,
err
=
net
.
Interfaces
()
if
err
!=
nil
&&
name
!=
""
{
return
false
}
}
for
_
,
ifs
:=
range
interfaces
{
if
len
(
ifs
.
HardwareAddr
)
>=
6
&&
(
name
==
""
||
name
==
ifs
.
Name
)
{
if
setNodeID
(
ifs
.
HardwareAddr
)
{
ifname
=
ifs
.
Name
return
true
}
}
}
// We found no interfaces with a valid hardware address. If name
// does not specify a specific interface generate a random Node ID
// (section 4.1.6)
if
name
==
""
{
if
nodeID
==
nil
{
nodeID
=
make
([]
byte
,
6
)
}
randomBits
(
nodeID
)
return
true
}
return
false
}
// NodeID returns a slice of a copy of the current Node ID, setting the Node ID
// if not already set.
func
NodeID
()
[]
byte
{
if
nodeID
==
nil
{
SetNodeInterface
(
""
)
}
nid
:=
make
([]
byte
,
6
)
copy
(
nid
,
nodeID
)
return
nid
}
// SetNodeID sets the Node ID to be used for Version 1 UUIDs. The first 6 bytes
// of id are used. If id is less than 6 bytes then false is returned and the
// Node ID is not set.
func
SetNodeID
(
id
[]
byte
)
bool
{
if
setNodeID
(
id
)
{
ifname
=
"user"
return
true
}
return
false
}
func
setNodeID
(
id
[]
byte
)
bool
{
if
len
(
id
)
<
6
{
return
false
}
if
nodeID
==
nil
{
nodeID
=
make
([]
byte
,
6
)
}
copy
(
nodeID
,
id
)
return
true
}
// NodeID returns the 6 byte node id encoded in uuid. It returns nil if uuid is
// not valid. The NodeID is only well defined for version 1 and 2 UUIDs.
func
(
uuid
UUID
)
NodeID
()
[]
byte
{
if
len
(
uuid
)
!=
16
{
return
nil
}
node
:=
make
([]
byte
,
6
)
copy
(
node
,
uuid
[
10
:
])
return
node
}
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/time.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2014 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
import
(
"encoding/binary"
"sync"
"time"
)
// A Time represents a time as the number of 100's of nanoseconds since 15 Oct
// 1582.
type
Time
int64
const
(
lillian
=
2299160
// Julian day of 15 Oct 1582
unix
=
2440587
// Julian day of 1 Jan 1970
epoch
=
unix
-
lillian
// Days between epochs
g1582
=
epoch
*
86400
// seconds between epochs
g1582ns100
=
g1582
*
10000000
// 100s of a nanoseconds between epochs
)
var
(
mu
sync
.
Mutex
lasttime
uint64
// last time we returned
clock_seq
uint16
// clock sequence for this run
timeNow
=
time
.
Now
// for testing
)
// UnixTime converts t the number of seconds and nanoseconds using the Unix
// epoch of 1 Jan 1970.
func
(
t
Time
)
UnixTime
()
(
sec
,
nsec
int64
)
{
sec
=
int64
(
t
-
g1582ns100
)
nsec
=
(
sec
%
10000000
)
*
100
sec
/=
10000000
return
sec
,
nsec
}
// GetTime returns the current Time (100s of nanoseconds since 15 Oct 1582) and
// adjusts the clock sequence as needed. An error is returned if the current
// time cannot be determined.
func
GetTime
()
(
Time
,
error
)
{
defer
mu
.
Unlock
()
mu
.
Lock
()
return
getTime
()
}
func
getTime
()
(
Time
,
error
)
{
t
:=
timeNow
()
// If we don't have a clock sequence already, set one.
if
clock_seq
==
0
{
setClockSequence
(
-
1
)
}
now
:=
uint64
(
t
.
UnixNano
()
/
100
)
+
g1582ns100
// If time has gone backwards with this clock sequence then we
// increment the clock sequence
if
now
<=
lasttime
{
clock_seq
=
((
clock_seq
+
1
)
&
0x3fff
)
|
0x8000
}
lasttime
=
now
return
Time
(
now
),
nil
}
// ClockSequence returns the current clock sequence, generating one if not
// already set. The clock sequence is only used for Version 1 UUIDs.
//
// The uuid package does not use global static storage for the clock sequence or
// the last time a UUID was generated. Unless SetClockSequence a new random
// clock sequence is generated the first time a clock sequence is requested by
// ClockSequence, GetTime, or NewUUID. (section 4.2.1.1) sequence is generated
// for
func
ClockSequence
()
int
{
defer
mu
.
Unlock
()
mu
.
Lock
()
return
clockSequence
()
}
func
clockSequence
()
int
{
if
clock_seq
==
0
{
setClockSequence
(
-
1
)
}
return
int
(
clock_seq
&
0x3fff
)
}
// SetClockSeq sets the clock sequence to the lower 14 bits of seq. Setting to
// -1 causes a new sequence to be generated.
func
SetClockSequence
(
seq
int
)
{
defer
mu
.
Unlock
()
mu
.
Lock
()
setClockSequence
(
seq
)
}
func
setClockSequence
(
seq
int
)
{
if
seq
==
-
1
{
var
b
[
2
]
byte
randomBits
(
b
[
:
])
// clock sequence
seq
=
int
(
b
[
0
])
<<
8
|
int
(
b
[
1
])
}
old_seq
:=
clock_seq
clock_seq
=
uint16
(
seq
&
0x3fff
)
|
0x8000
// Set our variant
if
old_seq
!=
clock_seq
{
lasttime
=
0
}
}
// Time returns the time in 100s of nanoseconds since 15 Oct 1582 encoded in
// uuid. It returns false if uuid is not valid. The time is only well defined
// for version 1 and 2 UUIDs.
func
(
uuid
UUID
)
Time
()
(
Time
,
bool
)
{
if
len
(
uuid
)
!=
16
{
return
0
,
false
}
time
:=
int64
(
binary
.
BigEndian
.
Uint32
(
uuid
[
0
:
4
]))
time
|=
int64
(
binary
.
BigEndian
.
Uint16
(
uuid
[
4
:
6
]))
<<
32
time
|=
int64
(
binary
.
BigEndian
.
Uint16
(
uuid
[
6
:
8
])
&
0xfff
)
<<
48
return
Time
(
time
),
true
}
// ClockSequence returns the clock sequence encoded in uuid. It returns false
// if uuid is not valid. The clock sequence is only well defined for version 1
// and 2 UUIDs.
func
(
uuid
UUID
)
ClockSequence
()
(
int
,
bool
)
{
if
len
(
uuid
)
!=
16
{
return
0
,
false
}
return
int
(
binary
.
BigEndian
.
Uint16
(
uuid
[
8
:
10
]))
&
0x3fff
,
true
}
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/util.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
import
(
"io"
)
// randomBits completely fills slice b with random data.
func
randomBits
(
b
[]
byte
)
{
if
_
,
err
:=
io
.
ReadFull
(
rander
,
b
);
err
!=
nil
{
panic
(
err
.
Error
())
// rand should never fail
}
}
// xvalues returns the value of a byte as a hexadecimal digit or 255.
var
xvalues
=
[]
byte
{
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
0
,
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
10
,
11
,
12
,
13
,
14
,
15
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
10
,
11
,
12
,
13
,
14
,
15
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
255
,
}
// xtob converts the the first two hex bytes of x into a byte.
func
xtob
(
x
string
)
(
byte
,
bool
)
{
b1
:=
xvalues
[
x
[
0
]]
b2
:=
xvalues
[
x
[
1
]]
return
(
b1
<<
4
)
|
b2
,
b1
!=
255
&&
b2
!=
255
}
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/uuid.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
import
(
"bytes"
"crypto/rand"
"fmt"
"io"
"strings"
)
// A UUID is a 128 bit (16 byte) Universal Unique IDentifier as defined in RFC
// 4122.
type
UUID
[]
byte
// A Version represents a UUIDs version.
type
Version
byte
// A Variant represents a UUIDs variant.
type
Variant
byte
// Constants returned by Variant.
const
(
Invalid
=
Variant
(
iota
)
// Invalid UUID
RFC4122
// The variant specified in RFC4122
Reserved
// Reserved, NCS backward compatibility.
Microsoft
// Reserved, Microsoft Corporation backward compatibility.
Future
// Reserved for future definition.
)
var
rander
=
rand
.
Reader
// random function
// New returns a new random (version 4) UUID as a string. It is a convenience
// function for NewRandom().String().
func
New
()
string
{
return
NewRandom
()
.
String
()
}
// Parse decodes s into a UUID or returns nil. Both the UUID form of
// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx and
// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded.
func
Parse
(
s
string
)
UUID
{
if
len
(
s
)
==
36
+
9
{
if
strings
.
ToLower
(
s
[
:
9
])
!=
"urn:uuid:"
{
return
nil
}
s
=
s
[
9
:
]
}
else
if
len
(
s
)
!=
36
{
return
nil
}
if
s
[
8
]
!=
'-'
||
s
[
13
]
!=
'-'
||
s
[
18
]
!=
'-'
||
s
[
23
]
!=
'-'
{
return
nil
}
uuid
:=
make
([]
byte
,
16
)
for
i
,
x
:=
range
[]
int
{
0
,
2
,
4
,
6
,
9
,
11
,
14
,
16
,
19
,
21
,
24
,
26
,
28
,
30
,
32
,
34
}
{
if
v
,
ok
:=
xtob
(
s
[
x
:
]);
!
ok
{
return
nil
}
else
{
uuid
[
i
]
=
v
}
}
return
uuid
}
// Equal returns true if uuid1 and uuid2 are equal.
func
Equal
(
uuid1
,
uuid2
UUID
)
bool
{
return
bytes
.
Equal
(
uuid1
,
uuid2
)
}
// String returns the string form of uuid, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
// , or "" if uuid is invalid.
func
(
uuid
UUID
)
String
()
string
{
if
uuid
==
nil
||
len
(
uuid
)
!=
16
{
return
""
}
b
:=
[]
byte
(
uuid
)
return
fmt
.
Sprintf
(
"%08x-%04x-%04x-%04x-%012x"
,
b
[
:
4
],
b
[
4
:
6
],
b
[
6
:
8
],
b
[
8
:
10
],
b
[
10
:
])
}
// URN returns the RFC 2141 URN form of uuid,
// urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, or "" if uuid is invalid.
func
(
uuid
UUID
)
URN
()
string
{
if
uuid
==
nil
||
len
(
uuid
)
!=
16
{
return
""
}
b
:=
[]
byte
(
uuid
)
return
fmt
.
Sprintf
(
"urn:uuid:%08x-%04x-%04x-%04x-%012x"
,
b
[
:
4
],
b
[
4
:
6
],
b
[
6
:
8
],
b
[
8
:
10
],
b
[
10
:
])
}
// Variant returns the variant encoded in uuid. It returns Invalid if
// uuid is invalid.
func
(
uuid
UUID
)
Variant
()
Variant
{
if
len
(
uuid
)
!=
16
{
return
Invalid
}
switch
{
case
(
uuid
[
8
]
&
0xc0
)
==
0x80
:
return
RFC4122
case
(
uuid
[
8
]
&
0xe0
)
==
0xc0
:
return
Microsoft
case
(
uuid
[
8
]
&
0xe0
)
==
0xe0
:
return
Future
default
:
return
Reserved
}
panic
(
"unreachable"
)
}
// Version returns the verison of uuid. It returns false if uuid is not
// valid.
func
(
uuid
UUID
)
Version
()
(
Version
,
bool
)
{
if
len
(
uuid
)
!=
16
{
return
0
,
false
}
return
Version
(
uuid
[
6
]
>>
4
),
true
}
func
(
v
Version
)
String
()
string
{
if
v
>
15
{
return
fmt
.
Sprintf
(
"BAD_VERSION_%d"
,
v
)
}
return
fmt
.
Sprintf
(
"VERSION_%d"
,
v
)
}
func
(
v
Variant
)
String
()
string
{
switch
v
{
case
RFC4122
:
return
"RFC4122"
case
Reserved
:
return
"Reserved"
case
Microsoft
:
return
"Microsoft"
case
Future
:
return
"Future"
case
Invalid
:
return
"Invalid"
}
return
fmt
.
Sprintf
(
"BadVariant%d"
,
int
(
v
))
}
// SetRand sets the random number generator to r, which implents io.Reader.
// If r.Read returns an error when the package requests random data then
// a panic will be issued.
//
// Calling SetRand with nil sets the random number generator to the default
// generator.
func
SetRand
(
r
io
.
Reader
)
{
if
r
==
nil
{
rander
=
rand
.
Reader
return
}
rander
=
r
}
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/uuid_test.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
import
(
"bytes"
"fmt"
"os"
"strings"
"testing"
"time"
)
type
test
struct
{
in
string
version
Version
variant
Variant
isuuid
bool
}
var
tests
=
[]
test
{
{
"f47ac10b-58cc-0372-8567-0e02b2c3d479"
,
0
,
RFC4122
,
true
},
{
"f47ac10b-58cc-1372-8567-0e02b2c3d479"
,
1
,
RFC4122
,
true
},
{
"f47ac10b-58cc-2372-8567-0e02b2c3d479"
,
2
,
RFC4122
,
true
},
{
"f47ac10b-58cc-3372-8567-0e02b2c3d479"
,
3
,
RFC4122
,
true
},
{
"f47ac10b-58cc-4372-8567-0e02b2c3d479"
,
4
,
RFC4122
,
true
},
{
"f47ac10b-58cc-5372-8567-0e02b2c3d479"
,
5
,
RFC4122
,
true
},
{
"f47ac10b-58cc-6372-8567-0e02b2c3d479"
,
6
,
RFC4122
,
true
},
{
"f47ac10b-58cc-7372-8567-0e02b2c3d479"
,
7
,
RFC4122
,
true
},
{
"f47ac10b-58cc-8372-8567-0e02b2c3d479"
,
8
,
RFC4122
,
true
},
{
"f47ac10b-58cc-9372-8567-0e02b2c3d479"
,
9
,
RFC4122
,
true
},
{
"f47ac10b-58cc-a372-8567-0e02b2c3d479"
,
10
,
RFC4122
,
true
},
{
"f47ac10b-58cc-b372-8567-0e02b2c3d479"
,
11
,
RFC4122
,
true
},
{
"f47ac10b-58cc-c372-8567-0e02b2c3d479"
,
12
,
RFC4122
,
true
},
{
"f47ac10b-58cc-d372-8567-0e02b2c3d479"
,
13
,
RFC4122
,
true
},
{
"f47ac10b-58cc-e372-8567-0e02b2c3d479"
,
14
,
RFC4122
,
true
},
{
"f47ac10b-58cc-f372-8567-0e02b2c3d479"
,
15
,
RFC4122
,
true
},
{
"urn:uuid:f47ac10b-58cc-4372-0567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"URN:UUID:f47ac10b-58cc-4372-0567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-0567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-1567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-2567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-3567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-4567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-5567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-6567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-7567-0e02b2c3d479"
,
4
,
Reserved
,
true
},
{
"f47ac10b-58cc-4372-8567-0e02b2c3d479"
,
4
,
RFC4122
,
true
},
{
"f47ac10b-58cc-4372-9567-0e02b2c3d479"
,
4
,
RFC4122
,
true
},
{
"f47ac10b-58cc-4372-a567-0e02b2c3d479"
,
4
,
RFC4122
,
true
},
{
"f47ac10b-58cc-4372-b567-0e02b2c3d479"
,
4
,
RFC4122
,
true
},
{
"f47ac10b-58cc-4372-c567-0e02b2c3d479"
,
4
,
Microsoft
,
true
},
{
"f47ac10b-58cc-4372-d567-0e02b2c3d479"
,
4
,
Microsoft
,
true
},
{
"f47ac10b-58cc-4372-e567-0e02b2c3d479"
,
4
,
Future
,
true
},
{
"f47ac10b-58cc-4372-f567-0e02b2c3d479"
,
4
,
Future
,
true
},
{
"f47ac10b158cc-5372-a567-0e02b2c3d479"
,
0
,
Invalid
,
false
},
{
"f47ac10b-58cc25372-a567-0e02b2c3d479"
,
0
,
Invalid
,
false
},
{
"f47ac10b-58cc-53723a567-0e02b2c3d479"
,
0
,
Invalid
,
false
},
{
"f47ac10b-58cc-5372-a56740e02b2c3d479"
,
0
,
Invalid
,
false
},
{
"f47ac10b-58cc-5372-a567-0e02-2c3d479"
,
0
,
Invalid
,
false
},
{
"g47ac10b-58cc-4372-a567-0e02b2c3d479"
,
0
,
Invalid
,
false
},
}
var
constants
=
[]
struct
{
c
interface
{}
name
string
}{
{
Person
,
"Person"
},
{
Group
,
"Group"
},
{
Org
,
"Org"
},
{
Invalid
,
"Invalid"
},
{
RFC4122
,
"RFC4122"
},
{
Reserved
,
"Reserved"
},
{
Microsoft
,
"Microsoft"
},
{
Future
,
"Future"
},
{
Domain
(
17
),
"Domain17"
},
{
Variant
(
42
),
"BadVariant42"
},
}
func
testTest
(
t
*
testing
.
T
,
in
string
,
tt
test
)
{
uuid
:=
Parse
(
in
)
if
ok
:=
(
uuid
!=
nil
);
ok
!=
tt
.
isuuid
{
t
.
Errorf
(
"Parse(%s) got %v expected %v
\b
"
,
in
,
ok
,
tt
.
isuuid
)
}
if
uuid
==
nil
{
return
}
if
v
:=
uuid
.
Variant
();
v
!=
tt
.
variant
{
t
.
Errorf
(
"Variant(%s) got %d expected %d
\b
"
,
in
,
v
,
tt
.
variant
)
}
if
v
,
_
:=
uuid
.
Version
();
v
!=
tt
.
version
{
t
.
Errorf
(
"Version(%s) got %d expected %d
\b
"
,
in
,
v
,
tt
.
version
)
}
}
func
TestUUID
(
t
*
testing
.
T
)
{
for
_
,
tt
:=
range
tests
{
testTest
(
t
,
tt
.
in
,
tt
)
testTest
(
t
,
strings
.
ToUpper
(
tt
.
in
),
tt
)
}
}
func
TestConstants
(
t
*
testing
.
T
)
{
for
x
,
tt
:=
range
constants
{
v
,
ok
:=
tt
.
c
.
(
fmt
.
Stringer
)
if
!
ok
{
t
.
Errorf
(
"%x: %v: not a stringer"
,
x
,
v
)
}
else
if
s
:=
v
.
String
();
s
!=
tt
.
name
{
v
,
_
:=
tt
.
c
.
(
int
)
t
.
Errorf
(
"%x: Constant %T:%d gives %q, expected %q
\n
"
,
x
,
tt
.
c
,
v
,
s
,
tt
.
name
)
}
}
}
func
TestRandomUUID
(
t
*
testing
.
T
)
{
m
:=
make
(
map
[
string
]
bool
)
for
x
:=
1
;
x
<
32
;
x
++
{
uuid
:=
NewRandom
()
s
:=
uuid
.
String
()
if
m
[
s
]
{
t
.
Errorf
(
"NewRandom returned duplicated UUID %s
\n
"
,
s
)
}
m
[
s
]
=
true
if
v
,
_
:=
uuid
.
Version
();
v
!=
4
{
t
.
Errorf
(
"Random UUID of version %s
\n
"
,
v
)
}
if
uuid
.
Variant
()
!=
RFC4122
{
t
.
Errorf
(
"Random UUID is variant %d
\n
"
,
uuid
.
Variant
())
}
}
}
func
TestNew
(
t
*
testing
.
T
)
{
m
:=
make
(
map
[
string
]
bool
)
for
x
:=
1
;
x
<
32
;
x
++
{
s
:=
New
()
if
m
[
s
]
{
t
.
Errorf
(
"New returned duplicated UUID %s
\n
"
,
s
)
}
m
[
s
]
=
true
uuid
:=
Parse
(
s
)
if
uuid
==
nil
{
t
.
Errorf
(
"New returned %q which does not decode
\n
"
,
s
)
continue
}
if
v
,
_
:=
uuid
.
Version
();
v
!=
4
{
t
.
Errorf
(
"Random UUID of version %s
\n
"
,
v
)
}
if
uuid
.
Variant
()
!=
RFC4122
{
t
.
Errorf
(
"Random UUID is variant %d
\n
"
,
uuid
.
Variant
())
}
}
}
func
clockSeq
(
t
*
testing
.
T
,
uuid
UUID
)
int
{
seq
,
ok
:=
uuid
.
ClockSequence
()
if
!
ok
{
t
.
Fatalf
(
"%s: invalid clock sequence
\n
"
,
uuid
)
}
return
seq
}
func
TestClockSeq
(
t
*
testing
.
T
)
{
// Fake time.Now for this test to return a monotonically advancing time; restore it at end.
defer
func
(
orig
func
()
time
.
Time
)
{
timeNow
=
orig
}(
timeNow
)
monTime
:=
time
.
Now
()
timeNow
=
func
()
time
.
Time
{
monTime
=
monTime
.
Add
(
1
*
time
.
Second
)
return
monTime
}
SetClockSequence
(
-
1
)
uuid1
:=
NewUUID
()
uuid2
:=
NewUUID
()
if
clockSeq
(
t
,
uuid1
)
!=
clockSeq
(
t
,
uuid2
)
{
t
.
Errorf
(
"clock sequence %d != %d
\n
"
,
clockSeq
(
t
,
uuid1
),
clockSeq
(
t
,
uuid2
))
}
SetClockSequence
(
-
1
)
uuid2
=
NewUUID
()
// Just on the very off chance we generated the same sequence
// two times we try again.
if
clockSeq
(
t
,
uuid1
)
==
clockSeq
(
t
,
uuid2
)
{
SetClockSequence
(
-
1
)
uuid2
=
NewUUID
()
}
if
clockSeq
(
t
,
uuid1
)
==
clockSeq
(
t
,
uuid2
)
{
t
.
Errorf
(
"Duplicate clock sequence %d
\n
"
,
clockSeq
(
t
,
uuid1
))
}
SetClockSequence
(
0x1234
)
uuid1
=
NewUUID
()
if
seq
:=
clockSeq
(
t
,
uuid1
);
seq
!=
0x1234
{
t
.
Errorf
(
"%s: expected seq 0x1234 got 0x%04x
\n
"
,
uuid1
,
seq
)
}
}
func
TestCoding
(
t
*
testing
.
T
)
{
text
:=
"7d444840-9dc0-11d1-b245-5ffdce74fad2"
urn
:=
"urn:uuid:7d444840-9dc0-11d1-b245-5ffdce74fad2"
data
:=
UUID
{
0x7d
,
0x44
,
0x48
,
0x40
,
0x9d
,
0xc0
,
0x11
,
0xd1
,
0xb2
,
0x45
,
0x5f
,
0xfd
,
0xce
,
0x74
,
0xfa
,
0xd2
,
}
if
v
:=
data
.
String
();
v
!=
text
{
t
.
Errorf
(
"%x: encoded to %s, expected %s
\n
"
,
data
,
v
,
text
)
}
if
v
:=
data
.
URN
();
v
!=
urn
{
t
.
Errorf
(
"%x: urn is %s, expected %s
\n
"
,
data
,
v
,
urn
)
}
uuid
:=
Parse
(
text
)
if
!
Equal
(
uuid
,
data
)
{
t
.
Errorf
(
"%s: decoded to %s, expected %s
\n
"
,
text
,
uuid
,
data
)
}
}
func
TestVersion1
(
t
*
testing
.
T
)
{
uuid1
:=
NewUUID
()
uuid2
:=
NewUUID
()
if
Equal
(
uuid1
,
uuid2
)
{
t
.
Errorf
(
"%s:duplicate uuid
\n
"
,
uuid1
)
}
if
v
,
_
:=
uuid1
.
Version
();
v
!=
1
{
t
.
Errorf
(
"%s: version %s expected 1
\n
"
,
uuid1
,
v
)
}
if
v
,
_
:=
uuid2
.
Version
();
v
!=
1
{
t
.
Errorf
(
"%s: version %s expected 1
\n
"
,
uuid2
,
v
)
}
n1
:=
uuid1
.
NodeID
()
n2
:=
uuid2
.
NodeID
()
if
!
bytes
.
Equal
(
n1
,
n2
)
{
t
.
Errorf
(
"Different nodes %x != %x
\n
"
,
n1
,
n2
)
}
t1
,
ok
:=
uuid1
.
Time
()
if
!
ok
{
t
.
Errorf
(
"%s: invalid time
\n
"
,
uuid1
)
}
t2
,
ok
:=
uuid2
.
Time
()
if
!
ok
{
t
.
Errorf
(
"%s: invalid time
\n
"
,
uuid2
)
}
q1
,
ok
:=
uuid1
.
ClockSequence
()
if
!
ok
{
t
.
Errorf
(
"%s: invalid clock sequence
\n
"
,
uuid1
)
}
q2
,
ok
:=
uuid2
.
ClockSequence
()
if
!
ok
{
t
.
Errorf
(
"%s: invalid clock sequence"
,
uuid2
)
}
switch
{
case
t1
==
t2
&&
q1
==
q2
:
t
.
Errorf
(
"time stopped
\n
"
)
case
t1
>
t2
&&
q1
==
q2
:
t
.
Errorf
(
"time reversed
\n
"
)
case
t1
<
t2
&&
q1
!=
q2
:
t
.
Errorf
(
"clock sequence chaned unexpectedly
\n
"
)
}
}
func
TestNodeAndTime
(
t
*
testing
.
T
)
{
// Time is February 5, 1998 12:30:23.136364800 AM GMT
uuid
:=
Parse
(
"7d444840-9dc0-11d1-b245-5ffdce74fad2"
)
node
:=
[]
byte
{
0x5f
,
0xfd
,
0xce
,
0x74
,
0xfa
,
0xd2
}
ts
,
ok
:=
uuid
.
Time
()
if
ok
{
c
:=
time
.
Unix
(
ts
.
UnixTime
())
want
:=
time
.
Date
(
1998
,
2
,
5
,
0
,
30
,
23
,
136364800
,
time
.
UTC
)
if
!
c
.
Equal
(
want
)
{
t
.
Errorf
(
"Got time %v, want %v"
,
c
,
want
)
}
}
else
{
t
.
Errorf
(
"%s: bad time
\n
"
,
uuid
)
}
if
!
bytes
.
Equal
(
node
,
uuid
.
NodeID
())
{
t
.
Errorf
(
"Expected node %v got %v
\n
"
,
node
,
uuid
.
NodeID
())
}
}
func
TestMD5
(
t
*
testing
.
T
)
{
uuid
:=
NewMD5
(
NameSpace_DNS
,
[]
byte
(
"python.org"
))
.
String
()
want
:=
"6fa459ea-ee8a-3ca4-894e-db77e160355e"
if
uuid
!=
want
{
t
.
Errorf
(
"MD5: got %q expected %q
\n
"
,
uuid
,
want
)
}
}
func
TestSHA1
(
t
*
testing
.
T
)
{
uuid
:=
NewSHA1
(
NameSpace_DNS
,
[]
byte
(
"python.org"
))
.
String
()
want
:=
"886313e1-3b8a-5372-9b90-0c9aee199e5d"
if
uuid
!=
want
{
t
.
Errorf
(
"SHA1: got %q expected %q
\n
"
,
uuid
,
want
)
}
}
func
TestNodeID
(
t
*
testing
.
T
)
{
nid
:=
[]
byte
{
1
,
2
,
3
,
4
,
5
,
6
}
SetNodeInterface
(
""
)
s
:=
NodeInterface
()
if
s
==
""
||
s
==
"user"
{
t
.
Errorf
(
"NodeInterface %q after SetInteface
\n
"
,
s
)
}
node1
:=
NodeID
()
if
node1
==
nil
{
t
.
Errorf
(
"NodeID nil after SetNodeInterface
\n
"
,
s
)
}
SetNodeID
(
nid
)
s
=
NodeInterface
()
if
s
!=
"user"
{
t
.
Errorf
(
"Expected NodeInterface %q got %q
\n
"
,
"user"
,
s
)
}
node2
:=
NodeID
()
if
node2
==
nil
{
t
.
Errorf
(
"NodeID nil after SetNodeID
\n
"
,
s
)
}
if
bytes
.
Equal
(
node1
,
node2
)
{
t
.
Errorf
(
"NodeID not changed after SetNodeID
\n
"
,
s
)
}
else
if
!
bytes
.
Equal
(
nid
,
node2
)
{
t
.
Errorf
(
"NodeID is %x, expected %x
\n
"
,
node2
,
nid
)
}
}
func
testDCE
(
t
*
testing
.
T
,
name
string
,
uuid
UUID
,
domain
Domain
,
id
uint32
)
{
if
uuid
==
nil
{
t
.
Errorf
(
"%s failed
\n
"
,
name
)
return
}
if
v
,
_
:=
uuid
.
Version
();
v
!=
2
{
t
.
Errorf
(
"%s: %s: expected version 2, got %s
\n
"
,
name
,
uuid
,
v
)
return
}
if
v
,
ok
:=
uuid
.
Domain
();
!
ok
||
v
!=
domain
{
if
!
ok
{
t
.
Errorf
(
"%s: %d: Domain failed
\n
"
,
name
,
uuid
)
}
else
{
t
.
Errorf
(
"%s: %s: expected domain %d, got %d
\n
"
,
name
,
uuid
,
domain
,
v
)
}
}
if
v
,
ok
:=
uuid
.
Id
();
!
ok
||
v
!=
id
{
if
!
ok
{
t
.
Errorf
(
"%s: %d: Id failed
\n
"
,
name
,
uuid
)
}
else
{
t
.
Errorf
(
"%s: %s: expected id %d, got %d
\n
"
,
name
,
uuid
,
id
,
v
)
}
}
}
func
TestDCE
(
t
*
testing
.
T
)
{
testDCE
(
t
,
"NewDCESecurity"
,
NewDCESecurity
(
42
,
12345678
),
42
,
12345678
)
testDCE
(
t
,
"NewDCEPerson"
,
NewDCEPerson
(),
Person
,
uint32
(
os
.
Getuid
()))
testDCE
(
t
,
"NewDCEGroup"
,
NewDCEGroup
(),
Group
,
uint32
(
os
.
Getgid
()))
}
type
badRand
struct
{}
func
(
r
badRand
)
Read
(
buf
[]
byte
)
(
int
,
error
)
{
for
i
,
_
:=
range
buf
{
buf
[
i
]
=
byte
(
i
)
}
return
len
(
buf
),
nil
}
func
TestBadRand
(
t
*
testing
.
T
)
{
SetRand
(
badRand
{})
uuid1
:=
New
()
uuid2
:=
New
()
if
uuid1
!=
uuid2
{
t
.
Errorf
(
"execpted duplicates, got %q and %q
\n
"
,
uuid1
,
uuid2
)
}
SetRand
(
nil
)
uuid1
=
New
()
uuid2
=
New
()
if
uuid1
==
uuid2
{
t
.
Errorf
(
"unexecpted duplicates, got %q
\n
"
,
uuid1
)
}
}
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/version1.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
import
(
"encoding/binary"
)
// NewUUID returns a Version 1 UUID based on the current NodeID and clock
// sequence, and the current time. If the NodeID has not been set by SetNodeID
// or SetNodeInterface then it will be set automatically. If the NodeID cannot
// be set NewUUID returns nil. If clock sequence has not been set by
// SetClockSequence then it will be set automatically. If GetTime fails to
// return the current NewUUID returns nil.
func
NewUUID
()
UUID
{
if
nodeID
==
nil
{
SetNodeInterface
(
""
)
}
now
,
err
:=
GetTime
()
if
err
!=
nil
{
return
nil
}
uuid
:=
make
([]
byte
,
16
)
time_low
:=
uint32
(
now
&
0xffffffff
)
time_mid
:=
uint16
((
now
>>
32
)
&
0xffff
)
time_hi
:=
uint16
((
now
>>
48
)
&
0x0fff
)
time_hi
|=
0x1000
// Version 1
binary
.
BigEndian
.
PutUint32
(
uuid
[
0
:
],
time_low
)
binary
.
BigEndian
.
PutUint16
(
uuid
[
4
:
],
time_mid
)
binary
.
BigEndian
.
PutUint16
(
uuid
[
6
:
],
time_hi
)
binary
.
BigEndian
.
PutUint16
(
uuid
[
8
:
],
clock_seq
)
copy
(
uuid
[
10
:
],
nodeID
)
return
uuid
}
Godeps/_workspace/src/code.google.com/p/go-uuid/uuid/version4.go
deleted
100644 → 0
View file @
751a1b4a
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package
uuid
// Random returns a Random (Version 4) UUID or panics.
//
// The strength of the UUIDs is based on the strength of the crypto/rand
// package.
//
// A note about uniqueness derived from from the UUID Wikipedia entry:
//
// Randomly generated UUIDs have 122 random bits. One's annual risk of being
// hit by a meteorite is estimated to be one chance in 17 billion, that
// means the probability is about 0.00000000006 (6 × 10−11),
// equivalent to the odds of creating a few tens of trillions of UUIDs in a
// year and having one duplicate.
func
NewRandom
()
UUID
{
uuid
:=
make
([]
byte
,
16
)
randomBits
([]
byte
(
uuid
))
uuid
[
6
]
=
(
uuid
[
6
]
&
0x0f
)
|
0x40
// Version 4
uuid
[
8
]
=
(
uuid
[
8
]
&
0x3f
)
|
0x80
// Variant is 10
return
uuid
}
Godeps/_workspace/src/github.com/satori/go.uuid/.travis.yml
0 → 100644
View file @
245a981a
language
:
go
go
:
-
1.0
-
1.1
-
1.2
-
1.3
-
1.4
sudo
:
false
notifications
:
email
:
false
Godeps/_workspace/src/github.com/satori/go.uuid/LICENSE
0 → 100644
View file @
245a981a
Copyright (C) 2013-2015 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.
Godeps/_workspace/src/github.com/satori/go.uuid/README.md
0 → 100644
View file @
245a981a
# 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.4
## 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-2015 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.
Godeps/_workspace/src/github.com/satori/go.uuid/benchmarks_test.go
0 → 100644
View file @
245a981a
// Copyright (C) 2013-2014 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"
)
}
}
func
BenchmarkMarshalBinary
(
b
*
testing
.
B
)
{
u
:=
NewV4
()
for
i
:=
0
;
i
<
b
.
N
;
i
++
{
u
.
MarshalBinary
()
}
}
func
BenchmarkMarshalText
(
b
*
testing
.
B
)
{
u
:=
NewV4
()
for
i
:=
0
;
i
<
b
.
N
;
i
++
{
u
.
MarshalText
()
}
}
func
BenchmarkUnmarshalBinary
(
b
*
testing
.
B
)
{
bytes
:=
[]
byte
{
0x6b
,
0xa7
,
0xb8
,
0x10
,
0x9d
,
0xad
,
0x11
,
0xd1
,
0x80
,
0xb4
,
0x00
,
0xc0
,
0x4f
,
0xd4
,
0x30
,
0xc8
}
u
:=
UUID
{}
for
i
:=
0
;
i
<
b
.
N
;
i
++
{
u
.
UnmarshalBinary
(
bytes
)
}
}
func
BenchmarkUnmarshalText
(
b
*
testing
.
B
)
{
bytes
:=
[]
byte
(
"6ba7b810-9dad-11d1-80b4-00c04fd430c8"
)
u
:=
UUID
{}
for
i
:=
0
;
i
<
b
.
N
;
i
++
{
u
.
UnmarshalText
(
bytes
)
}
}
func
BenchmarkMarshalToString
(
b
*
testing
.
B
)
{
u
:=
NewV4
()
for
i
:=
0
;
i
<
b
.
N
;
i
++
{
u
.
String
()
}
}
Godeps/_workspace/src/github.com/satori/go.uuid/uuid.go
0 → 100644
View file @
245a981a
// Copyright (C) 2013-2015 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"
"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
// Used in string method conversion
const
dash
byte
=
'-'
// UUID v1/v2 storage.
var
(
storageMutex
sync
.
Mutex
clockSequence
uint16
lastTime
uint64
hardwareAddr
[
6
]
byte
posixUID
=
uint32
(
os
.
Getuid
())
posixGID
=
uint32
(
os
.
Getgid
())
)
// String parse helpers.
var
(
urnPrefix
=
[]
byte
(
"urn:uuid:"
)
byteGroups
=
[]
int
{
8
,
4
,
4
,
4
,
12
}
)
// 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
// The nil UUID is special form of UUID that is specified to have all
// 128 bits set to zero.
var
Nil
=
UUID
{}
// 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
{
buf
:=
make
([]
byte
,
36
)
hex
.
Encode
(
buf
[
0
:
8
],
u
[
0
:
4
])
buf
[
8
]
=
dash
hex
.
Encode
(
buf
[
9
:
13
],
u
[
4
:
6
])
buf
[
13
]
=
dash
hex
.
Encode
(
buf
[
14
:
18
],
u
[
6
:
8
])
buf
[
18
]
=
dash
hex
.
Encode
(
buf
[
19
:
23
],
u
[
8
:
10
])
buf
[
23
]
=
dash
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 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.
// Following formats are supported:
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
func
(
u
*
UUID
)
UnmarshalText
(
text
[]
byte
)
(
err
error
)
{
if
len
(
text
)
<
32
{
err
=
fmt
.
Errorf
(
"uuid: invalid UUID string: %s"
,
text
)
return
}
if
bytes
.
Equal
(
text
[
:
9
],
urnPrefix
)
{
text
=
text
[
9
:
]
}
else
if
text
[
0
]
==
'{'
{
text
=
text
[
1
:
]
}
b
:=
u
[
:
]
for
_
,
byteGroup
:=
range
byteGroups
{
if
text
[
0
]
==
'-'
{
text
=
text
[
1
:
]
}
_
,
err
=
hex
.
Decode
(
b
[
:
byteGroup
/
2
],
text
[
:
byteGroup
])
if
err
!=
nil
{
return
}
text
=
text
[
byteGroup
:
]
b
=
b
[
byteGroup
/
2
:
]
}
return
}
// 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
)
!=
16
{
err
=
fmt
.
Errorf
(
"uuid: UUID must be exactly 16 bytes long, got %d bytes"
,
len
(
data
))
return
}
copy
(
u
[
:
],
data
)
return
}
// 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
)
==
16
{
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
)
}
// 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
}
// 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
}
// 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
}
Godeps/_workspace/src/github.com/satori/go.uuid/uuid_test.go
0 → 100644
View file @
245a981a
// Copyright (C) 2013, 2015 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
TestScanBinary
(
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
.
Scan
(
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
.
Scan
(
b2
)
if
err
==
nil
{
t
.
Errorf
(
"Should return error unmarshalling from empty byte slice, got %s"
,
err
)
}
}
func
TestScanString
(
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"
u1
:=
UUID
{}
err
:=
u1
.
Scan
(
s1
)
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
)
}
s2
:=
""
u2
:=
UUID
{}
err
=
u2
.
Scan
(
s2
)
if
err
==
nil
{
t
.
Errorf
(
"Should return error trying to unmarshal from empty string"
)
}
}
func
TestScanText
(
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
.
Scan
(
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
.
Scan
(
b2
)
if
err
==
nil
{
t
.
Errorf
(
"Should return error trying to unmarshal from empty string"
)
}
}
func
TestScanUnsupported
(
t
*
testing
.
T
)
{
u
:=
UUID
{}
err
:=
u
.
Scan
(
true
)
if
err
==
nil
{
t
.
Errorf
(
"Should return error trying to unmarshal from bool"
)
}
}
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
)
}
}
key.go
View file @
245a981a
...
...
@@ -4,7 +4,7 @@ import (
"path"
"strings"
"github.com/jbenet/go-datastore/Godeps/_workspace/src/
code.google.com/p/go-uuid/
uuid"
"github.com/jbenet/go-datastore/Godeps/_workspace/src/
github.com/satori/go.
uuid"
dsq
"github.com/jbenet/go-datastore/query"
)
...
...
@@ -204,7 +204,7 @@ func (k Key) IsTopLevel() bool {
// RandomKey()
// NewKey("/f98719ea086343f7b71f32ea9d9d521d")
func
RandomKey
()
Key
{
return
NewKey
(
strings
.
Replace
(
uuid
.
New
(),
"-"
,
""
,
-
1
))
return
NewKey
(
strings
.
Replace
(
uuid
.
New
V4
()
.
String
(),
"-"
,
""
,
-
1
))
}
/*
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment