<- channel operator, 344–345

%d verb, 63–66

%f verb, 66–67

//go:embed directive, 518, 521–522

escape sequence, 61–62

[N] syntax, 71–72

%q verb, 63

%s verb, 63

escape sequence, 61–62

%T verb, 67

~(tilde) constraint operator, 325–326

%v verb, 67–69

%#v verb, 69–70

%+v verb, 169, 185

%w verb, 294, 301

abbreviations in package names, 6

accessing struct fields, 172–173

adding goroutines to waitgroups

• negative number of, 425–426

• positive number of, 423–424

• zero number of, 424–425

aliases, resolving name conflicts, 16, 56–57

All method, 208–209

anonymous functions, 150, 159–160

any keyword, 242–243

APIs, scope, 10

append function, 85–90, 97

appending

• to files, 500–503

• to slices, 85–90, 97

architecture-independent numeric types, 31

arguments, 141–142

• accepting from other functions, 151

• functions as, 148–149

• return arguments, 143–144

  • capturing panic values, 269–273

  • error handling, 262–263

  • multiple, 144–145

  • named returns, 145–147

• of same type, 142–143

• variadic arguments, 151–152

• passing slices with, 153–154

• position of, 152–153

• when to use, 154–156

arrays

• avoiding out-of-bounds errors, 287–289

• converting to slices, 102–104

• creating, 79

• data types in, 82–83

• indexing, 81–82

• initializing, 79–80

• iteration over, 105

• purpose of, 77

• setting values of, 85

• slices versus, 77–79

• subsets of, 103–104

• type definitions, 83–84

• zero values, 81

AsError interface, 303–304

asserting

• interface implementation, 241–242

• with type assertions, 250–251

  • avoiding panics, 284–287

  • concrete type verification, 252

  • generics and, 329–331

  • with switch statement, 252–254

  • usage example, 255–257

  • validating, 251–252

assigning

• functions to variables, 283–284

• multiple values to variables, 45–46

• variables, 41–42

binaries, embedding files in, 520–521

bitwise operators, 135

blocking channels, 343–344

boolean logic

• boolean operators, 134

• comparison operators, 135

• equality comparison, 129–130

break keyword, 107–108

buffered channels, 358–359

• message delivery and, 360–362

• reading closed, 362–363

• usage example, 359–360

byte numeric type, 31

callback interfaces, defining, 255–256

calling

• functions without interfaces, 235–237

• generics, 316–317

• methods, 177

cancellation deadlines on contexts, 374

cancellation events

• on contexts, 396

  • canceling contexts, 398–400

  • creating cancelable contexts, 397–398

  • deadlines, 405–406

  • errors on, 409–410

  • listening for, 375–376

  • listening for confirmation, 400–405

  • timeouts, 407–408

• on error groups, listening for, 439–440

cap function, 92, 96–97, 112–113

capacity

• of maps, 112–113

• of slices, 91–92, 96–97

capitalization for exporting variables, 57

capturing

• panic values, 269–273

• system signals, 363

  • implementing graceful shutdown, 365–367

  • listening for shutdown confirmation, 368–370

  • listening for system signals, 367–368

  • os/signals package, 363–365

  • timing out nonresponsive shutdown, 370–371

casting values, 45

chan keyword, 343

channels

• blocking/unblocking, 343–344

• buffered, 358–359

  • message delivery and, 360–362

  • reading closed, 362–363

  • usage example, 359–360

• capturing system signals, 363

  • implementing graceful shutdown, 365–367

  • listening for shutdown confirmation, 368–370

  • listening for system signals, 367–368

  • os/signals package, 363–365

  • timing out nonresponsive shutdown, 370–371

• characteristics of, 343

• closing, 352–354

  • closing already-closed, 357

  • reading buffered, 362–363

  • reading closed, 354–357

  • with sync.Once type, 463–466

  • writing closed, 358

• creating, 343–344

• listening with select statements, 348–349

• message queues versus, 349–351

• range loops and, 348

• sending/receiving values, 344–345

• unidirectional, 351–352

• usage example, 345–347

choosing numeric types, 32

cleaning up test helpers, 227–229

closing channels, 352–354

• closing already-closed, 357

• reading buffered, 362–363

• reading closed, 354–357

• with sync.Once type, 463–466

• writing closed, 358

closures, 149–150

code coverage

• coverage profiles, 203–204

• editor support for, 206

• go test command, 202–203

• go tool cover command, 204–205

• HTML coverage reports, 205–206

comparison operators, 135

compiled languages, 28–30

complex values in maps, 123–124

• updating, 125–126

complex64 numeric type, 31

complex128 numeric type, 31

concrete types

• compilation errors for type assertions, 330–331

• interfaces versus, 231–233

• verifying via type assertions, 252

concurrency. See also synchronization

• channels

  • blocking/unblocking, 343–344

  • buffered, 358–359

  • buffered message delivery, 360–362

  • buffered usage example, 359–360

  • capturing system signals, 363

  • characteristics of, 343

  • closing, 352–354

  • closing already-closed, 357

  • creating, 343–344

  • implementing graceful shutdown, 365–367

  • listening for shutdown confirmation, 368–370

  • listening for system signals, 367–368

  • listening with select statements, 348–349

  • message queues versus, 349–351

  • os/signals package, 363–365

  • range loops and, 348

  • reading closed, 354–357

  • reading closed buffered, 362–363

  • sending/receiving values, 344–345

  • timing out nonresponsive shutdown, 370–371

  • unidirectional, 351–352

  • usage example, 345–347

  • writing closed, 358

contexts

• cancellation events, 375–376, 396–410

• deadlines on, 374

• default implementation, 379–380

• error messages, 376, 408–411

• exporting keys, 393–394

• key security, 394–396

• listening for system signals, 411–413

• nodal hierarchy, 381–387

• retrieving values, 376–378

• rules for, 380–381

• string keys, 388–393

• testing system signals, 413–416

• wrapping with values, 382, 384–386

• dog feeding metaphor, 336–338

• goroutines, 338

  • memory management, 339

  • runtime.GOMAXPROCS function, 341–342

  • scheduling, 339–342

  • usage example, 342

  • work sharing, 339–340

  • work stealing, 341

• parallelism versus, 335–336

concurrent monitors, starting, 401–402

const keyword, 48

constants, 48–51

• declaring, 48

• modifying, 48

• typed, 49

• untyped, 50–51

constraints. See type constraints

constraints package, 326–328

constraints.Integer constraint, 327

constraints.Ordered constraint, 327–328

constraints.Signed constraint, 327

context package, 373, 378. See also contexts

context.Background function, 378–380

context.Canceled error, 409–410

context.CancelFunc function, 397–398, 402–403

context.Context interface, 374, 379–380

context.Context.Deadline method, 374

context.Context.Done method, 375–376, 398–399

context.Context.Err method, 376, 408–409

context.Context.Value method, 376–378, 386–387

context.DeadlineExceeded error, 410–411

contexts

• cancellation events, 396

  • canceling contexts, 398–400

  • creating cancelable contexts, 397–398

  • deadlines, 405–406

  • errors on, 409–410

  • listening for, 375–376

  • listening for confirmation, 400–405

  • timeouts, 407–408

