C
C
Coding Exercise Docs
Search…
C
C
Coding Exercise Docs
Introduction
C++
C#
HTML & JavaScript
Java
PHP
Python 3
React
Ruby
R
SciPy
SQL
Swift
Powered By GitBook
Swift
To evaluate student solutions written in Swift, you need to write tests using XCTest.

Basics

Let's start with a basic exercise. Your student has to implement a HelloWorld class with a function helloWorld() that returns the string "Hello World". For the sake of simplicity, it doesn't print anything.
Here is an example solution:
Exercise.swift
1
import Foundation
2
class HelloWorld {
3
func helloWorld() -> String {
4
return "Hello World"
5
}
6
}
Copied!
And this is an example test of the student's code:
Evaluate.swift
1
import XCTest
2
@testable import Base
3
​
4
class Evaluate: UMBaseTestCase {
5
var hw = HelloWorld()
6
​
7
func testHelloWorld() {
8
XCTAssertEqual(hw.helloWorld(),
9
"Hello World",
10
"You should print 'Hello World'")
11
}
12
}
Copied!
If you are using Swift 3, add the following snippet after that:
1
extension Evaluate {
2
static var allTests : [(String, (Evaluate) -> () throws -> Void)] {
3
return [
4
("testHelloWorld", testHelloWorld)
5
]
6
}
7
}
Copied!
Let's examine the above test code.
1
import XCTest
2
@testable import Base
Copied!
Your code must include those lines to import the XCTest framework and our module.
1
class Evaluate: UMBaseTestCase {
2
​
3
}
Copied!
Your test code must live inside a class named Evaluate. It is, otherwise, just a plain Swift class.
UMBaseTestCase inherits from XCTestCase. It provides some additional helper methods to manipulate Standard Input and Output. The Evaluate class can inherit from UMBaseTestCase or directly XCTestCase.
If you are using Swift 3, in order to run your test methods, you must add all of them to allTests. If you are using Swift 5, you can skip the section below, because we run the tests with --enable-test-discovery. The test method's names names should comply with a naming convention testFoo()
1
extension Evaluate {
2
static var allTests : [(String, (Evaluate) -> () throws -> Void)] {
3
return [
4
("testHelloWorld", testHelloWorld)
5
]
6
}
7
}
Copied!
XCTAssertEqual is a method provided by XCTest which asserts that two expressions have the same value. You can use it with 3 arguments:
    Actual value
    Expected value
    Feedback message to be shown if values are not equal
You can see other assertions here.
Our test class has a test case testHelloWorld() which asserts equality of "Hello World" and the return value of the student's function.

Testing outputs

Let's change the previous example a little bit and ask students to print "Hello World" rather than return the string.
Here is an example solution:
Exercise.swift
1
class HelloWorld {
2
func helloWorld() {
3
print("Hello World")
4
}
5
}
Copied!
To be able to test the student code, you must be able to read standard output after calling helloWorld(). For this purpose, we have provided helper methods on UMBaseTestCase.
For example:
Evaluate.swift
1
import XCTest
2
@testable import Base
3
​
4
class Evaluate: UMBaseTestCase {
5
var hw = HelloWorld()
6
​
7
func testHelloWorld(){
8
self.prepareStdOut()
9
hw.helloWorld()
10
XCTAssertEqual(self.getOutput(),
11
"Hello World\n",
12
"You should print 'Hello World'")
13
}
14
}
Copied!
If you are using Swift 3, add the following snippet after that:
1
extension Evaluate {
2
static var allTests : [(String, (Evaluate) -> () throws -> Void)] {
3
return [
4
("testHelloWorld", testHelloWorld)
5
]
6
}
7
}
Copied!
There are a few differences between this test and the previous one:
    We are using helper methods to gain access to data written to standard output.
    Calling self.prepareStdOut() redirects standard output to a temporary log file to be able to read later.
    Comparing the "Hello World" string with the output that we read with self.getOutput().
    The getOutput() method reads the output from the log file and restores the standard output to previous state, therefore we can get feedback from test results.
You can see more details about helper methods below in other examples.

Providing inputs

