math/bits: some regular examples for functions

Change-Id: Iee1b3e116b4dcc4071d6512abc5241eabedaeb5c
Reviewed-on: https://go-review.googlesource.com/53850
Reviewed-by: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/src/math/bits/example_test.go b/src/math/bits/example_test.go
index a43d1f365f60023d69538d5afe8123c20b4dbc02..5c64bb99de17d7b471761325c8dd65b2eeaf3aaf 100644 (file)
--- a/src/math/bits/example_test.go
+++ b/src/math/bits/example_test.go
@@ -9,70 +9,98 @@ import (
        "math/bits"
 )
 
-func ExampleLeadingZeros16() {
-       fmt.Println(bits.LeadingZeros16(0))
-       fmt.Println(bits.LeadingZeros16(1))
-       fmt.Println(bits.LeadingZeros16(256))
-       fmt.Println(bits.LeadingZeros16(65535))
+func ExampleLeadingZeros8() {
+       fmt.Printf("LeadingZeros8(%08b) = %d\n", 1, bits.LeadingZeros8(1))
        // Output:
-       // 16
-       // 15
-       // 7
-       // 0
+       // LeadingZeros8(00000001) = 7
 }
 
-func ExampleLeadingZeros32() {
-       fmt.Println(bits.LeadingZeros32(0))
-       fmt.Println(bits.LeadingZeros32(1))
+func ExampleLeadingZeros16() {
+       fmt.Printf("LeadingZeros16(%016b) = %d\n", 1, bits.LeadingZeros16(1))
        // Output:
-       // 32
-       // 31
+       // LeadingZeros16(0000000000000001) = 15
 }
 
-func ExampleLeadingZeros64() {
-       fmt.Println(bits.LeadingZeros64(0))
-       fmt.Println(bits.LeadingZeros64(1))
+func ExampleLeadingZeros32() {
+       fmt.Printf("LeadingZeros32(%032b) = %d\n", 1, bits.LeadingZeros32(1))
        // Output:
-       // 64
-       // 63
+       // LeadingZeros32(00000000000000000000000000000001) = 31
 }
 
-func ExampleOnesCount() {
-       fmt.Printf("%b\n", 14)
-       fmt.Println(bits.OnesCount(14))
+func ExampleLeadingZeros64() {
+       fmt.Printf("LeadingZeros64(%064b) = %d\n", 1, bits.LeadingZeros64(1))
        // Output:
-       // 1110
-       // 3
+       // LeadingZeros64(0000000000000000000000000000000000000000000000000000000000000001) = 63
 }
 
 func ExampleOnesCount8() {
-       fmt.Printf("%b\n", 14)
-       fmt.Println(bits.OnesCount8(14))
+       fmt.Printf("OnesCount8(%08b) = %d\n", 14, bits.OnesCount8(14))
        // Output:
-       // 1110
-       // 3
+       // OnesCount8(00001110) = 3
 }
 
 func ExampleOnesCount16() {
-       fmt.Printf("%b\n", 14)
-       fmt.Println(bits.OnesCount16(14))
+       fmt.Printf("OnesCount16(%016b) = %d\n", 14, bits.OnesCount16(14))
        // Output:
-       // 1110
-       // 3
+       // OnesCount16(0000000000001110) = 3
 }
 
 func ExampleOnesCount32() {
-       fmt.Printf("%b\n", 14)
-       fmt.Println(bits.OnesCount32(14))
+       fmt.Printf("OnesCount32(%032b) = %d\n", 14, bits.OnesCount32(14))
        // Output:
-       // 1110
-       // 3
+       // OnesCount32(00000000000000000000000000001110) = 3
 }
 
 func ExampleOnesCount64() {
-       fmt.Printf("%b\n", 14)
-       fmt.Println(bits.OnesCount64(14))
+       fmt.Printf("OnesCount64(%064b) = %d\n", 14, bits.OnesCount64(14))
+       // Output:
+       // OnesCount64(0000000000000000000000000000000000000000000000000000000000001110) = 3
+}
+
+func ExampleTrailingZeros8() {
+       fmt.Printf("TrailingZeros8(%08b) = %d\n", 8, bits.TrailingZeros8(8))
+       // Output:
+       // TrailingZeros8(00001000) = 3
+}
+
+func ExampleTrailingZeros16() {
+       fmt.Printf("TrailingZeros16(%016b) = %d\n", 8, bits.TrailingZeros16(8))
+       // Output:
+       // TrailingZeros16(0000000000001000) = 3
+}
+
+func ExampleTrailingZeros32() {
+       fmt.Printf("TrailingZeros32(%032b) = %d\n", 8, bits.TrailingZeros32(8))
+       // Output:
+       // TrailingZeros32(00000000000000000000000000001000) = 3
+}
+
+func ExampleTrailingZeros64() {
+       fmt.Printf("TrailingZeros64(%064b) = %d\n", 8, bits.TrailingZeros64(8))
+       // Output:
+       // TrailingZeros64(0000000000000000000000000000000000000000000000000000000000001000) = 3
+}
+
+func ExampleLen8() {
+       fmt.Printf("Len8(%08b) = %d\n", 8, bits.Len8(8))
+       // Output:
+       // Len8(00001000) = 4
+}
+
+func ExampleLen16() {
+       fmt.Printf("Len16(%016b) = %d\n", 8, bits.Len16(8))
+       // Output:
+       // Len16(0000000000001000) = 4
+}
+
+func ExampleLen32() {
+       fmt.Printf("Len32(%032b) = %d\n", 8, bits.Len32(8))
+       // Output:
+       // Len32(00000000000000000000000000001000) = 4
+}
+
+func ExampleLen64() {
+       fmt.Printf("Len64(%064b) = %d\n", 8, bits.Len64(8))
        // Output:
-       // 1110
-       // 3
+       // Len64(0000000000000000000000000000000000000000000000000000000000001000) = 4
 }