• deadlines on, 374

• default implementation, 379–380

• error messages

  • context.Canceled error, 409–410

  • context.Context.Err method, 376, 408–409

  • context.DeadlineExceeded error, 410–411

• exporting keys, 393–394

• key security, 394–396

• listening for system signals, 411–413

• nodal hierarchy, 381

  • context.WithValue function, 382, 384–386

  • key resolution, 386–387

  • usage example, 382–384

• retrieving values, 376–378

• rules for, 380–381

• string keys, 388

  • custom types, 390–393

  • key collisions, 388–390

• testing system signals, 413–416

• wrapping with values, 382, 384–386

context.WithCancel function, 397

context.WithDeadline function, 405–406

context.WithTimeout function, 407–408

context.WithValue function, 382, 384–386

continue keyword, 107–108

control structures

• if statements

  • else if statements, 131–132

  • else statements, 130–131

  • explained, 129–130

  • variable scope, 132–134

• logic and math operators, 134–135

• switch statements, 135–138

  • default blocks, 138–139

  • fallthrough keyword, 139–140

converting

• arrays to slices, 102–104

• strings to/from numbers, 72–75

copy function, 101–102

copying

• map values on insert, 124–125

• slices, 101–102

coverage profiles, 203–204

custom data types, 167–168

custom errors

• defining, 291–293

• error interface, 289

• standard errors versus, 289–291

• unwrapping, 298–301

custom string key types, 390–393

cyclical imports, 24–25

data races

• detecting in tests, 447–449

• -race flag, 445–447

• shared access example, 443–445

data types

• in arrays, 82–83

• concrete types versus interfaces, 231–233

• constants, 49–51

• declaring new, 167–168

• in function arguments, 141–143

• functions as, 147, 180–181

• generics, 332–334

• inheritance, 181–182

• numeric, 31–35

• architecture-independent, 31

• choosing, 32

• implementation-specific, 31

• overflow versus wraparound, 32–34

• saturation, 34–35

in slices, 82–83

static versus dynamic typing, 27–28

string literals, 35–37

• interpreted, 35

• quotation marks for, 35

• raw, 36–37

third-party, methods on, 178–179

UTF-8 characters, 37–40

• iterating over, 38–40

• runes, 38

deadlines on contexts, 374, 405–406, 410–411

debug.PrintStack function, 307

debug.Stack function, 307

declaring. See also defining

• constants, 48

• data types, 167–168

• methods, 176

• slices, 95–96

• variables, 40, 44–45

decrementing integers, 122

default blocks, 138–139

default implementations of contexts, 379–380

defer keyword, 156, 229, 266

deferring function calls, 156

• anonymous functions, 159–160

• exit and fatal messages, 158–159

• with multiple returns, 156–157

• order of execution, 157

• panics and, 158

• scope, 160–162

• testing.TB.Cleanup method versus, 229

defining. See also declaring

• callback interfaces, 255–256

• custom errors, 291–293

• interfaces, 243–247

• structs, 168–169

• test helpers, 222–226

• type constraints, 321–322

delete function, 118–119

deleting map keys, 118–119

dependencies, 16–22

• go.sum file, 20–21

• requiring, 18–20

• updating, 21–22

• usage, 17–18

directories. See also files

• creating, 481–483, 499–500

• creating multiple, 489–492

• creating structure with file path helpers, 486–487

• errors with file path helpers, 488–489

• fixing walk tests, 497–500

• names, retrieving, 486

• reading, 468–470

• skipping, 477–481

• special, 467–468

• for specific files, retrieving, 485

• walking, 473–477, 510–513

• Windows filepaths, 505–506

disabling test caching, 221

discarding variables, 47

do while loops, 108–109

dog feeding metaphor (concurrency), 336–338

dynamic typing, 27–28

else if statements, 131–132

else statements, 130–131

embed package, 517

embedding

• files, 517

  • in binaries, 520–521

  • modifying, 521–522

  • as strings/byte slices, 522

  • usage example, 518–519

• interfaces, 249–250

embed.FS type, 518–519

empty interfaces, 242–243

encoding with struct tags, 173–176

equality comparison, 129–130

errgroup.Group type, 436, 440–442

errgroup.Group.Go method, 437

errgroup.Group.Wait method, 437–439

errgroup.WithContext function, 439–440

error groups

• errgroup.Group type, 436, 440–442

• errgroup.Group.Go method, 437

• errgroup.Group.Wait method, 437–439

• errgroup.WithContext function, 439–440

• golang.org/x/sync/errgroup package, 434

• problem solved by, 434–436

error interface, 261, 289

errors. See also testing

• arrays versus slices, 103

• in compilation, 18, 29–30, 34

• context error messages

  • context.Canceled error, 409–410

  • context.Context.Err method, 376, 408–409

  • context.DeadlineExceeded error, 410–411

• custom

  • defining, 291–293

  • error interface, 289

  • standard errors versus, 289–291

  • unwrapping, 298–301

• errors.As function, 302–304

• errors.Is function, 304–306

• with file path helpers, 488–489

• with formatting verbs, 70–71

• nil receivers, 192–193

• out of bounds, 81–82

• panics

  • assigning functions to variables, 283–284

  • avoiding, 273

  • capturing and returning values, 269–273

  • checking for nil receivers, 274–275

  • checking type assertions, 284–287

  • initializing interfaces, 280–283

  • initializing maps, 275–278

  • initializing pointers, 278–280

  • log.Fatal function, 273

  • from out-of-bounds errors, 264–265, 287–289

  • raising, 265

  • recovering from, 265–269

• returning, 144

• stack traces, 307–308

• types of, 296

• unwrapping, 297–301

• as values, 259–261

  • error interface, 261

  • errors.New function, 261

  • fmt.Errorf method, 262

  • handling, 262–263

  • usage example, 263–264

• in walk tests, fixing, 497–500

• wrapping, 294–297

errors.As function, 302–304

errors.Is function, 304–306, 489

errors.New function, 261

errors.Unwrap function, 297–301

escape characters

• escaping, 62–63

• for formatting strings, 61–62

• in raw string literals, 36

exceptions, 259–260

exits, deferred function calls and, 158–159

expanding slices with variadic operator, 153–154

explicit argument indexes, 71–72

explicit implementation of interfaces, 233–234

exporting

• context keys, 393–394

• variables, 57

extensions, retrieving, 485

failing fast when testing, 220–221

fallthrough keyword, 139–140

fatal message, deferred function calls and, 158–159

file systems

• fs package, 506–507

  • fs.File interface, 509

  • fs.FS interface, 508, 510–513

• mocking, 513–517

file tree, example of, 467–468

filepath package, 484

filepath.Base function, 486

filepath.Dir function, 485, 486–487

filepath.Ext function, 485, 486–487

filepath.Join function, 505–506

filepath.WalkDir function, 473–474, 475–477

files. See also directories

• appending to, 500–503

• creating, 492–495, 499–500

• directory of, retrieving, 485

