Conditionals & Testing

.leftcol30[
<center>
<img src="https://github.com/emse-p4a-gwu/emse-p4a-gwu.github.io/raw/master/images/p4a_hex_sticker.png" width=250>
</center>
]

### <svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:1em;width:1em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M496 128v16a8 8 0 0 1-8 8h-24v12c0 6.627-5.373 12-12 12H60c-6.627 0-12-5.373-12-12v-12H24a8 8 0 0 1-8-8v-16a8 8 0 0 1 4.941-7.392l232-88a7.996 7.996 0 0 1 6.118 0l232 88A8 8 0 0 1 496 128zm-24 304H40c-13.255 0-24 10.745-24 24v16a8 8 0 0 0 8 8h464a8 8 0 0 0 8-8v-16c0-13.255-10.745-24-24-24zM96 192v192H60c-6.627 0-12 5.373-12 12v20h416v-20c0-6.627-5.373-12-12-12h-36V192h-64v192h-64V192h-64v192h-64V192H96z"/></svg> EMSE 4571: Intro to Programming for Analytics
### <svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M224 256c70.7 0 128-57.3 128-128S294.7 0 224 0 96 57.3 96 128s57.3 128 128 128zm89.6 32h-16.7c-22.2 10.2-46.9 16-72.9 16s-50.6-5.8-72.9-16h-16.7C60.2 288 0 348.2 0 422.4V464c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48v-41.6c0-74.2-60.2-134.4-134.4-134.4z"/></svg> John Paul Helveston
### <svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M0 464c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V192H0v272zm320-196c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zM192 268c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zM64 268c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12H76c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12H76c-6.6 0-12-5.4-12-12v-40zM400 64h-48V16c0-8.8-7.2-16-16-16h-32c-8.8 0-16 7.2-16 16v48H160V16c0-8.8-7.2-16-16-16h-32c-8.8 0-16 7.2-16 16v48H48C21.5 64 0 85.5 0 112v48h448v-48c0-26.5-21.5-48-48-48z"/></svg> February 03, 2022
]

---

# Week 4: .fancy[Conditionals & Testing]

## 1. Conditionals
## 2. Testing

## BREAK

## 3. Tips

---

# Week 4: .fancy[Conditionals & Testing]

## 1. .orange[Conditionals]
## 2. Testing

## BREAK

## 3. Tips

---

# "Flow Control"

### Code that alters the otherwise linear flow of operations in a program.

- `if` statements
- `else` statements
]

- `for` loops
- `while` loops
- `break` statements
- `next` statements
]

---

### Basic format

```r
if ( CONDITION ) {
    # Do stuff here
}
```
]]

<br>

---

# Quick code tracing

Consider this function:

```r
f <- function(x) {
    cat("A")
    if (x == 0) {
        cat("B")
        cat("C")
    }
    cat("D")
}
```
]]

What will this print?

```r
f(1)
f(0)
```
]]

---

# Quick practice

### Write the function `absValue(n)` that returns the absolute value of a number (and no cheating - you can't use the built-in `abs()` function!)

Tests:
- `absValue(7) == 7`
- `absValue(-7) == 7`
- `absValue(0) == 0`

---

### Basic format:

```r
if ( CONDITION ) {
  # Do stuff here
} else {
  # Do other stuff here
}
```
]]

<br>

---

# Quick code tracing

```r
f <- function(x) {
    cat("A")
    if (x == 0) {
        cat("B")
        cat("C")
    } else {
        cat("D")
        if (x == 1) {
            cat("E")
        } else {
            cat("F")
        }
    }
    cat("G")
}
```
]]

What will this print?

```r
f(0)
f(1)
f(2)
```
]]

---

# `else if` chains

Example - "bracketing" problems:

