Drop public And/Or ops and race instrumentation
This commit is contained in:
Vorapol Rinsatitnon
@@ -531,472 +531,6 @@ func TestAddUintptrMethod(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndInt32(t *testing.T) {
|
||||
var x struct {
|
||||
before int32
|
||||
i int32
|
||||
after int32
|
||||
}
|
||||
x.before = magic32
|
||||
x.after = magic32
|
||||
x.i = -1
|
||||
j := x.i
|
||||
for mask := int32(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := AndInt32(&x.i, ^mask)
|
||||
j &= ^mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic32 || x.after != magic32 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndInt32Method(t *testing.T) {
|
||||
var x struct {
|
||||
before int32
|
||||
i Int32
|
||||
after int32
|
||||
}
|
||||
x.before = magic32
|
||||
x.after = magic32
|
||||
x.i.Store(-1)
|
||||
j := x.i.Load()
|
||||
for mask := int32(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.And(^mask)
|
||||
j &= ^mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic32 || x.after != magic32 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndUint32(t *testing.T) {
|
||||
var x struct {
|
||||
before uint32
|
||||
i uint32
|
||||
after uint32
|
||||
}
|
||||
x.before = magic32
|
||||
x.after = magic32
|
||||
x.i = 0xffffffff
|
||||
j := x.i
|
||||
for mask := uint32(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := AndUint32(&x.i, ^mask)
|
||||
j &= ^mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic32 || x.after != magic32 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndUint32Method(t *testing.T) {
|
||||
var x struct {
|
||||
before uint32
|
||||
i Uint32
|
||||
after uint32
|
||||
}
|
||||
x.before = magic32
|
||||
x.after = magic32
|
||||
x.i.Store(0xffffffff)
|
||||
j := x.i.Load()
|
||||
for mask := uint32(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.And(^mask)
|
||||
j &= ^mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic32 || x.after != magic32 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndInt64(t *testing.T) {
|
||||
var x struct {
|
||||
before int64
|
||||
i int64
|
||||
after int64
|
||||
}
|
||||
magic64 := int64(magic64)
|
||||
x.before = magic64
|
||||
x.after = magic64
|
||||
x.i = -1
|
||||
j := x.i
|
||||
for mask := int64(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := AndInt64(&x.i, ^mask)
|
||||
j &= ^mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic64 || x.after != magic64 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic64, magic64)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndInt64Method(t *testing.T) {
|
||||
var x struct {
|
||||
before int64
|
||||
i Int64
|
||||
after int64
|
||||
}
|
||||
magic64 := int64(magic64)
|
||||
x.before = magic64
|
||||
x.after = magic64
|
||||
x.i.Store(-1)
|
||||
j := x.i.Load()
|
||||
for mask := int64(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.And(^mask)
|
||||
j &= ^mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic64 || x.after != magic64 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic64, magic64)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndUint64(t *testing.T) {
|
||||
var x struct {
|
||||
before uint64
|
||||
i uint64
|
||||
after uint64
|
||||
}
|
||||
magic64 := uint64(magic64)
|
||||
x.before = magic64
|
||||
x.after = magic64
|
||||
x.i = 0xfffffffffffffff
|
||||
j := x.i
|
||||
for mask := uint64(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := AndUint64(&x.i, ^mask)
|
||||
j &= ^mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic64 || x.after != magic64 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic64, magic64)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndUint64Method(t *testing.T) {
|
||||
var x struct {
|
||||
before uint64
|
||||
i Uint64
|
||||
after uint64
|
||||
}
|
||||
magic64 := uint64(magic64)
|
||||
x.before = magic64
|
||||
x.after = magic64
|
||||
x.i.Store(0xfffffffffffffff)
|
||||
j := x.i.Load()
|
||||
for mask := uint64(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.And(^mask)
|
||||
j &= ^mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic64 || x.after != magic64 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic64, magic64)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndUintptr(t *testing.T) {
|
||||
var x struct {
|
||||
before uintptr
|
||||
i uintptr
|
||||
after uintptr
|
||||
}
|
||||
var m uint64 = magic64
|
||||
magicptr := uintptr(m)
|
||||
x.before = magicptr
|
||||
x.after = magicptr
|
||||
x.i = ^uintptr(0)
|
||||
j := x.i
|
||||
for mask := uintptr(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := AndUintptr(&x.i, ^mask)
|
||||
j &= ^mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magicptr || x.after != magicptr {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAndUintptrMethod(t *testing.T) {
|
||||
var x struct {
|
||||
before uintptr
|
||||
i Uintptr
|
||||
after uintptr
|
||||
}
|
||||
var m uint64 = magic64
|
||||
magicptr := uintptr(m)
|
||||
x.before = magicptr
|
||||
x.after = magicptr
|
||||
x.i.Store(^uintptr(0))
|
||||
j := x.i.Load()
|
||||
for mask := uintptr(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.And(^mask)
|
||||
j &= ^mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magicptr || x.after != magicptr {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrInt32(t *testing.T) {
|
||||
var x struct {
|
||||
before int32
|
||||
i int32
|
||||
after int32
|
||||
}
|
||||
x.before = magic32
|
||||
x.after = magic32
|
||||
var j int32
|
||||
for mask := int32(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := OrInt32(&x.i, mask)
|
||||
j |= mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic32 || x.after != magic32 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrInt32Method(t *testing.T) {
|
||||
var x struct {
|
||||
before int32
|
||||
i Int32
|
||||
after int32
|
||||
}
|
||||
x.before = magic32
|
||||
x.after = magic32
|
||||
var j int32
|
||||
for mask := int32(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.Or(mask)
|
||||
j |= mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic32 || x.after != magic32 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrUint32(t *testing.T) {
|
||||
var x struct {
|
||||
before uint32
|
||||
i uint32
|
||||
after uint32
|
||||
}
|
||||
x.before = magic32
|
||||
x.after = magic32
|
||||
var j uint32
|
||||
for mask := uint32(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := OrUint32(&x.i, mask)
|
||||
j |= mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic32 || x.after != magic32 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrUint32Method(t *testing.T) {
|
||||
var x struct {
|
||||
before uint32
|
||||
i Uint32
|
||||
after uint32
|
||||
}
|
||||
x.before = magic32
|
||||
x.after = magic32
|
||||
var j uint32
|
||||
for mask := uint32(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.Or(mask)
|
||||
j |= mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic32 || x.after != magic32 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic32, magic32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrInt64(t *testing.T) {
|
||||
var x struct {
|
||||
before int64
|
||||
i int64
|
||||
after int64
|
||||
}
|
||||
magic64 := int64(magic64)
|
||||
x.before = magic64
|
||||
x.after = magic64
|
||||
var j int64
|
||||
for mask := int64(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := OrInt64(&x.i, mask)
|
||||
j |= mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic64 || x.after != magic64 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic64, magic64)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrInt64Method(t *testing.T) {
|
||||
var x struct {
|
||||
before int64
|
||||
i Int64
|
||||
after int64
|
||||
}
|
||||
magic64 := int64(magic64)
|
||||
x.before = magic64
|
||||
x.after = magic64
|
||||
var j int64
|
||||
for mask := int64(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.Or(mask)
|
||||
j |= mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic64 || x.after != magic64 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic64, magic64)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrUint64(t *testing.T) {
|
||||
var x struct {
|
||||
before uint64
|
||||
i uint64
|
||||
after uint64
|
||||
}
|
||||
magic64 := uint64(magic64)
|
||||
x.before = magic64
|
||||
x.after = magic64
|
||||
var j uint64
|
||||
for mask := uint64(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := OrUint64(&x.i, mask)
|
||||
j |= mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic64 || x.after != magic64 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic64, magic64)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrUint64Method(t *testing.T) {
|
||||
var x struct {
|
||||
before uint64
|
||||
i Uint64
|
||||
after uint64
|
||||
}
|
||||
magic64 := uint64(magic64)
|
||||
x.before = magic64
|
||||
x.after = magic64
|
||||
var j uint64
|
||||
for mask := uint64(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.Or(mask)
|
||||
j |= mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magic64 || x.after != magic64 {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magic64, magic64)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrUintptr(t *testing.T) {
|
||||
var x struct {
|
||||
before uintptr
|
||||
i uintptr
|
||||
after uintptr
|
||||
}
|
||||
var m uint64 = magic64
|
||||
magicptr := uintptr(m)
|
||||
x.before = magicptr
|
||||
x.after = magicptr
|
||||
var j uintptr
|
||||
for mask := uintptr(1); mask != 0; mask <<= 1 {
|
||||
old := x.i
|
||||
k := OrUintptr(&x.i, mask)
|
||||
j |= mask
|
||||
if x.i != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i, j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magicptr || x.after != magicptr {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOrUintptrMethod(t *testing.T) {
|
||||
var x struct {
|
||||
before uintptr
|
||||
i Uintptr
|
||||
after uintptr
|
||||
}
|
||||
var m uint64 = magic64
|
||||
magicptr := uintptr(m)
|
||||
x.before = magicptr
|
||||
x.after = magicptr
|
||||
var j uintptr
|
||||
for mask := uintptr(1); mask != 0; mask <<= 1 {
|
||||
old := x.i.Load()
|
||||
k := x.i.Or(mask)
|
||||
j |= mask
|
||||
if x.i.Load() != j || k != old {
|
||||
t.Fatalf("mask=%d i=%d j=%d k=%d old=%d", mask, x.i.Load(), j, k, old)
|
||||
}
|
||||
}
|
||||
if x.before != magicptr || x.after != magicptr {
|
||||
t.Fatalf("wrong magic: %#x _ %#x != %#x _ %#x", x.before, x.after, magicptr, magicptr)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCompareAndSwapInt32(t *testing.T) {
|
||||
var x struct {
|
||||
before int32
|
||||
|
||||
Reference in New Issue
Block a user