• embedding, 517

  • in binaries, 520–521

  • modifying, 521–522

  • as strings/byte slices, 522

  • usage example, 518–519

• errors with file path helpers, 488–489

• extensions, retrieving, 485

• fixing walk tests, 497–500

• metadata on, 471–473

• names, retrieving, 486

• naming, 9

• reading, 494–495, 503–505

• skipping, 477

• truncating, 495–497

• Windows filepaths, 505–506

first-class functions, 147

float32 numeric type, 31–32

float64 numeric type, 31–32

floats, formatting with formatting verbs, 66–67

fmt package, functions in, 57–58

• errors with formatting verbs, 70–71

• escape characters, 61–63

• explicit argument indexes, 71–72

• float formatting verbs, 66–67

• formatting verbs, 61

• Fprint functions, 59

• integer formatting verbs, 63–66

• multiple Println arguments, 61

• new lines, 60

• Print functions, 59

• Sprint functions, 58–59

• string formatting verbs, 63

• value Go-syntax printing, 69–70

• value printing, 67–69

• value type printing, 67

fmt.Errorf method, 262, 294, 301

fmt.Stringer interface, 241

folders, package folder structure, 4, 6–13. See also directories

• multiple packages, 7–9

• naming files, 9

• organization, 9–13

for loops

• appending to slices, 88–89

• break keyword, 107–108

• continue keyword, 107–108

• explained, 104–105

• iteration over arrays and slices, 105

• range keyword, 105–106

formatting

• floats with formatting verbs, 66–67

• integers with formatting verbs, 63–66

• strings

  • errors with formatting verbs, 70–71

  • escape characters, 61–63

  • explicit argument indexes, 71–72

  • with formatting verbs, 61, 63

  • list of functions, 57–58

  • Sprint functions, 58–59

• verbs for, 61

  • errors with, 70–71

  • escape characters, 61–63

  • explicit argument indexes, 71–72

  • floats, 66–67

  • integers, 63–66

  • strings, 63

  • value type printing, 67

Fprint functions, 59

fs package, 506–507

fs.DirEntry type, 469–470

fs.ErrExit error, 489

fs.File interface, 509

fs.FileInfo interface, 471–472

fs.FS interface, 508, 510–513

fs.SkipDir error, 478–479

fstest.MapFile type, 509, 515

fstest.MapFS type, 514, 515–517

fs.WalkDir function, 510–512

fs.WalkDirFunc function, 474–475

functions. See also interfaces

• anonymous, 150

• arguments, 141–142

  • accepting from other functions, 151

  • capturing panic values, 269–273

  • error handling, 262–263

  • functions as, 148–149

  • multiple return arguments, 144–145

  • named returns, 145–147

  • passing slices with, 153–154

  • position of variadic arguments, 152–153

  • return arguments, 143–144

  • of same type, 142–143

  • variadic arguments, 151–152

  • when to use variadic arguments, 154–156

• assigning to variables, 283–284

• calling without interfaces, 235–237

• closures, 149–150

• as data types, 180–181

• deferring calls, 156

  • anonymous functions, 159–160

  • exit and fatal messages, 158–159

  • with multiple returns, 156–157

  • order of execution, 157

  • panics and, 158

  • scope, 160–162

  • testing.TB.Cleanup method versus, 229

• definitions, 141

• as first class, 147

• in fmt package, 57–58

  • errors with formatting verbs, 70–71

  • escape characters, 61–63

  • explicit argument indexes, 71–72

  • float formatting verbs, 66–67

  • formatting verbs, 61

  • Fprint functions, 59

  • integer formatting verbs, 63–66

  • multiple Println arguments, 61

  • new lines, 60

  • Print functions, 59

  • Sprint functions, 58–59

  • string formatting verbs, 63

  • value Go-syntax printing, 69–70

  • value printing, 67–69

  • value type printing, 67

• generics, 311

  • calling, 316–317

  • constraints package, 326–328

  • defining constraints, 321–322

  • instantiating, 320–321

  • mixing type and method constraints, 331

  • multiple type constraints, 322–323

  • multiple types, 317–320

  • type assertions, 329–331

  • type constraints, 315–317

  • underlying type constraints, 324–326

• init, 162–163

  • multiple, 163–164

  • order of execution, 164

  • for side effects, 164–166

• methods on, 181

• methods versus, 177

• new, 189–190

• in strconv package, 72–75

• test function signatures, 196

• test helpers, 222

  • cleaning up, 227–229

  • defining, 222–226

  • marking functions as, 226–227

• as variables, 147–148

garbage collection, 28

generic functions, 311

• calling, 316–317

• constraints package, 326–328

• defining constraints, 321–322

• instantiating, 320–321

• mixing type and method constraints, 331

• multiple type constraints, 322–323

• multiple types, 317–320

• type assertions, 329–331

• type constraints, 315–317

• underlying type constraints, 324–326

generic package names, avoiding, 6

generic types, 332–334

getting pointers, 185–186

go build command, 29

go get command, 4, 18–20

go get -u command, 21–22

go help mod command, 2

go help test command, 477

go mod command, 2

go mod init command, 3

go test command, 202–203

go tool cover command, 204–205

go vet command, 71

golang.org/x/exp/constraints package, 326–328

golang.org/x/sync/errgroup package, 434

go.mod file, 2

goroutines, 338. See also channels; contexts; synchronization

• memory management, 339

• messages and, 350–351

• runtime.GOMAXPROCS function, 341–342

• scheduling, 339–342

• usage example, 342

• work sharing, 339–340

• work stealing, 341

go.sum file, 20–21

Go-syntax of value, printing, 69–70

graceful shutdown

• implementing, 365–367

• listening for shutdown confirmation, 368–370

• listening for system signals, 367–368

• rules for, 363

• timing out nonresponsive shutdown, 370–371

growing slices, 92–94, 97–99

handling errors, 262–263

heap, 183

helper functions

• in context package, 378

• test helpers, 222

  • cleaning up, 227–229

  • defining, 222–226

  • marking functions as, 226–227

• .hidden directory, 467–468

• HTML coverage reports, 205–206

• http.HandlerFunc type, 181

identifiers. See constants; variables

if statements, 129–130

• else if statements, 131–132

• else statements, 130–131

• variable scope, 132–134

_ignore directory, 467–468

implementation-specific numeric types, 31

implicit implementation of interfaces, 234–235

import aliases, 16

import keyword, 14

importing

• modules, 13–16, 22

• packages, 13–16

  • cyclical imports, 24–25

  • multiple versions, 23–24

  • for side effects, 164–166

incrementing integers, 122

indexing

• arrays, 81–82

• avoiding out-of-bounds errors, 287–289

• slices, 81–82

inferred typing, 50–51

inheritance, 181–182

init functions, 162–163

• multiple, 163–164

• order of execution, 164

• for side effects, 164–166

initializing

• arrays, 79–80

• interfaces, 280–283

• maps, 113, 275–278

• modules, 3

• packages. See init functions

• pointers, 278–280

• slices, 79–80

• structs, 169–172

• variables, 44–45

instantiating generics, 320–321

int numeric type, 31–32

int8 numeric type, 31

