fix FreeBSD signal handling around thread creation (thanks Devon H. O'Dell),
goroutine profile, stack dumps,
implement runtime.osyield on FreeBSD 386, amd64 (thanks Devon H. O'Dell),
- permit default behaviour of SIGTSTP, SIGTTIN, SIGTTOU,
+ permit default behavior of SIGTSTP, SIGTTIN, SIGTTOU,
release unused memory to the OS (thanks Sébastien Paolacci),
remove an obsolete file (thanks Mikio Hara).
* spec: make all comparison results untyped bool,
* suffixarray: use binary search for both ends of Lookup (thanks Eric Eisner).
* syscall: add missing network interface constants (thanks Mikio Hara).
* template: treat map keys as zero, not non-existent (thanks Roger Peppe).
-* time: allow cancelling of After events (thanks Roger Peppe),
+* time: allow canceling of After events (thanks Roger Peppe),
support Solaris zoneinfo directory.
* token/position: added SetLinesForContent.
* unicode: update to unicode 6.0.0.
* cmath: new complex math library (thanks Charles L. Dorian).
* docs: update to match current coding style (thanks Christopher Wedgwood).
* exp/eval: fix example and add target to Makefile (thanks Evan Shaw).
-* fmt: change behaviour of format verb %b to match %x when negative (thanks Andrei Vieru).
+* fmt: change behavior of format verb %b to match %x when negative (thanks Andrei Vieru).
* gc: compile s == "" as len(s) == 0,
distinguish fatal compiler bug from error+exit,
fix alignment on non-amd64,
func testSlicePanic1() {
defer func() {
if r := recover(); r != nil {
- println("paniced as expected")
+ println("panicked as expected")
}
}()
func testSlicePanic2() {
defer func() {
if r := recover(); r != nil {
- println("paniced as expected")
+ println("panicked as expected")
}
}()
func testStringSlicePanic() {
defer func() {
if r := recover(); r != nil {
- println("paniced as expected")
+ println("panicked as expected")
}
}()
func testInt64IndexPanic() {
defer func() {
if r := recover(); r != nil {
- println("paniced as expected")
+ println("panicked as expected")
}
}()
func testInt64SlicePanic() {
defer func() {
if r := recover(); r != nil {
- println("paniced as expected")
+ println("panicked as expected")
}
}()
}
// dataSortKey is used to sort a slice of data symbol *Symbol pointers.
-// The sort keys are kept inline to improve cache behaviour while sorting.
+// The sort keys are kept inline to improve cache behavior while sorting.
type dataSortKey struct {
size int64
name string
/* type */
t := STB_GLOBAL << 4
- // TODO(mwhudson): presumably the behaviour should actually be the same on both arm and 386.
+ // TODO(mwhudson): presumably the behavior should actually be the same on both arm and 386.
if SysArch.Family == sys.I386 && s.Attr.CgoExport() && s.Type&obj.SMASK == obj.STEXT {
t |= STT_FUNC
} else if SysArch.Family == sys.ARM && s.Attr.CgoExportDynamic() && s.Type&obj.SMASK == obj.STEXT {
* - Mouse zooming (using the wheel)
* - Object dragging
*
- * You can configure the behaviour of the pan/zoom/drag with the variables
+ * You can configure the behavior of the pan/zoom/drag with the variables
* listed in the CONFIGURATION section of this file.
*
* Known issues:
_, cancel := WithCancel(ctx)
checkChildren("with WithCancel child ", ctx, 1)
cancel()
- checkChildren("after cancelling WithCancel child", ctx, 0)
+ checkChildren("after canceling WithCancel child", ctx, 0)
ctx, _ = WithCancel(Background())
checkChildren("after creation", ctx, 0)
_, cancel = WithTimeout(ctx, 60*time.Minute)
checkChildren("with WithTimeout child ", ctx, 1)
cancel()
- checkChildren("after cancelling WithTimeout child", ctx, 0)
+ checkChildren("after canceling WithTimeout child", ctx, 0)
}
func XTestWithCancelCanceledParent(t testingT) {
if subtle.ConstantTimeCompare(expectedTag[:], tag) != 1 {
// The AESNI code decrypts and authenticates concurrently, and
// so overwrites dst in the event of a tag mismatch. That
- // behaviour is mimicked here in order to be consistent across
+ // behavior is mimicked here in order to be consistent across
// platforms.
for i := range out {
out[i] = 0
if subtle.ConstantTimeCompare(expectedTag[:], tag) != 1 {
// The AESNI code decrypts and authenticates concurrently, and
// so overwrites dst in the event of a tag mismatch. That
- // behaviour is mimicked here in order to be consistent across
+ // behavior is mimicked here in order to be consistent across
// platforms.
for i := range out {
out[i] = 0
CurrentTime time.Time // if zero, the current time is used
// KeyUsage specifies which Extended Key Usage values are acceptable.
// An empty list means ExtKeyUsageServerAuth. Key usage is considered a
- // constraint down the chain which mirrors Windows CryptoAPI behaviour,
+ // constraint down the chain which mirrors Windows CryptoAPI behavior,
// but not the spec. To accept any key usage, include ExtKeyUsageAny.
KeyUsages []ExtKeyUsage
}
// WARNING: this doesn't do any revocation checking.
func (c *Certificate) Verify(opts VerifyOptions) (chains [][]*Certificate, err error) {
// Platform-specific verification needs the ASN.1 contents so
- // this makes the behaviour consistent across platforms.
+ // this makes the behavior consistent across platforms.
if len(c.Raw) == 0 {
return nil, errNotParsed
}
// If no default value is given then the zero value for the type is
// assumed to be the default value. This isn't obviously the correct
- // behaviour, but it's what Go has traditionally done.
+ // behavior, but it's what Go has traditionally done.
if params.optional && params.defaultValue == nil {
if reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface()) {
return bytesEncoder(nil), nil
break
}
if time.Since(start) > time.Second {
- t.Fatal("cancelling context did not stop program")
+ t.Fatal("canceling context did not stop program")
}
time.Sleep(time.Millisecond)
}
// The conv and assert functions below do very similar things.
// The convXXX functions are guaranteed by the compiler to succeed.
-// The assertXXX functions may fail (either panicing or returning false,
+// The assertXXX functions may fail (either panicking or returning false,
// depending on whether they are 1-result or 2-result).
// The convXXX functions succeed on a nil input, whereas the assertXXX
// functions fail on a nil input.
freezetheworld()
return
case 1:
- // Something failed while panicing, probably the print of the
+ // Something failed while panicking, probably the print of the
// argument to panic(). Just print a stack trace and exit.
_g_.m.dying = 2
print("panic during panic\n")
// license that can be found in the LICENSE file.
// Test that an interface conversion error panics with an "interface
-// conversion" run-time error. It was (incorrectly) panicing with a
+// conversion" run-time error. It was (incorrectly) panicking with a
// "nil pointer dereference."
package main