How do you test whether students are able to read input from standard input?
Consider that the student's task is to read a customer's first and last name from standard input and print the full name to standard output.
The solution for this problem can be implemented as follows:
Exercise.swift
1
import Foundation
2
class Customer {
3
var name:String!
4
​
5
func getName() -> String {
6
​
7
print("Enter your name:")
8
self.name = self.readString()
9
return self.name
10
}
11
​
12
private func readString() -> String {
13
let str = String(data: FileHandle.standardInput.availableData,
14
encoding:String.Encoding.utf8)!
15
.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
16
return str
17
}
18
}
Copied!
UMBaseTestCase has a method to fill standard input with given values.
1
func setStdInput(input:)
Copied!
inputs: String input to be entered to standard input. A line separator will be appended to each input.
The following test class enters name in the console and checks whether the student's code can return the name.
Evaluate.swift
1
import XCTest
2
@testable import Base
3
​
4
class Evaluate: UMBaseTestCase {
5
var customer = Customer()
6
​
7
func testGetName(){
8
let str = "Albert Einstein"
9
self.setStdInput(input:str)
10
var name = customer.getName()
11
XCTAssertEqual(name,
12
"Albert Einstein",
13
"For inputs 'Albert Einstein' it doesn't work.")
14
}
15
}
Copied!
If you are using Swift 3, add the following snippet after that:
1
extension Evaluate {
2
static var allTests : [(String, (Evaluate) -> () throws -> Void)] {
3
return [
4
("testGetName", testGetName)
5
]
6
}
7
}
Copied!

Testing exceptions

You can expect student code to raise exceptions in some cases.
So let's improve the example above and ask students to throw IllegalArgumentException if the input passed to a function is not valid. setSSN() won't accept SSNs shorter than 10 characters and setAge() won't accept negative ages. And if the age is negative, the exception message must be "Age can't be a negative number.".
The solution for this problem in Swift 3 can be implemented as follows:
Exercise.swift
1
enum CustomerError: Error {
2
case IllegalArgumentError
3
}
4
​
5
class Customer {
6
var SSN:String?
7
var age:Int?
8
​
9
func setSSN(ssn:String) throws {
10
if (ssn.characters.count < 10) {
11
throw CustomerError.IllegalArgumentError
12
}
13
self.SSN = ssn
14
}
15
​
16
func setAge(age:Int) throws {
17
if (age < 0) {
18
// Error with message
19
throw CustomerError.IllegalArgumentError
20
}
21
self.age = age
22
}
23
}
Copied!
The solution for this problem in Swift 5 can be implemented as follows:
Exercise.swift
1
enum CustomerError: Error {
2
case IllegalArgumentError
3
}
4
​
5
class Customer {
6
var SSN:String?
7
var age:Int?
8
​
9
func setSSN(ssn:String) throws {
10
if (ssn.count < 10) {
11
throw CustomerError.IllegalArgumentError
12
}
13
self.SSN = ssn
14
}
15
​
16
func setAge(age:Int) throws {
17
if (age < 0) {
18
// Error with message
19
throw CustomerError.IllegalArgumentError
20
}
21
self.age = age
22
}
23
}
Copied!
To check whether the student handled exception cases, you can use XCTAssertThrowsError. The following test class is checking exceptions.
Evaluate.swift
1
import XCTest
2
@testable import Base
3
​
4
class Evaluate: UMBaseTestCase {
5
var customer = Customer()
6
​
7
func testInvalidSSN() {
8
// Check if it raises exception for invalid Social Security Number
9
XCTAssertThrowsError(try customer.setSSN(ssn:"123"),
10
"You should throw IllegalArgumentError")
11
}
12
​
13
func testInvalidAge() {
14
// Check if it raises exception for negative age
15
XCTAssertThrowsError(try customer.setAge(age:-5),
16
"You should throw IllegalArgumentError")
17
}
18
}
Copied!
If you are using Swift 3, add the following snippet after that:
1
extension Evaluate {
2
static var allTests : [(String, (Evaluate) -> () throws -> Void)] {
3
return [
4
("testInvalidSSN", testInvalidSSN),
5
("testInvalidAge", testInvalidAge)
6
]
7
}
8
}
Copied!
You can also use a try / catch block to check whether an exception is thrown and call XCTFail if it is not.

