App-Development-with-Swift-Certified-User Apple App Development with Swift Certified User Exam Free Practice Exam Questions (2026 Updated)

This question belongs to Swift Programming Language , specifically the domains covering control flow , loops , and range operators .

The code starts with:

var count = 0

var answer = 0

So both variables begin with the value 0.

In the first loop:

for index in 1...5 {

count = index

}

the closed range 1...5 includes 1, 2, 3, 4, and 5 . During each iteration, count is updated to the current value of index. After the loop finishes, the final value assigned to count is 5 .

Then the second loop runs:

for index in 1.. < count {

answer = index

}

Here, the half-open range 1.. < count means values starting at 1 up to, but not including , count. Since count is 5, this loop runs with index equal to 1, 2, 3, and 4 . Each time through the loop, answer is updated to the current index. After the last iteration, answer becomes 4 .

So the final value of answer is 4 . This question tests understanding of the difference between the closed range operator ... and the half-open range operator .. < , which is a key Swift control-flow concept.

This question belongs to View Building with SwiftUI , particularly the domain involving positioning and/or laying out a single SwiftUI view with standard views and modifiers . To place text on top of a shape such as a Capsule, SwiftUI uses the overlay modifier. Apple documents overlay as a view modifier that layers one view in front of another, which is exactly what is needed here: the text should appear on top of the blue capsule rather than beside or below it. The second blank must therefore be Text , because SwiftUI uses a Text view to display string content like " Great! " .

The completed code is:

struct ContentView: View {

var body: some View {

Capsule()

.fill(.blue)

.frame(width: 200.0, height: 100.0)

.overlay(

Text( " Great! " )

.font(.largeTitle)

)

}

}

This works because Capsule() creates the shape, .fill(.blue) gives it the blue color, .frame(width:height:) sets its size, and .overlay(...) places the Text( " Great! " ) directly above that shape. This is a standard SwiftUI composition pattern: build a base view, then apply modifiers to style it and layer additional content. In App Development with Swift objectives, this aligns with understanding standard views, modifiers, and layout techniques in SwiftUI.

This question belongs to Xcode Developer Tools , especially the objective on using debugging techniques including breakpoints and stepping controls .

When execution stops at a breakpoint on line 3, Step Over runs that line without entering into another function call, so it is the correct action for moving past line 3 while staying in the current function. Step Into is used when execution reaches line 4 and you want to enter the display(numbers) function, which takes you into the function body starting at line 8. Once inside that function, Step Out continues execution until the current function returns, which is exactly what “step out from line 8” means.

Deactivate breakpoints turns breakpoint handling off so the debugger no longer stops on active breakpoints. Continue program execution resumes the app until the next breakpoint or until the program finishes.

So the correct control order is:

1 = Continue

2 = Deactivate breakpoints

3 = Step Over

4 = Step Into

5 = Step Out

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 objectives covering arrays , loops , and range operators . The array has 6 elements, so menuItems.count is 6. The loop uses the half-open range operator:

for index in 1.. < (menuItems.count - 1)

That becomes:

for index in 1.. < 5

In Swift, the half-open range operator a.. < b includes the lower bound but does not include the upper bound. So this loop runs with index values 1, 2, 3, 4, not 0 and not 5.

Array subscripting uses those indexes to print:

menuItems[1] → " Burger "

menuItems[2] → " Chicken "

menuItems[3] → " Pasta "

menuItems[4] → " Salad "

That means " Pizza " at index 0 is skipped, and " Steak " at index 5 is also skipped. Swift arrays use zero-based indexing, and count returns the number of elements in the array.

Therefore, the program prints only " Burger " , " Chicken " , " Pasta " , and " Salad " , so the correct answer is A .

Comprehensive and Detailed Explanation From App Development with Swift domains:

This question belongs to View Building with SwiftUI , specifically the objective about using property wrappers such as @State, @Binding, and @Environment to manage and share data between views.

The correct answer is @Environment because it is used to read values provided by the system or the surrounding view environment. These values can include device-related or system-provided information such as size classes, color scheme, locale, and dismiss actions. In SwiftUI, @Environment gives a view access to contextual information that it does not own directly, but which is supplied by the framework or ancestor views.

The other options are not correct for this purpose:

@State is used for local mutable state owned by the current view.

@Binding is used to create a two-way connection to state owned elsewhere, usually in a parent view.

@StateObject is used to create and own an observable reference-type object for the lifetime of the view.

So if you want a SwiftUI view to read data coming from system or device settings, the correct property wrapper is @Environment .

This question belongs to Swift Programming Language , especially the domains covering control flow , loops , logical operators , and guard . The loop runs through 0.. < max, and since max = 101, the values of num are 0 through 100. Inside the loop, the guard statement keeps only values that satisfy both conditions:

num % 5 == 0 → the number must be divisible by 5

num % 2 != 0 → the number must be odd

So the code counts numbers from 0 to 100 that are odd multiples of 5 . Those values are:

5, 15, 25, 35, 45, 55, 65, 75, 85, 95

That gives a total of 10 numbers. Therefore count becomes 10, and the printed output is:

Total count: 10

The key Swift concept here is that guard ... else { continue } skips any loop iteration that does not meet the required condition. Only matching values reach count += 1. This is a standard use of guard for early exit and of the remainder operator % for divisibility checks. Therefore, the correct answer is B .

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 , especially the domains covering basic Swift types , operators , and constants versus variables .

There are two compile problems in the snippet. First, unitPrice and shipping are inferred as Double, while quantity is inferred as Int. In Swift, arithmetic operands must have compatible types; Swift does not automatically mix Int and Double in one arithmetic expression. So unitPrice * quantity fails unless quantity is changed to Double or explicitly converted. That makes A a correct fix.

Second, the line totalCost += ... uses the compound assignment operator +=, which stores a new value back into the left-hand side. Swift requires the left-hand side of += to be mutable, so totalCost must be declared with var, not let. That makes D the second correct fix.

The other choices do not solve the actual compile issues. B is unnecessary because totalCost is already explicitly declared as Double, so 0 is valid there. C would still leave shipping as Double, so the mixed-type arithmetic problem remains. E is irrelevant because shipping is never reassigned. Therefore, the two correct answers are A and D

This question belongs to View Building with SwiftUI , specifically stacking views and applying modifiers. A ZStack layers views from back to front, so the first item becomes the background and later items appear on top. To match the screenshot, the black background must be the back layer, so Color.black goes first. The large white circle sits above that, so Circle() followed by .foregroundStyle(.white) comes next. Finally, the red heart image sits on top of the circle, so Image(systemName: " heart " ).resizable() followed by .foregroundStyle(.red).frame(width: 200, height: 200) must be last. SwiftUI’s Image.resizable() allows the symbol image to scale to the frame you apply, and foregroundStyle sets the visible color styling for the shape and symbol.

So the intended structure is:

ZStack {

Color.black

Circle()

.foregroundStyle(.white)

Image(systemName: " heart " ).resizable()

.foregroundStyle(.red)

.frame(width: 200, height: 200)

}

This produces a black background, a white circular shape, and a centered red heart on top, exactly as shown.

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.