App-Development-with-Swift-Certified-User App Development with Swift Certified User Exam Questions and Answers

This question belongs to View Building with SwiftUI , especially the objective domain on using List views to iterate through collections and displaying model data in SwiftUI. In the code, animals is the data source passed into List(animals) { animal in ... }. That closure iterates through each element of the collection one at a time, and the parameter animal represents the current Animal instance for that row. To show the name of the current animal in the UI, the correct statement is Text(animal.name). SwiftUI’s list documentation explains that each row inside a List must be a SwiftUI View, and a Text view is a standard way to display a string value for each item in the collection.

Option D is therefore correct because it accesses the name property of the current animal object being processed by the List closure. This is the standard SwiftUI pattern when iterating over identifiable model objects: pass the collection into List, receive each item in the closure, and build a row view from that item’s properties. Apple’s SwiftUI tutorials repeatedly use this collection-driven row-building pattern for lists and navigation.

The other options are incorrect for clear reasons. A incorrectly refers to the type name Animal instead of the current instance. B uses Animals with the wrong identifier and an invalid indexing approach. C also treats animal as an index rather than the current element object. Since the closure already gives you the current Animal, you directly access its property with animal.name.

This question belongs to Swift Programming Language , specifically the domain covering structs, classes, properties, methods, and the difference between structures and classes .

The key point is that Printer is declared as a class :

class Printer {

var copies: Int

init(copies: Int) {

self.copies = copies

}

}

In Swift, classes are reference types . That means when you assign one class instance to another variable, both variables refer to the same object in memory rather than creating a separate copy. Apple’s Swift language guide explains that classes are passed by reference, while structures are value types. So in this code:

var printer1 = Printer(copies: 2)

var printer2 = printer1

both printer1 and printer2 point to the same Printer instance.

Next, this line changes the shared object:

printer2.copies = 10

Because printer2 refers to the same instance as printer1, changing printer2.copies also changes printer1.copies. Therefore, when the code executes:

print(printer1.copies)

the output is 10 .

This question tests one of the most important Swift concepts: classes are reference types , while structs are value types . If Printer had been a struct instead of a class, the result would have been different because assignment would copy the value rather than share the same instance.

This question belongs to Swift Programming Language , specifically the domain covering basic Swift types and how Swift handles enumerations . The code defines an enum named CompassPoint with the cases north, south, east, and west, and then declares direction as type CompassPoint. In Swift, an enum case can be assigned using the fully qualified form CompassPoint.north, so B is valid. Swift also allows the shorthand form .north when the compiler already knows the expected type is CompassPoint, so D is also valid. Apple’s Swift language documentation explains that once a variable is known to be of a specific enumeration type, you can set its value using the shorter dot syntax.

The other options are not allowed. A is invalid because enum cases are not assigned using constructor-style syntax like CompassPoint(north). C is invalid because north by itself is not enough unless it is written with dot shorthand in a context with inferred enum type. E is invalid because north is a case of the enum type, not a member accessed from the variable instance as direction.north. Swift enum cases are referenced from the enum type or by shorthand dot syntax, not as instance properties.

This question belongs to View Building with SwiftUI , specifically the domain on creating a multi-view app with navigation stacks, links, and sheets .

To present a modal view in SwiftUI when a Boolean state changes, the correct modifier is .sheet . The matching sheet API for a Boolean binding is:

sheet(isPresented: $showInfo) {

// modal content

}