```r
getLetterGrade <- function(score) {
    if (score >= 90) {
        grade <- "A"
    } else if (score >= 80) {
        grade <- "B"
    } else if (score >= 70) {
        grade <- "C"
    } else if (score >= 60) {
        grade <- "D"
    } else {
        grade <- "F"
    }
    return(grade)
}
```
]

Check function output:

```r
getLetterGrade(99)
```

```
#> [1] "A"
```

```r
getLetterGrade(88)
```

```
#> [1] "B"
```

```r
getLetterGrade(70)
```

```
#> [1] "C"
```

```r
getLetterGrade(61)
```

```
#> [1] "D"
```

```r
getLetterGrade(22)
```

```
#> [1] "F"
```
]

---

# Your turn

Write the function `getType(x)` that returns the type of the data (either `integer`, `double`, `character`, or `logical`).

Basically, it should do the same thing as the `typeof()` function (but you can't use `typeof()` in your solution).

Tests:

- `getType(3) == "double"`
- `getType(3L) == "integer"`
- `getType("foo") == "character"`
- `getType(TRUE) == "logical"`

---

# Week 4: .fancy[Conditionals & Testing]

## 1. Conditionals
## 2. .orange[Testing]

## BREAK

## 3. Tips

---

# Why write test functions?

<br>

## 1. They help you understand the problem

## 2. They verify that a function is working as expected

---

# Test function "syntax"

### Function:

```r
functionName <- function(arguments) {
    # Do stuff here
    return(something)
}
```
]]

### Test function:

```r
test_functionName <- function() {
    cat("Testing functionName()...")
    # Put test cases here
    cat("Passed!\n")
}
```
]]

---

# Writing test cases with `stopifnot()`

`stopifnot()` stops the function if whatever is inside the `()` is not `TRUE`.

### Function:

```r
isEven <- function(n) {
    return((n %% 2) == 0)
}
```

- `isEven(1)` should be `FALSE`
- `isEven(2)` should be `TRUE`
- `isEven(-7)` should be `FALSE`

]]

### Test function:

```r
test_isEven <- function() {
    cat("Testing isEven()...")
    stopifnot(isEven(1) == FALSE)
    stopifnot(isEven(2) == TRUE)
    stopifnot(isEven(-7) == FALSE)
    cat("Passed!\n")
}
```
]]

---

# Writing test cases with `stopifnot()`

`stopifnot()` stops the function if whatever is inside the `()` is not `TRUE`.

### Function:

```r
isEven <- function(n) {
    return((n %% 2) == 0)
}
```

- `isEven(1)` should be `FALSE`
- `isEven(2)` should be `TRUE`
- `isEven(-7)` should be `FALSE`
]]

### Test function:

```r
test_isEven <- function() {
    cat("Testing isEven()...")
    stopifnot(isEven(1) == FALSE)
    stopifnot(isEven(2) == TRUE)
    stopifnot(isEven(-7) == FALSE)
    cat("Passed!\n")
}
```

```r
test_isEven()
```

```
#> Testing isEven()...Passed!
```
]]

---

# Write the test function _first_!

### Step 1: Write the test function

```r
test_isEven <- function() {
    cat("Testing isEven()...")
    stopifnot(isEven(1) == FALSE)
    stopifnot(isEven(2) == TRUE)
    stopifnot(isEven(-7) == FALSE)
    cat("Passed!\n")
}
```
]]

### Step 2: Write the function

```r
isEven <- function(n) {
    return((n %% 2) == 0)
}
```

### Step 3: Test the function

```r
test_isEven()
```

```
#> Testing isEven()...Passed!
```
]]

---

# Test cases to consider: NOLES

.leftcol40[
- ### **N**ormal cases
- ### **O**pposites
- ### **L**arge & small cases
- ### **E**dge cases
- ### **S**pecial cases
]

---

# Test cases to consider: NOLES

.leftcol40[
- ### .red[**N**ormal cases]
- ### **O**pposites
- ### **L**arge & small cases
- ### **E**dge cases
- ### **S**pecial cases
]