int16 numeric type, 31

int32 numeric type, 31

int64 numeric type, 31

integers

• formatting with formatting verbs, 63–66

• incrementing/decrementing, 122

• padding, 64–66

interfaces

• AsError interface, 303–304

• asserting implementation, 241–242

• callback, 255–256

• calling functions without, 235–237

• concrete types versus, 231–233

• context.Context interface, 374

• defining, 243–247

• drawbacks of, 311–315

• embedding, 249–250

• empty, 242–243

• error interface, 261, 289

• explicit implementation, 233–234

• implementing, 247–249

• implicit implementation, 234–235

• initializing, 280–283

• io.Writer interface, 237–240

• IsError interface, 305–306

• multiple, 241

• type assertions, 250–251

  • concrete type verification, 252

  • with switch statement, 252–254

  • usage example, 255–257

  • validating, 251–252

• Unwrapper interface, 299

• usage example, 237–239

• validatable, 250

interpreted languages, 28–29

interpreted string literals, 35

io.Reader interface, 503–505

io.ReadWriteCloser interface, 249–250

io.Writer interface, 237–240, 503–505

IsError interface, 305–306

iterating over UTF-8 characters, 38–40

iteration

• of arrays and slices, 105

• do while loops, 108–109

• for loops

  • appending to slices, 88–89

  • break keyword, 107–108

  • continue keyword, 107–108

  • explained, 104–105

  • range keyword, 105–106

• of maps, 116–118

JSON encoding with struct tags, 173–176

keys

• in contexts

  • collisions, 388–390

  • custom string key types, 390–393

  • exporting, 393–394

  • resolving, 386–387

  • security, 394–396

  • string keys, 388

• in maps, 114–116

  • deleting, 118–119

  • interface drawbacks, 311–315

  • listing, 126–127

  • nonexistent, 120–121

  • sorting, 127–129

  • testing presence of, 122–123

keywords, list of, 30

len function, 91, 96–97, 112

length

• of maps, 112–113

• of slices, 91–92, 96–97

listener function, 353

listening

• for cancellation events on contexts, 375–376

• to channels

  • with select statements, 348–349

  • for shutdown confirmation, 368–370

  • for system signals, 367–368

  • for context cancellation confirmation, 400–405

  • for error group cancellation, 439–440

  • for system signals with contexts, 411–413

• listing map keys, 126–127