So the first blank must be .sheet , and the second blank must be (isPresented: .

The logic works like this:

@State stores the local Boolean that controls presentation.

Pressing the button calls showInfo.toggle(), changing the value from false to true.

When that Boolean becomes true, the .sheet(isPresented:) modifier presents the modal view.

When the modal is dismissed, SwiftUI updates the Boolean back as needed.

There is also a typing issue in the screenshot: the state variable appears as ShowInfo, while the button and binding use showInfo. Swift is case-sensitive, so those names must match. The corrected code should use the same identifier consistently, such as:

@State var showInfo = false

Therefore, the correct dropdown selections are:

sheet

(isPresented:

This question belongs to Swift Programming Language , specifically the objective covering structs, properties, and initializers .

In the struct, both the property and the initializer parameter are named age:

struct person {

var age: Int

init(age: Int) {

self.age = age

}

}

Here, age inside the initializer could refer to either the property of the struct or the parameter passed into the initializer. Swift uses self.age to clearly mean the property that belongs to the current instance , while plain age refers to the initializer parameter . So self.age = age means: assign the parameter value to the instance property.

That is why C is correct. The keyword self is required here to remove ambiguity between two identifiers with the same name.

The other options are incorrect:

A is wrong because self here is not pointing to the parameter; it points to the instance property.

B is wrong because self is not always required in every initializer assignment. It is specifically needed here because of the naming conflict.

D is wrong because whether the property has a default value is not the reason self is needed in this example.

So the correct answer is C. self is needed to distinguish between the property and the parameter with the same name.

age — Variable

birthDate — Constant

socialSecurityNumber — Constant

salary — Variable

currentDepartment — Variable

This question belongs to Swift Programming Language , specifically the objective on demonstrating when to use constants and variables . In Swift, a constant is declared with let and is used for values that should not change after they are set. A variable is declared with var and is used for values that may change over time.

Birth date is a constant because a person’s date of birth does not change. Social security number is also a constant because it is intended to be a fixed identifier for that employee record. By contrast, age is a variable because it changes over time. Salary is a variable because compensation can be adjusted. Current department is also a variable because an employee may transfer to another department.

This matches Swift best practice: use let for fixed data and var for mutable data. So in a human resources record, identifiers that are permanent should be constants, while values that can change during employment should be variables.

This question belongs to Xcode Developer Tools , specifically the objective on using debugging techniques including breakpoints, watchpoints, and logging to resolve errors . A watchpoint monitors a variable or memory location during a debugging session, so you first need the program to stop while being debugged. That is why the correct order begins with setting a breakpoint and then running the code so execution pauses at a useful point. Apple’s debugging guidance describes debugging as something done at runtime using the debugger, and LLDB’s watchpoint documentation explains that watchpoints are part of the debugger workflow rather than something you set before the program is stopped.

Once execution is paused, you use the debug area to inspect the current variables. After locating the variable you want to monitor, you right-click the variable and select Watch to create the watchpoint. This sequence is consistent with how Xcode and LLDB expose watchpoint functionality during an active debug session. LLDB also describes watchpoints as objects you create to stop execution when a watched value changes, which only makes sense after the debugger has access to the running program state.

RedCircleView()

GreenTriangleView()

BlueSquareView()

BlueSquareView()

GreenTriangleView()

This question belongs to View Building with SwiftUI , specifically arranging views with HStack , VStack , and ZStack . In SwiftUI, an HStack lays views out horizontally, a VStack lays them out vertically, and a ZStack overlays views front-to-back. Apple’s stack layout guidance describes these three containers exactly this way.

To match the canvas, the main HStack must show three items from left to right: a red circle , a green triangle , and then a right-side vertical group. That means the first two blanks inside HStack are RedCircleView() and GreenTriangleView(). On the right side, the VStack shows a blue square on top, so the next blank is BlueSquareView(). Under that, the lower-right shape is made by layering a green triangle on top of a blue square , which means the ZStack must contain BlueSquareView() first as the background and GreenTriangleView() second as the foreground. SwiftUI’s documentation notes that ZStack aligns and overlays its children in depth order, which is why the square goes before the triangle.

So the correct placement order is:

HStack {

RedCircleView()

GreenTriangleView()

VStack {

BlueSquareView()

ZStack {

BlueSquareView()

GreenTriangleView()

}

}

}

That arrangement reproduces the exact layout shown in the canvas.

You can treat a NavigationLink like a button, and run some Swift code when it is pressed. — False

NavigationSplitView can be used to do navigation differently on different device sizes. — True

You can put a header on your present View in a NavigationStack using .navigationTitle. — True

If you have a NavigationLink that goes to another View with a NavigationLink, you need to declare a NavigationStack at each level. — False

This question belongs to View Building with SwiftUI , specifically the objective on creating a multi-view app with navigation stacks, links, and sheets . Statement 1 is False because NavigationLink is primarily a navigation control that pushes or presents a destination in a navigation container; Apple documents it as creating a navigation link that presents a destination, not as a general-purpose action control like Button.

Statement 2 is True because NavigationSplitView is designed for adaptive navigation and can present navigation in different ways depending on platform and available space. Apple documents NavigationSplitView as a container for navigation across multiple columns, and this adaptive behavior is exactly why it is used differently across device sizes.

Statement 3 is True because .navigationTitle(...) sets the navigation title for a view shown inside a navigation container. Apple explicitly describes a view’s navigation title as something used to visually display the current navigation state of an interface.

Statement 4 is False because you do not need a separate NavigationStack at every level. Apple describes NavigationStack as the container that manages a stack of views, and NavigationLink pushes additional destinations onto that stack. Nested destinations can keep navigating within the same stack.