### Example:

```r
isEven <- function(n) {
    return((n %% 2) == 0)
}
```
]

- `isEven(1) == FALSE`
- `isEven(2) == TRUE`
- `isEven(-7) == FALSE`
]

---

# Test cases to consider: NOLES

.leftcol40[
- ### **N**ormal cases
- ### .red[**O**pposites]
- ### **L**arge & small cases
- ### **E**dge cases
- ### **S**pecial cases
]

### Example:

```r
isEven <- function(n) {
    return((n %% 2) == 0)
}
```
]

Need cases that return both `TRUE` and `FALSE`

- `isEven(52) == TRUE`
- `isEven(53) == FALSE`
- `isEven(5) == FALSE`
- `isEven(-5) == FALSE`
]

---

# Test cases to consider: NOLES

.leftcol40[
- ### **N**ormal cases
- ### **O**pposites
- ### .red[**L**arge & small cases]
- ### **E**dge cases
- ### **S**pecial cases
]

### Example:

```r
isEven <- function(n) {
    return((n %% 2) == 0)
}
```
]

- `isEven(8675309) == FALSE`
- `isEven(-8675309) == FALSE`
- `isEven(1) == FALSE`
- `isEven(-1) == FALSE`
]

---

# Test cases to consider: NOLES

.leftcol40[
- ### **N**ormal cases
- ### **O**pposites
- ### **L**arge & small cases
- ### .red[**E**dge cases]
- ### **S**pecial cases
]

### Example:

```r
isPositive <- function(n) {
    return(n > 0)
}
```
]

- `isPositive(0.000001) == TRUE`
- `isPositive(0) == FALSE`
- `isPositive(-0.000001) == FALSE`
]

---

# Test cases to consider: NOLES

.leftcol40[
- ### **N**ormal cases
- ### **O**pposites
- ### **L**arge & small cases
- ### **E**dge cases
- ### .red[**S**pecial cases]
]

.rightcol60[
- Negative numbers
- `0` and `1` for integers
- The empty string, `""`
- Strange input _types_, e.g. `"2"` instead of `2`.
]

---

# Testing function inputs

What if we gave `isEven()` the wrong input type?

```r
isEven <- function(n) {
    return((n %% 2) == 0)
}
```

```r
isEven('42')
```

```
#> Error in n%%2: non-numeric argument to binary operator
```
]]

```r
isEven <- function(n) {
    if (! is.numeric(n)) {
        return(NaN)
    }
    return((n %% 2) == 0)
}
```
]]

---

# Testing function inputs

What if we gave `isEven()` the wrong input type?

```r
isEven <- function(n) {
    return((n %% 2) == 0)
}
```

```r
isEven('42')
```

```
#> Error in n%%2: non-numeric argument to binary operator
```
]]

An improved function that checks inputs:

```r
isEven <- function(n) {
    if (! is.numeric(n)) {
        return(NaN)
    }
    return((n %% 2) == 0)
}
```

```r
isEven('42')
```

```
#> [1] NaN
```

```r
isEven(TRUE)
```

```
#> [1] NaN
```
]]

---

# Your turn

For each of the following functions, start by writing a test function that tests the function for a variety of values of inputs. Consider cases that you might not expect!

.leftcol[
1) Write the function `isFactor(f, n)` that takes two integer values and returns `TRUE` if `f` is a factor of `n`, and `FALSE` otherwise (e.g. `2` is a factor of `6`). Note that every integer is a factor of `0`. Assume `f` and `n` will only be numeric values.
]

.rightcol[
2) Write the function `isMultiple(m, n)` that takes two integer values and returns `TRUE` if `m` is a multiple of `n` and `FALSE` otherwise. Note that `0` is a multiple of every integer other than itself. Hint: You may want to use the `isFactor(f, n)` function you just wrote above. Assume `m` and `n` will only be numeric values.
]

---

# .fancy[Break]