• listings

  • accessing struct fields, 172–173

  • adding negative number of goroutines to waitgroups, 425–426

  • adding positive number of goroutines to waitgroups, 423–424

  • adding zero number of goroutines to waitgroups, 424–425

  • a.go file, 8

  • All method, 208–209

  • anonymous functions, 150

  • any keyword, 242–243

  • appending to files, 501–503

  • appending to slices, 86–90

  • array of four strings, 78

  • AsError interface, 303–304

  • asserting interface implementation, 242

  • assigning functions to variables, 283–284

  • assigning multiple values, 45–46

  • assigning variables, 41–42

  • bad folder files listing, 8

  • bad identifier names, 52

  • bad package build, 9

  • bad.go file, 10–11

  • bar/bar.go file, 15

  • bar.go file, 24–25

  • b.go file, 8

  • blocking/unblocking channels, 345

  • boolean equality comparison, 129–130

  • break keyword, 107–108

  • buffered channel message delivery, 361–362

  • buffered channel usage example, 359–360

  • calling functions without interfaces, 235–237

  • calling generics, 316–317

  • calling methods, 177

  • cap function, 92, 112–113

  • capturing and returning panic values, 269–273

  • casting values, 45

  • channel usage example, 345–347

  • checking for nil receivers, 193, 274–275

  • checking type assertions, 285–287

  • closing already-closed channels, 357

  • closing channels, 353–354, 463–466

  • closures, 149–150

  • code coverage, 203

  • compilation errors, 18, 29–30, 34

  • complex if/else if statements, 135–136

  • complex values in maps, 123–124

  • concrete types versus interfaces, 231–233

  • constraints.Integer constraint, 327

  • constraints.Ordered constraint, 328

  • constraints.Signed constraint, 327

  • context key collisions, 389–390

  • context key security, 394–396

  • context package, 373, 378

  • context.Background function, 378–380

  • context.Canceled error, 409–410

  • context.CancelFunc function, 397–398, 402–403

  • context.Context interface, 374

  • context.Context.Deadline method, 374

  • context.Context.Done method, 375–376, 398–399

  • context.Context.Err method, 376, 408–409

  • context.Context.Value method, 376–378

  • context.DeadlineExceeded error, 410–411

  • context.WithCancel function, 397

  • context.WithDeadline function, 405–406

  • context.WithTimeout function, 407–408

  • context.WithValue function, 385–386

  • continue keyword, 107–108

  • converting arrays to slices, 102–104

  • converting strings to/from numbers, 74–75

  • copying map values on insert, 124–125

  • copying slices, 101–102

  • coverage profiles, 203–204

  • coverage profiles on per-function basis, 207

  • crafting failure messages, 201–202

  • creating arrays versus slices, 79

  • creating directory structure, 486–487

  • creating files/directories, 499–500

  • custom data type usage, 168

  • custom string key types, 391–393

  • cyclical imports, 24–25

  • data types in arrays and slices, 83

  • debug.PrintStack function, 307

  • debug.Stack function, 307

  • declaring constants, 48

  • declaring methods, 176

  • declaring new data types, 167

  • declaring slices, 95–96

  • declaring variables, 40

  • default blocks in switch statements, 138–139

  • deferred function calls and exit/fatal message, 159

  • deferred function calls and panics, 158

  • deferring anonymous functions, 159–160

  • deferring function calls, 156

  • deferring function calls with multiple returns, 156–157

  • defining custom errors, 292–293

  • defining interfaces, 243–247

  • defining structs, 169

  • defining test helpers, 223–226

  • defining type constraints, 321–322

  • delete function, 118

  • deleting map keys, 118–119

  • demo module files listing, 15

  • detecting race conditions in tests, 447–449

  • disabling test caching, 221

  • discarding variables, 47

  • do while loops, 109

  • else if statements, 132

  • else statements, 130–131

  • embed package, 517

  • embedding files as strings/byte slices, 522

  • embedding files in binaries, 520–521

  • embed.FS type, 518–519

  • empty interface, 242, 243

  • encoding with struct tags, 173–175

  • errgroup.Group type, 436, 441–442

  • errgroup.Group.Go method, 437

  • errgroup.Group.Wait method, 437–439

  • errgroup.WithContext function, 439–440

  • error interface, 261, 289

  • error types, 296

  • error usage example, 263–264

  • errors as values, 260–261

  • errors with file path helpers, 488–489

  • errors with formatting verbs, 70

  • errors.As function, 302–303

  • errors.Is function, 305, 489

  • errors.New function, 261

  • errors.Unwrap function, 297–301

  • escape characters and , 62

  • escaping escape characters, 62–63

  • exceptions, 259–260

  • expanding slices with variadic operator, 154

  • explicit argument indexes, 71–72

  • explicit implementation of interfaces, 233–234

  • exporting context keys, 393–394

  • exporting variables, 57

  • external dependencies file structure, 20

  • failing fast when testing, 221

  • fallthrough keyword, 139–140

  • file tree example, 467–468

  • filepath package, 484

  • filepath.Base function, 486

  • filepath.Dir function, 485

  • filepath.Ext function, 485

  • filepath.Join function, 505–506

  • filepath.WalkDir function, 473–474, 475–477

  • fixing walk tests, 497–500

  • flect.Dasherize function, 17

  • float formatting verbs, 66

  • fmt package, 58

  • fmt.Errorf method, 262

  • fmt.Fprint function, 59

  • fmt.Print function, 59

  • fmt.Println function, 60

  • fmt.Sprint function, 58–59

  • fmt.Stringer interface, 241

  • foo type, 25

  • foo/bar/bar.go file, 15

  • foo.go file, 13

  • for loops, 105

  • fs package, 507

  • fs.DirEntry type, 469–470

  • fs.File interface, 509

  • fs.FileInfo interface, 471–472

  • fs.FS interface, 508

  • fs.SkipDir error, 478–479

  • fstest.MapFile type, 509, 515

  • fstest.MapFS type, 514, 515–517

  • fs.WalkDir function, 510–512

  • fs.WalkDirFunc function, 474–475

  • function arguments, 142–143

  • function definitions, 141

  • function types, 180–181

  • functions accepting other function arguments, 151

  • functions as arguments, 148–149

  • functions as variables, 147–148

  • generic types, 332–334

  • generics, 316

  • getting pointers, 185–186

  • //go:embed directive, 518, 521–522

  • go get command, 4, 18–19

  • go help test command, 477

  • go mod command, 2

  • go mod init command, 3

  • Go module files listing, 1

  • go tool cover command, 204–205

  • go vet command, 71

  • golang.org/x/exp/constraints package, 326

  • golang.org/x/sync/errgroup package, 434

  • go.mod file, 2, 18

  • go.mod file updates, 20

  • good folder files listing, 7–8, 11–12

  • goroutine usage example, 342

  • goroutines, 338

  • go.sum file, 21

  • growing slices, 92–94

  • handling errors, 263

  • HTML coverage reports, 205–206

  • http.HandlerFunc type, 181

  • if statements, 130

  • implementing graceful shutdown, 365–367

  • implementing interfaces, 247–249

  • implicit implementation of interfaces, 234–235

  • importing modules with semantic versioning, 22

  • importing multiple packages, 14, 23–24

  • improper mutex usage, 456–459

  • indexing arrays and slices, 81–82

  • inferred typing, 50–51

  • inheritance, 182

  • init function, 162–163

  • init functions for side effects, 165–166

  • initializing arrays and slices, 80

  • initializing interfaces, 280–283

  • initializing maps, 113, 276–278

  • initializing pointers, 278–280

  • initializing structs, 169–172

  • initializing variables, 44

  • instantiating generics, 320–321

  • integer formatting verbs, 64

  • interface usage example, 238–239

  • interpreted string literals, 35

  • io.ReadWriteCloser interface, 249–250

  • io.Writer interface, 237, 239–240

  • IsError interface, 305–306

  • iterating over maps, 116–118

  • iterating over UTF-8 characters, 39–40

  • key resolution in contexts, 386–387

  • len function, 91, 112

  • listener function, 353

  • listening for shutdown confirmation, 368–370

  • listening for system signals, 367–368, 412–413

  • listing map keys, 126–127

  • log.Fatal function, 273

  • logging in tests, 215

  • main.go file, 14, 17

  • make function, 95, 113, 344

  • make function with append function, 97

  • make function with length and capacity, 96–97

  • managing goroutines with sync.WaitGroup, 434–436

  • map keys, 114–115, 311–315

  • messages and goroutines, 350–351

  • method receivers, 188–189

  • methods on third-party types, 178–179

  • mixing type and method constraints, 331

  • modifying constants, 48

  • modifying variables, 48–49

  • multiple generic types, 317–319

  • multiple goroutines for one task, 419–420

  • multiple init functions, 163–164

  • multiple interfaces, 241

  • multiple Println arguments, 61

  • multiple return arguments, 144–145

  • multiple type constraints, 322–323

  • mutating subsets of slices, 100

  • name conflicts between variables and packages, 54–55

  • name conflicts when importing packages, 15–16

  • named returns, 146–147

  • names folder files listing, 13

  • naming files, 9

  • naming packages, 5–6

  • naming variables, 53

  • new function, 189–190

  • new lines, 60

  • nil receivers, 191–192

  • nodal hierarchy for contexts, 381–384

  • nonexistent map keys, 120–121

  • order of execution for deferred function calls, 157

  • order of execution for init functions, 164

  • os.Create function, 492–494, 495–496

  • os.DirEntry type, 468

  • os.DirFS function, 512

  • os.FileMode type, 482

  • os.Interrupt type, 365

  • os.Mkdir function, 481–483

  • os.MkdirAll function, 490–492

  • os.OpenFile function, 501

  • os.ReadDir function, 468, 470

  • os.ReadFile function, 494–495

  • os.Signal type, 364

  • os.Stat function, 472–473

  • overflow example, 33–34

  • package folder structure, 4, 6–7

  • padding integers, 64–66

  • panic from out-of-bounds error, 264–265, 287–289

  • panic function, 265

  • passing by value, 184

  • path package, 54

  • pointer usage, 187

  • printing stack traces, 308

  • printing value Go-syntax, 69–70

  • printing value type, 67

  • printing values, 68–69

  • problem solved by single task execution, 460–462

  • -race flag, 445–446

  • range keyword, 106

  • range loops, 348

  • raw string literals, 36–37

  • reading closed buffered channels, 362–363

  • reading closed channels, 354–355

  • reading files, 504–505

  • receiving pointers, 184

  • recover function, 266

  • recovering from panics, 266–269

  • resolving name conflicts, 55–57

  • return arguments, 143

  • returning errors, 144

  • runes, 38

  • running package tests, 213

  • running specific tests, 218–219

  • running tests with subpackages, 213–214

  • runtime.GOMAXPROCS function, 341–342

  • saturation example, 34–35

  • scope of deferred functions, 160–162

  • select statements, 349

  • sending TEST_SIGNAL signal, 416

  • sending/receiving values via channels, 345

  • setting and retrieving map values, 111–112

  • shared access example, 443–445, 449

  • signal.Notify function, 364

  • signal.NotifyContext function, 412

  • slice of four strings, 78–79

  • smtp package, 7

  • sort package, 127–128

  • sorting map keys, 128–129

  • sound package, 7

  • standard error examples, 290–291

  • starting concurrent monitors, 401–402

  • strconv.ParseInt function, 73

  • string formatting verbs, 63

  • string keys in contexts, 388

  • struct tags, 173

  • structs as map keys, 115–116

  • structure of subtests, 211–212

  • structure of table driven tests, 208

  • subsets of slices, 99

  • subtests, 212–213

  • switch statements, 136–138

  • sync package, 447

  • sync.Locker interface, 450

  • sync.Locker.Lock method, 450

  • sync.Locker.Unlock method, 451

  • sync.Mutex type, 451–453

  • sync.Once type, 459–460, 462–463, 465

  • sync.RWMutex type, 453–455

  • sync.Waitgroup type, 421, 432–433

  • sync.WaitGroup.Add method, 422

  • sync.WaitGroup.Done method, 427–431

  • sync.WaitGroup.Wait method, 422

  • syntactic sugar for methods, 177–178

  • table driven tests, 209–210

  • test file naming conventions, 196

  • test function signatures, 196

  • testing map key presence, 122–123

  • testing system signals, 414–416

  • testing.Short function, 216–217

  • testing.T type, 197

  • testing.TB interface, 222–223

  • testing.TB.Cleanup method, 227–229

  • testing.TB.Helper method, 226

  • testing.T.Error method, 198–200

  • testing.T.Fatal method, 198, 200–201

  • testing.T.Parallel method, 217–218

  • testing.T.Run method, 211

  • theoretical representation of slices, 91

  • time.Ticker function, 351

  • timing out nonresponsive shutdown, 370–371

  • timing out tests, 219–220

  • type assertion usage example, 255–257

  • type assertions, 251, 329–330

  • type assertions with switch statements, 253–254

  • type definitions for arrays and slices, 83–84

  • typed constants, 49

  • underlying type constraints, 324–326

  • unidirectional channels, 352

  • uninitialized maps, 114

  • unused variables, 47

  • Unwrapper interface, 299

  • unwrapping errors, 297–301

  • updating complex values in maps, 125–126

  • updating dependencies, 21–22

  • UTF-8 character example, 37–38

  • validating type assertions, 252

  • variable declarations, 27–28

  • variable scope in if statements, 132–134

  • variadic arguments, 151–153

  • verbose test output, 214

  • verifying concrete types with type assertions, 252

  • when to use variadic arguments, 154–156

  • work sharing, 339–340

  • work stealing, 341

  • wraparound example, 33

  • wrapping errors, 294–297

  • writing to closed channels, 358

  • zero values for arrays and slices, 81

  • zero values for closed channels, 355–357

  • zero values for maps, 121–122

  • zero values for variables, 42–44