Splitting the exercise in multiple files

For Swift 5 we support splitting the exercises in multiple files. You will still have to make a single evaluation file covering the tests cases you need, but you might have several separate test cases.
For example, if we have Solution with multiple files with classes that perform the simple arithmetic operations like subtraction and addition:
ExerciseAdd.swift
1
class AppAdd {
2
func add(a:Int, _ b:Int) -> Int {
3
return a + b
4
}
5
}
Copied!
and
ExerciseSub.swift
1
class AppSub {
2
func sub(a:Int, _ b:Int) -> Int {
3
return a - b
4
}
5
}
Copied!
Then you can have a single Evaluation File with multiple Test Cases EvaluateAdd and EvaluateSub:
Evaluate.swift
1
import XCTest
2
import Foundation
3
@testable import Base
4
​
5
class EvaluateAdd: UMBaseTestCase {
6
var appAdd: AppAdd!
7
​
8
override func setUp() {
9
super.setUp()
10
​
11
appAdd = AppAdd()
12
}
13
​
14
func testAddCheck() {
15
XCTAssertEqual(appAdd.add(a:1, 1), 2)
16
}
17
​
18
}
19
​
20
class EvaluateSub: UMBaseTestCase {
21
var appSub: AppSub!
22
​
23
override func setUp() {
24
super.setUp()
25
​
26
appSub = AppSub()
27
}
28
​
29
func testSubCheck() {
30
XCTAssertEqual(appSub.sub(a:5, 3), 2)
31
}
32
}
Copied!

UMBaseTestCase

Let's see all the details of the UMBaseTestCase class which is provided by Udemy to help you deal with reading outputs and entering inputs for student solutions.
UMBaseTestCase.swift
1
import XCTest
2
import Foundation
3
@testable import Base
4
​
5
class UMBaseTestCase: XCTestCase {
6
​
7
var savedStdOut:Int32!
8
var savedStdIn:Int32!
9
​
10
let stdInLogFile = "/eval/stdIn.log"
11
let stdOutLogFile = "/eval/stdOut.log"
12
​
13
var isStdOutRedirected:Bool!
14
var isStdInRedirected:Bool!
15
​
16
override func setUp() {
17
super.setUp()
18
isStdOutRedirected = false
19
isStdInRedirected = false
20
}
21
​
22
override func tearDown(){
23
super.tearDown()
24
if(isStdOutRedirected == true){
25
self.restoreStdOutToDefault()
26
}
27
if(isStdInRedirected == true){
28
self.restoreStdInToDefault()
29
}
30
}
31
​
32
// Redirect StandardInput in order to read from log file
33
func setStdInput(input:String){
34
do {
35
try input.write(toFile:stdInLogFile, atomically: true, encoding: String.Encoding.utf8)
36
} catch {
37
// failed to write file
38
}
39
isStdInRedirected = true
40
savedStdIn = dup(STDIN_FILENO)
41
freopen(stdInLogFile, "r", stdin)
42
}
43
​
44
// Redirect StandardOutput to log file
45
func prepareStdOut() {
46
isStdOutRedirected = true
47
savedStdOut = dup(STDOUT_FILENO)
48
freopen(stdOutLogFile, "w", stdout)
49
}
50
​
51
// Read from StandardOutput from log file
52
func getOutput()->String {
53
// Restore standartOutput
54
// This is important to restore to get Test results
55
self.restoreStdOutToDefault()
56
let content = try! String(contentsOfFile: stdOutLogFile, encoding: String.Encoding.utf8)
57
return content
58
}
59
​
60
private func restoreStdOutToDefault(){
61
isStdOutRedirected = false
62
fflush(stdout)
63
dup2(savedStdOut, STDOUT_FILENO)
64
close(savedStdOut)
65
}
66
​
67
private func restoreStdInToDefault(){
68
isStdInRedirected = false
69
dup2(savedStdIn, STDIN_FILENO)
70
close(savedStdIn)
71
}
72
}
Copied!
Previous
SQL
Last modified 1yr ago
Copy link
Contents
Basics
Testing outputs
Providing inputs
Testing exceptions
Splitting the exercise in multiple files
UMBaseTestCase