---

# Week 4: .fancy[Conditionals & Testing]

## BREAK

## 3. .orange[Tips]
]

---

background-color: #fff

---

# Debugging your code

Use `traceback()` to find the steps that led to an error (the "call stack")

Example:

```r
f <- function(x) {
    return(x + 1)
}

g <- function(x) {
    return(f(x) - 1)
}
```

```r
g('a')
```

```
#> Error in x + 1: non-numeric argument to binary operator
```

```r
traceback()
```

```
2: f(x) at #2
1: g("a")
```

---

# When testing _numbers_, use `almostEqual()`

Rounding errors can cause headaches:

```r
x <- 0.1 + 0.2
x
```

```
#> [1] 0.3
```

```r
x == 0.3
```
```
#> [1] FALSE
```
]]

---

# When testing _numbers_, use `almostEqual()`

Rounding errors can cause headaches:

```r
x <- 0.1 + 0.2
x
```

```
#> [1] 0.3
```

```r
x == 0.3
```

```
#> [1] FALSE
```

```r
print(x, digits = 20)
```

```
#> [1] 0.30000000000000004441
```
]]

---

# When testing _numbers_, use `almostEqual()`

Rounding errors can cause headaches:

```r
x <- 0.1 + 0.2
x
```

```
#> [1] 0.3
```

```r
x == 0.3
```

```
#> [1] FALSE
```

```r
print(x, digits = 20)
```

```
#> [1] 0.30000000000000004441
```
]]

```r
almostEqual <- function(n1, n2, threshold = 0.00001) {
    return(abs(n1 - n2) <= threshold)
}
```

```r
x <- 0.1 + 0.2
almostEqual(x, 0.3)
```

```
#> [1] TRUE
```
]]

---

# Checking for integer values

```r
is.integer(7)
```

```
#> [1] FALSE
```
]]

Define a new function that returns `TRUE` if the _value_ is an integer:

```r
is.integer.val <- function(x) {
    return(almostEqual(x, round(x)))
}
is.integer.val(7)
```

```
#> [1] TRUE
```
]]

---

# Checking for special data types

**Not available**: `NA`<br>_value is "missing"_

```r
x <- NA
x == NA
```

```
#> [1] NA
```
]

**No value**: `NULL`<br>_no value whatsoever_

```r
x <- NULL
x == NULL
```

```
#> logical(0)
```
]

---

# Checking for special data types

**Not available**: `NA`<br>_value is "missing"_

```r
x <- NA
x == NA
```

```
#> [1] NA
```

Have to use special function:

```r
is.na(x)
```

```
#> [1] TRUE
```
]

**No value**: `NULL`<br>_no value whatsoever_

```r
x <- NULL
x == NULL
```

```
#> logical(0)
```

Have to use special function:

```r
is.null(x)
```

```
#> [1] TRUE
```
]

---

# Your turn

Write the function `getInRange(x, bound1, bound2)` which takes 3 numeric values: `x`, `bound1`, and `bound2`. `bound1` is not necessarily less than `bound2`. If `x` is between the two bounds, return `x`, but if `x` is less than the lower bound, return the lower bound, or if `x` is greater than the upper bound, return the upper bound. For example:

- `getInRange(1, 3, 5)` returns `3` (the lower bound, since 1 is below [3,5])
- `getInRange(4, 3, 5)` returns `4` (the original value, since 4 is between [3,5])
- `getInRange(6, 3, 5)` returns `5` (the upper bound, since 6 is above [3,5])
- `getInRange(6, 5, 3)` returns `5` (the upper bound, since 6 is above [3,5])

You should also write a test function called `test_getInRange()`.

**Bonus**: Try writing `getInRange(x, bound1, bound2)` without using `if` or `else`

---

# [HW 4](https://p4a.seas.gwu.edu/2022-Spring/hw4-conditionals-testing.html)

## You'll need to write a _test function_ for each function!