• lists

  • arrays

    • converting to slices, 102–104

    • creating, 79

    • data types in, 82–83

    • indexing, 81–82

    • initializing, 79–80

    • iteration over, 105

    • purpose of, 77

    • setting values of, 85

    • slices versus, 77–79

    • subsets of, 103–104

    • type definitions, 83–84

    • zero values, 81

  • slices

    • appending to, 85–90, 97

    • arrays versus, 77–79

    • converting arrays to, 102–104

    • copying, 101–102

    • creating, 79, 95–97

    • data types in, 82–83

    • declaring, 95–96

    • growing, 92–94, 97–99

    • indexing, 81–82

    • initializing, 79–80

    • iteration over, 105

    • length and capacity, 91–92, 96–97

    • purpose of, 77

    • setting values of, 85

    • subsets of, 99–100

    • theoretical representation of, 91

    • type definitions, 83–84

    • zero values, 81

• locking resources

  • improper mutex usage, 455–459

  • sync.Locker interface, 449–451

  • sync.Mutex type, 451–453

  • sync.RWMutex type, 453–455

• log.Fatal function, 273

• logging in tests, 215

• logic. See boolean logic; control structures

• loops

  • do while loops, 108–109

  • for loops

    • appending to slices, 88–89

    • break keyword, 107–108

    • continue keyword, 107–108

    • explained, 104–105

    • iteration over arrays and slices, 105

    • range keyword, 105–106

  • over channels, 348

make function, 95–97, 113, 278, 344

maps

• explained, 111

• initializing, 113, 275–278

• iteration over, 116–118

• keys in, 114–116

  • deleting, 118–119

  • interface drawbacks, 311–315

  • listing, 126–127

  • nonexistent, 120–121

  • sorting, 127–129

  • testing presence of, 122–123

• length and capacity, 112–113

• uninitialized, 114

• values

  • complex values, 123–124

  • copying on insert, 124–125

  • updating complex values, 125–126

• zero values, 121–122

mathematical operators, 134

memory management, 28

• array and slice memory spaces, 85

• cleaning up test helpers, 227–229

• goroutines, 339

• heap, 183

• pointers and, 190–191

• stack, 183, 186

message delivery, buffered channels and, 360–362

message queues, channels versus, 349–351

metadata on files, 471–473

methods

• calling, 177

• declaring, 176

• on functions, 181

• functions versus, 177

• inheritance, 181–182

• mixing type and method constraints, 331

• syntactic sugar, 177–178

• for test failures, 198–202

• on third-party types, 178–179

• value versus pointer receivers, 188–189

mocking file systems, 513–517

modifying

• constants, 48

• embedded files, 521–522

• variables, 48–49

• modules, 1–4

  • commands for, 2

  • definition of, 1

  • dependencies, 16–22

  • go.sum file, 20–21

  • requiring, 18–20

  • updating, 21–22

  • usage, 17–18

• importing, 13–16, 22

• initializing, 3

• VCS and, 3–4

monitors, starting concurrent, 401–402

multiline strings in raw string literals, 36–37

multiple arguments with Println function, 61

multiple directories, creating, 489–492

multiple generic types, 317–320

multiple init functions, 163–164

multiple interfaces, 241

multiple packages

• in folder structure, 198

• importing, 14, 23–24

multiple return arguments, 144–145

multiple type constraints, 322–323

multiple values, assigning to variables, 45–46

mutating subsets of slices, 100

mutexes, synchronization with

• detecting race conditions in tests, 447–449

• improper usage, 455–459

• locking resources, 449–451

• sync.RWMutex type, 453–455

• usage example, 451–453

name conflicts

• between variables and packages, 53–57

• when importing packages, 14–16

named returns, 145–147

names of files/directories, retrieving, 486

naming

• files, 9

• packages, 5–6

• test files, 195–196

• variables, 51–57

  • bad examples, 52

  • capitalization, 57

  • package name conflicts, 53–57

  • rules for, 51–52

  • styles for, 53

negative number of goroutines, adding to waitgroups, 425–426

new function, 189–190

new lines

• escape characters for, 61–62

• printing, 60

nil receivers, 191–193, 274–275

nil value for variables, 42

nodal hierarchy for contexts, 381

• context.WithValue function, 382, 384–386

• key resolution, 386–387

• usage example, 382–384

nonexistent map keys, 120–121

nonresponsive shutdown, timing out, 370–371

numbers, converting strings to/from, 72–75

numeric types, 31–35

• architecture-independent, 31

• choosing, 32

• implementation-specific, 31

• overflow versus wraparound, 32–34

• saturation, 34–35

operators

• list of, 30

• logic and math, 134–135

order of execution

• for deferred function calls, 157

• for init functions, 164

os.Create function, 492–494, 495–496, 499–500

os.DirEntry type, 468

os.DirFS function, 512

os.FileMode type, 482

os.Interrupt type, 365

os.Mkdir function, 481–483, 488–489

os.MkdirAll function, 489–492, 499–500

