// license that can be found in the LICENSE file.

// Tests short circuiting.

package main

import "testing"

func and_ssa(arg1, arg2 bool) bool {
	return arg1 && rightCall(arg2)
}

func or_ssa(arg1, arg2 bool) bool {
	return arg1 || rightCall(arg2)
}

var rightCalled bool

//go:noinline
func rightCall(v bool) bool {
	rightCalled = true
	return v
	panic("unreached")
}

	// uintptr cast above.
	var z uintptr
	if always {
		z = y
	} else {
		z = 0
	}
	return (*[8]uint)(unsafe.Pointer(z))
}

// g_ssa is the same as f_ssa, but with a bit of pointer
// arithmetic for added insanity.
func g_ssa() *[7]uint {
	// Make x a uintptr pointing to where a points.
	var x uintptr
	if always {
		x = uintptr(unsafe.Pointer(a))
	} else {
		x = 0
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test control flow

package main

import "testing"

// nor_ssa calculates NOR(a, b).
// It is implemented in a way that generates
// phi control values.
func nor_ssa(a, b bool) bool {
	var c bool
	if a {
		c = true
	}
	if b {
		c = true
	}
	if c {
		return false
	}
	return true
}

package main

import "testing"

//go:noinline
func eq_ssa(a int64) bool {
	return 4+a == 10
}

//go:noinline
func neq_ssa(a int64) bool {
	return 10 != a+4
}

func testCmp(t *testing.T) {
	if wanted, got := true, eq_ssa(6); wanted != got {
		t.Errorf("eq_ssa: expected %v, got %v\n", wanted, got)
	}
	if wanted, got := false, eq_ssa(7); wanted != got {
		t.Errorf("eq_ssa: expected %v, got %v\n", wanted, got)
	}

}

func assertEqual(t *testing.T, x, y int) {
	if x != y {
		mypanic(t, fmt.Sprintf("assertEqual failed got %d, want %d", x, y))
	}
}

func TestAddressed(t *testing.T) {
	x := f1_ssa(2, 3)
	output += fmt.Sprintln("*x is", *x)
	output += fmt.Sprintln("Gratuitously use some stack")
	output += fmt.Sprintln("*x is", *x)
	assertEqual(t, *x, 9)

	w := f3a_ssa(6)
	output += fmt.Sprintln("*w is", *w)

// compile

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func f_ssa(x int, p *int) {
	if false {
		y := x + 5
		for {
			*p = y
		}
	}

		fmt.Fprintf(w, "  mid [%d]byte\n", s)
		fmt.Fprintf(w, "  post [8]byte\n")
		fmt.Fprintf(w, "}\n")

		// function being tested
		fmt.Fprintf(w, "//go:noinline\n")
		fmt.Fprintf(w, "func zero%d_ssa(x *[%d]byte) {\n", s, s)
		fmt.Fprintf(w, "  *x = [%d]byte{}\n", s)
		fmt.Fprintf(w, "}\n")

		// testing harness
		fmt.Fprintf(w, "func testZero%d(t *testing.T) {\n", s)

```Python hl_lines="7"
{!../../../docs_src/first_steps/tutorial003.py!}
```

!!! note "Nota"
    Se você não sabe a diferença, verifique o [Async: *"Com pressa?"*](../async.md#com-pressa){.internal-link target=_blank}.

### Passo 5: retorne o conteúdo

```Python hl_lines="8"
{!../../../docs_src/first_steps/tutorial001.py!}
```

# Sobre HTTPS

É fácil assumir que HTTPS é algo que é apenas "habilitado" ou não.

Mas é bem mais complexo do que isso.

!!! tip "Dica"
    Se você está com pressa ou não se importa, continue com as seções seguintes para instruções passo a passo para configurar tudo com diferentes técnicas.

Mas primeiro, vamos verificar alguns pequenos conceitos.

## Está com pressa?

Se você não se importa com qualquer um desses termos e só precisa adicionar segurança com autenticação baseada em usuário e senha _agora_, pule para os próximos capítulos.

## OAuth2