example_test.go

Documentation: encoding/binary

		 1  // Copyright 2011 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package binary_test
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"encoding/binary"
		10  	"fmt"
		11  	"math"
		12  )
		13  
		14  func ExampleWrite() {
		15  	buf := new(bytes.Buffer)
		16  	var pi float64 = math.Pi
		17  	err := binary.Write(buf, binary.LittleEndian, pi)
		18  	if err != nil {
		19  		fmt.Println("binary.Write failed:", err)
		20  	}
		21  	fmt.Printf("% x", buf.Bytes())
		22  	// Output: 18 2d 44 54 fb 21 09 40
		23  }
		24  
		25  func ExampleWrite_multi() {
		26  	buf := new(bytes.Buffer)
		27  	var data = []interface{}{
		28  		uint16(61374),
		29  		int8(-54),
		30  		uint8(254),
		31  	}
		32  	for _, v := range data {
		33  		err := binary.Write(buf, binary.LittleEndian, v)
		34  		if err != nil {
		35  			fmt.Println("binary.Write failed:", err)
		36  		}
		37  	}
		38  	fmt.Printf("%x", buf.Bytes())
		39  	// Output: beefcafe
		40  }
		41  
		42  func ExampleRead() {
		43  	var pi float64
		44  	b := []byte{0x18, 0x2d, 0x44, 0x54, 0xfb, 0x21, 0x09, 0x40}
		45  	buf := bytes.NewReader(b)
		46  	err := binary.Read(buf, binary.LittleEndian, &pi)
		47  	if err != nil {
		48  		fmt.Println("binary.Read failed:", err)
		49  	}
		50  	fmt.Print(pi)
		51  	// Output: 3.141592653589793
		52  }
		53  
		54  func ExampleRead_multi() {
		55  	b := []byte{0x18, 0x2d, 0x44, 0x54, 0xfb, 0x21, 0x09, 0x40, 0xff, 0x01, 0x02, 0x03, 0xbe, 0xef}
		56  	r := bytes.NewReader(b)
		57  
		58  	var data struct {
		59  		PI	 float64
		60  		Uate uint8
		61  		Mine [3]byte
		62  		Too	uint16
		63  	}
		64  
		65  	if err := binary.Read(r, binary.LittleEndian, &data); err != nil {
		66  		fmt.Println("binary.Read failed:", err)
		67  	}
		68  
		69  	fmt.Println(data.PI)
		70  	fmt.Println(data.Uate)
		71  	fmt.Printf("% x\n", data.Mine)
		72  	fmt.Println(data.Too)
		73  	// Output:
		74  	// 3.141592653589793
		75  	// 255
		76  	// 01 02 03
		77  	// 61374
		78  }
		79  
		80  func ExampleByteOrder_put() {
		81  	b := make([]byte, 4)
		82  	binary.LittleEndian.PutUint16(b[0:], 0x03e8)
		83  	binary.LittleEndian.PutUint16(b[2:], 0x07d0)
		84  	fmt.Printf("% x\n", b)
		85  	// Output:
		86  	// e8 03 d0 07
		87  }
		88  
		89  func ExampleByteOrder_get() {
		90  	b := []byte{0xe8, 0x03, 0xd0, 0x07}
		91  	x1 := binary.LittleEndian.Uint16(b[0:])
		92  	x2 := binary.LittleEndian.Uint16(b[2:])
		93  	fmt.Printf("%#04x %#04x\n", x1, x2)
		94  	// Output:
		95  	// 0x03e8 0x07d0
		96  }
		97  
		98  func ExamplePutUvarint() {
		99  	buf := make([]byte, binary.MaxVarintLen64)
	 100  
	 101  	for _, x := range []uint64{1, 2, 127, 128, 255, 256} {
	 102  		n := binary.PutUvarint(buf, x)
	 103  		fmt.Printf("%x\n", buf[:n])
	 104  	}
	 105  	// Output:
	 106  	// 01
	 107  	// 02
	 108  	// 7f
	 109  	// 8001
	 110  	// ff01
	 111  	// 8002
	 112  }
	 113  
	 114  func ExamplePutVarint() {
	 115  	buf := make([]byte, binary.MaxVarintLen64)
	 116  
	 117  	for _, x := range []int64{-65, -64, -2, -1, 0, 1, 2, 63, 64} {
	 118  		n := binary.PutVarint(buf, x)
	 119  		fmt.Printf("%x\n", buf[:n])
	 120  	}
	 121  	// Output:
	 122  	// 8101
	 123  	// 7f
	 124  	// 03
	 125  	// 01
	 126  	// 00
	 127  	// 02
	 128  	// 04
	 129  	// 7e
	 130  	// 8001
	 131  }
	 132  
	 133  func ExampleUvarint() {
	 134  	inputs := [][]byte{
	 135  		{0x01},
	 136  		{0x02},
	 137  		{0x7f},
	 138  		{0x80, 0x01},
	 139  		{0xff, 0x01},
	 140  		{0x80, 0x02},
	 141  	}
	 142  	for _, b := range inputs {
	 143  		x, n := binary.Uvarint(b)
	 144  		if n != len(b) {
	 145  			fmt.Println("Uvarint did not consume all of in")
	 146  		}
	 147  		fmt.Println(x)
	 148  	}
	 149  	// Output:
	 150  	// 1
	 151  	// 2
	 152  	// 127
	 153  	// 128
	 154  	// 255
	 155  	// 256
	 156  }
	 157  
	 158  func ExampleVarint() {
	 159  	inputs := [][]byte{
	 160  		{0x81, 0x01},
	 161  		{0x7f},
	 162  		{0x03},
	 163  		{0x01},
	 164  		{0x00},
	 165  		{0x02},
	 166  		{0x04},
	 167  		{0x7e},
	 168  		{0x80, 0x01},
	 169  	}
	 170  	for _, b := range inputs {
	 171  		x, n := binary.Varint(b)
	 172  		if n != len(b) {
	 173  			fmt.Println("Varint did not consume all of in")
	 174  		}
	 175  		fmt.Println(x)
	 176  	}
	 177  	// Output:
	 178  	// -65
	 179  	// -64
	 180  	// -2
	 181  	// -1
	 182  	// 0
	 183  	// 1
	 184  	// 2
	 185  	// 63
	 186  	// 64
	 187  }
	 188
View as plain text