os.OpenFile function, 501

os.ReadDir function, 468, 470

os.ReadFile function, 494–495

os.Signal type, 364

os/signals package, 363–365

os.Stat function, 472–473

out-of-bounds errors, 81–82, 264–265, 287–289

overflow in numeric types, 32–34

package aliases, resolving name conflicts, 16, 56–57

package keyword, 5

packages, 4–6

• definition of, 4

• dependencies, 16–22

  • go.sum file, 20–21

  • requiring, 18–20

  • updating, 21–22

  • usage, 17–18

• folder structure, 4, 6–13

  • multiple packages, 7–9

  • naming files, 9

  • organization, 9–13

• importing, 13–16

  • cyclical imports, 24–25

  • multiple versions, 23–24

  • for side effects, 164–166

• initializing. See init functions

• name conflicts

  • with variables, 53–57

  • when importing, 14–16

• naming, 5–6

• running tests, 213, 217

padding integers, 64–66

panic function, 265

panics

• avoiding, 273

  • assigning functions to variables, 283–284

  • checking for nil receivers, 274–275

  • checking type assertions, 284–287

  • initializing interfaces, 280–283

  • initializing maps, 275–278

  • initializing pointers, 278–280

  • from out-of-bounds errors, 287–289

• capturing and returning values, 269–273

• closing channels, 464–465

• decrementing sync.WaitGroup, 431

• deferred function calls and, 158

• log.Fatal function, 273

• from out-of-bounds errors, 264–265, 287–289

• raising, 265

• recovering from, 265–269

parallelism

• concurrency versus, 335–336

• running tests in parallel, 217–218

ParseInt function, 73

passing

• by reference, 186

• by value, 183–184

path for importing packages, 13–14

performance, pointers and, 190–191

pointer receivers, value receivers versus, 188–189

pointers, 182–183

• getting, 185–186

• initializing, 278–280

• new function, 189–190

• nil receivers, 191–193

• passing by reference, 186

• passing by value, 183–184

• performance, 190–191

• printing, 185

• receiving, 184

• usage example, 186–187

positive number of goroutines, adding

to waitgroups, 423–424

Print functions, 59

printing

• pointers, 185

• runes, 38

• stack traces, 308

• strings

  • Fprint functions, 59

  • multiple Println arguments, 61

  • new lines, 60

  • Print functions, 59

• structs, 169

• values

  • with formatting verbs, 67–69

  • Go-syntax of value, 69–70

  • type of value, 67

Println function

• adding new lines, 60

• multiple arguments, 61

quotation marks for string literals, 35

race conditions

• detecting in tests, 447–449

• -race flag, 445–447

• shared access example, 443–445

-race flag, 445–447

raising panics, 265

range keyword, 39–40, 105–106, 116–118, 348

raw string literals, 36–37

reading

• closed buffered channels, 362–363

• closed channels, 354–357

• directories, 468–470

• files, 494–495, 503–505

receivers

• nil, 191–193

• value versus pointer, 188–189

receiving

• pointers, 184

• values via channels, 344–345

recover function, 265–269

recovering from panics, 265–269

requiring dependencies, 18–20

return arguments, 143–144

• accepting in functions, 151

• capturing panic values, 269–273

• error handling, 262–263

• multiple, 144–145

• named returns, 145–147

rune numeric type, 31, 38

running tests, 213

• disabling test caching, 221

• failing fast, 220–221

• logging in tests, 215

• package tests, 213, 217

• in parallel, 217–218

• short tests, 216–217

• specific tests, 218–219

• with subpackages, 213–214

• timing out, 219–220

• verbose output, 214

runtime.GOMAXPROCS function, 341–342

saturation in numeric types, 34–35

scheduling goroutines, 339–342

scope

• of APIs, 10

• of deferred functions, 160–162

• of variables in if statements, 132–134

security of context keys, 394–396

select statements, 348–349

selecting numeric types, 32

semantic versioning, 22

sending

• TEST_SIGNAL signal, 416

• values via channels, 344–345

shared access

• improper mutex usage, 455–459

• locking resources, 449–451

• mutex usage example, 451–453

• race conditions, 443–445, 447–449

• sync.RWMutex type, 453–455

short tests, 216–217

shutdown, graceful

• implementing, 365–367

• listening for shutdown confirmation, 368–370

• listening for system signals, 367–368

• rules for, 363

• timing out nonresponsive shutdown, 370–371

shutdown confirmation, listening for, 368–370

side effects, init functions for, 164–166

signal.Notify function, 364

signal.NotifyContext function, 412

single execution of task

• closing channels, 463–466

• problem solved by, 460–462

• sync.Once type, 459–460, 462–463

skipping

• directories, 477–481

• files, 477

slices

• appending to, 85–90, 97

• arrays versus, 77–79

• avoiding out-of-bounds errors, 287–289

• converting arrays to, 102–104

• copying, 101–102

• creating, 79, 95–97

• data types in, 82–83

• declaring, 95–96

• embedding files as, 522

• expanding with variadic operator, 153–154

• growing, 92–94, 97–99

• indexing, 81–82

• initializing, 79–80

• iteration over, 105

• length and capacity, 91–92, 96–97

• purpose of, 77

• setting values of, 85

• subsets of, 99–100

• theoretical representation of, 91

• type definitions, 83–84

• zero values, 81

sort package, 127–129

sorting map keys, 127–129

specific tests, running, 218–219

Sprint functions, 58–59

stack, 183, 186

stack traces, 307–308

standard errors, custom errors versus, 289–291

starting concurrent monitors, 401–402

static typing, 27–28

strconv package, 72–75

string keys in contexts, 388

• custom types, 390–393

• key collisions, 388–390

string literals, 35–37

• converting to/from numbers, 72–75

• embedding files as, 522

• formatting

  • errors with formatting verbs, 70–71

  • escape characters, 61–63

  • explicit argument indexes, 71–72

  • with formatting verbs, 61, 63

  • list of functions, 57–58

  • Sprint functions, 58–59

• interpreted, 35

• printing

  • Fprint functions, 59

  • multiple Println arguments, 61

  • new lines, 60

  • Print functions, 59

• quotation marks for, 35

• raw, 36–37

struct tags, encoding with, 173–176

structs, 167

• accessing fields, 172–173

• defining, 168–169

• initializing, 169–172

• as map keys, 115–116

• printing, 169

structural typing, 235

subdirectories, creating, 481–483

subpackages, running tests with, 213–214

subsets

• of arrays, 103–104

• of slices, 99–100

subtests, 211–213

switch statements, 135–138

• default blocks, 138–139

• fallthrough keyword, 139–140

• type assertions with, 252–254

sync package, 447

synchronization

• error groups

  • errgroup.Group type, 436, 440–442

  • errgroup.Group.Go method, 437

  • errgroup.Group.Wait method, 437–439

  • errgroup.WithContext function, 439–440

  • golang.org/x/sync/errgroup package, 434

  • problem solved by, 434–436

• with mutexes

  • detecting race conditions in tests, 447–449

  • improper usage, 455–459

  • locking resources, 449–451

  • sync.RWMutex type, 453–455

  • usage example, 451–453

• race conditions

  • -race flag, 445–447

  • shared access example, 443–445

• single execution of task closing channels, 463–466

• problem solved by, 460–462

• sync.Once type, 459–460, 462–463

sync package, 447

waitgroups

• problem solved by, 419–421

• sync.Waitgroup type, 421, 432–433

• sync.WaitGroup.Add method, 422–426

• sync.WaitGroup.Done method, 426–431

• sync.WaitGroup.Wait method, 421–422

sync.Locker interface, 449–451

sync.Locker.Lock method, 450

sync.Locker.Unlock method, 451

sync.Mutex type, 451–453

sync.Once type, 459–460, 462–463, 465

sync.RWMutex type, 453–455

sync.Waitgroup type, 421, 432–433

sync.WaitGroup.Add method, 422–426

sync.WaitGroup.Done method, 426–431

sync.WaitGroup.Wait method, 421–422

syntactic sugar for methods, 177–178

system signals

capturing, 363

• implementing graceful shutdown, 365–367

• listening for shutdown confirmation, 368–370

• listening for system signals, 367–368

• os/signals package, 363–365

• timing out nonresponsive shutdown, 370–371

listening with contexts, 411–413

testing, 413–416

tab character, escape characters for, 61–62

table driven testing, 206–207

• structure of, 207–208

• subtests, 211–213

• writing, 208–210

test caching, disabling, 221

test failures

• crafting failure messages, 201–202

• marking, 198

• testing.T.Error method, 198–200

• testing.T.Fatal method, 200–201

test files, naming, 195–196

test function signatures, 196

test helpers, 222

• cleaning up, 227–229

• defining, 222–226

• marking functions as, 226–227

TEST_SIGNAL signal, sending, 416

testdata directory, 467–468, 480–481

testing

• map key presence, 122–123

• system signals, 413–416

testing framework, 195

• code coverage

  • coverage profiles, 203–204

  • editor support for, 206

  • go test command, 202–203

  • go tool cover command, 204–205

  • HTML coverage reports, 205–206

• running tests, 213

  • disabling test caching, 221

  • failing fast, 220–221

  • logging in tests, 215

  • package tests, 213, 217

  • in parallel, 217–218

  • short tests, 216–217

  • specific tests, 218–219

  • with subpackages, 213–214

  • timing out, 219–220

  • verbose output, 214

• table driven testing, 206–207

  • structure of, 207–208

  • subtests, 211–213

  • writing, 208–210

• test failures

  • crafting failure messages, 201–202

  • marking, 198

  • testing.T.Error method, 198–200

  • testing.T.Fatal method, 200–201

• test file naming conventions, 195–196

• test helpers, 222

  • cleaning up, 227–229

  • defining, 222–226

  • marking functions as, 226–227

• testing.T type, 196–197

testing.Short function, 216–217

testing.T type, 196–197

testing.TB interface, 222–223

testing.TB.Cleanup method, 227–229

testing.TB.Helper method, 226

testing.T.Error method, 198–200

testing.T.Fatal method, 198, 200–201

testing.T.Log method, 215

testing.T.Parallel method, 217–218

testing.T.Run method, 211

third-party types, methods on, 178–179

threads. See goroutines

time.Ticker function, 351

timing out

• contexts, 407–408

• nonresponsive shutdown, 370–371

• tests, 219–220

truncating files, 495–497

type assertions, 250–251

• avoiding panics, 284–287

• concrete type verification, 252

• generics and, 329–331

• with switch statement, 252–254

• usage example, 255–257

• validating, 251–252

type constraints, 315–317

• constraints package, 326–328

• defining, 321–322

• mixing with method constraints, 331

• multiple, 322–323

• underlying, 324–326

type definitions for arrays and slices, 83–84

type inference, 50–51

type keyword, 167–168

type of value, printing, 67

typed constants, 49

types. See data types; interfaces

uint numeric type, 31–32

uint8 numeric type, 31

uint16 numeric type, 31

uint32 numeric type, 31

uint64 numeric type, 31

uintptr numeric type, 31

unblocking channels, 343–344

underlying type constraints, 324–326

unidirectional channels, 351–352

uninitialized maps, 114

untyped constants, 50–51

unused variables, 46–47

Unwrapper interface, 299

unwrapping errors, 297–301

updating

• complex values in maps, 125–126

• dependencies, 21–22

UTF-8 characters, 37–40

• iterating over, 38–40

• runes, 38

validatable interfaces, 250

validating type assertions, 251–252

value receivers, pointer receivers versus, 188–189

values

• of arrays and slices, setting, 85

• converting strings to/from, 72–75

• errors as, 259–261

  • error interface, 261

  • errors.New function, 261

  • fmt.Errorf method, 262

  • handling, 262–263

  • usage example, 263–264

• lists of. See lists

• in maps

  • complex values, 123–124

  • copying on insert, 124–125

  • updating complex values, 125–126

• panic values, capturing and returning, 269–273

• printing

  • with formatting verbs, 67–69

  • Go-syntax of value, 69–70

  • type of value, 67

• receiving pointers, 184

• retrieving from contexts, 376–378

• sending/receiving via channels, 344–345

• wrapping contexts with, 382, 384–386

var keyword, 40

variables, 40–47

• assigning, 41–42

  • functions to, 283–284

  • multiple values, 45–46

• closures, 149–150

• declaring, 40, 44–45

• discarding, 47

• exporting, 57

• functions as, 147–148

• getting pointers, 185–186

• initializing, 44–45

• modifying, 48–49

• naming, 51–57

  • bad examples, 52

  • capitalization, 57

  • package name conflicts, 53–57

  • rules for, 51–52

  • styles for, 53

• nil value, 42

• scope in if statements, 132–134

• unused, 46–47

• values

  • converting strings to/from, 72–75

  • lists of. See lists

  • printing, 67–69

  • printing Go-syntax of, 69–70

  • printing type of, 67

• zero values, 42–44

variadic arguments, 151–152

• with append function, 89–90

• passing slices with, 153–154

• position of, 152–153

• when to use, 154–156

VCS (version control systems), modules and, 3–4

verbose test output, 214

verbs, formatting, 61

• errors with, 70–71

• escape characters, 61–63

• explicit argument indexes, 71–72

• floats, 66–67

• integers, 63–66

• strings, 63

• value type printing, 67

waitgroups

• problem solved by, 419–421

• sync.Waitgroup type, 421, 432–433

• sync.WaitGroup.Add method, 422–426

• sync.WaitGroup.Done method, 426–431

• sync.WaitGroup.Wait method, 421–422

walk test errors, fixing, 497–500

walking directories, 473–477, 510–513

Windows filepaths, 505–506

work sharing, 339–340

work stealing, 341

wraparound in numeric types, 32–34

wrapping

• contexts with values, 382, 384–386

• errors, 294–297

writing

• to closed channels, 358

• subtests, 212–213

• table driven testing, 208–210

zero number of goroutines, adding to waitgroups, 424–425

zero values

• for arrays and slices, 81

• for closed channels, 355–357

• for maps, 121–122

• for variables, 42–44