Apple App-Development-with-Swift-Certified-User App Development with Swift Certified User Exam Exam Practice Test

This question falls under View Building with SwiftUI , specifically the domain covering multi-view apps with navigation stacks, links, and sheets . The first blank must be NavigationLink because SwiftUI uses a navigation link inside a NavigationStack to push or present a destination view as part of the navigation hierarchy. Apple’s documentation states that people tap or click a NavigationLink to present a view inside a NavigationStack or NavigationSplitView. That matches the first code section, where tapping " Show Blue View " should navigate to BlueView().

The second blank must be .sheet because the code uses isPresented: $showRedView, which is the standard SwiftUI sheet modifier for modal presentation controlled by a Boolean binding. Apple documents sheet(isPresented:onDismiss:content:) as the modifier to use when you want to present a modal view when a Boolean becomes true. Since the button toggles showRedView, SwiftUI presents RedView() modally as a sheet.

So the completed structure is effectively:

NavigationLink( " Show Blue View " ) {

BlueView()

}

sheet(isPresented: $showRedView) {

RedView()

}

This directly aligns with SwiftUI navigation and modal presentation patterns in the App Development with Swift objective domains.

This question belongs to Swift Programming Language , specifically the objective on variable scope and shadowing .

The code first declares:

let even = 2

This creates a constant named even in the outer scope with the value 2.

Inside the for loop, the code declares another constant with the same name:

let even = num * 2

This inner even exists only inside the loop body. It shadows the outer even, which means that within the loop, the name even refers to the loop’s local constant, not the original one. However, that inner constant goes out of scope at the end of each loop iteration.

After the loop finishes, the inner even no longer exists. So when the final line runs:

print(even)

Swift uses the original outer constant, which is still 2.

So the output is:

2

This question tests two important Swift concepts:

Scope : where a variable or constant can be accessed

Shadowing : when a local declaration temporarily hides another declaration with the same name

Therefore, the correct answer is 2 .

This question belongs to View Building with SwiftUI , specifically the domain on extracting subviews to simplify the structure of an overlarge View .

When you create a custom SwiftUI view and add a stored property like:

let text: String

that property becomes part of the view’s initializer. Since the property name is text, Swift expects you to pass the value using the parameter label text: when creating the view. So the correct call is:

BigGreenTextView(text: " That ' s all folks " )

That makes B the correct answer.

Why the others are wrong:

A is incorrect because this is not using the expected parameter label.

C would only be correct if there were already another variable named text in the calling scope and you wanted to pass that variable instead of the literal string shown in the question.

D is incorrect because it omits the parameter label.

This is a standard SwiftUI pattern: extract reusable formatting into a separate custom View, give it an input property, and then pass the needed value through the initializer using the property label.

This question belongs to View Building with SwiftUI , especially the domain on creating multiple views to implement app logic and sharing values between views. In FirstView, the value typed into the TextField is stored in number, which is a String. When the NavigationLink is tapped, the code passes Int(number) ?? 0 into SecondView. In Swift, converting a string to an integer with Int(...) uses an optional initializer, which means it returns an optional value and will produce nil if the string cannot be converted. The ?? 0 nil-coalescing operator then supplies 0 if conversion fails.

Inside SecondView, the body is:

Color(passedNumber == 3 ? .blue : .red)

This uses the ternary conditional operator. If passedNumber equals 3, the displayed color is blue; otherwise, it is red. Therefore, entering 3 into the TextField causes Int(number) to become 3, which makes the condition passedNumber == 3 true and displays a blue canvas. Any other listed number results in red.

So the correct answer is A. 3 . This matches the SwiftUI pattern of taking user input, converting it to the needed type, passing it into another view, and rendering UI conditionally based on that value.

Comprehensive and Detailed Explanation From App Development with Swift domains:

This question belongs to View Building with SwiftUI , specifically the objective about extracting subviews to simplify the structure of an overlarge view . The correct answer is C because the standard SwiftUI approach to modularizing a large interface is to create a separate custom view, usually as a new struct conforming to View, and then use that view inside the main view. Apple’s tutorials and documentation repeatedly show this pattern: move part of the UI into its own SwiftUI view type, then compose the main screen from smaller view components.

Option A is not the primary SwiftUI pattern for extracting a reusable subview. Option B does the opposite of modularization, because it keeps everything in the same large body. Option D is about state management and data flow, not about extracting a visual component into its own reusable subview. Apple’s SwiftUI materials emphasize composition, where views are lightweight and can be split into smaller reusable pieces for clarity, maintainability, and reuse. WWDC guidance also shows Xcode’s “Extract Subview” workflow, which creates a separate view structure from selected UI code.

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.

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.

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.

Comprehensive and Detailed Explanation From App Development with Swift domains:

This question belongs to Xcode Developer Tools , especially the objectives about using the Xcode interface, building and running an app, and debugging. A is true because Xcode supports SwiftUI previews in the canvas, allowing you to see a view’s interface directly in Xcode without fully launching the entire app in the normal run workflow. Apple’s documentation states that Xcode can display a preview of a custom SwiftUI view in the preview canvas and keep it updated as you make code changes.

D is also true because when you run an app from Xcode on a device, Xcode opens a debugging session in the debug area. Apple explicitly documents that after a successful build, Xcode runs the app and opens a debugging session, which means you can view debug information while the app is running on the phone.

The other options are false. B is false because a phone does not have to be physically attached at all times; modern Xcode workflows support device pairing and wireless development after setup. C is false because Generic iOS Device is not an actual simulator run target for launching the app like a specific simulator device. E is false because you do not need a paid Apple Developer Program membership merely to run an app on your own device for development; Apple provides support for development testing on devices with the required setup such as pairing and Developer Mode.

This question belongs to View Building with SwiftUI , specifically the objective on positioning and laying out a single SwiftUI view with standard views and modifiers.

The correct answer is D because it uses the right combination of SwiftUI image modifiers for all three requirements:

the image is made resizable with .resizable()

it is given rounded corners with .clipShape(RoundedRectangle(cornerRadius: 50))

it displays the entire image with .aspectRatio(contentMode: .fit)

it is sized with .frame(width: 300)

The key part is .aspectRatio(contentMode: .fit) . In SwiftUI, .fit scales the image so the whole image remains visible inside the available frame. That matches the requirement “displays the entire image, regardless of size.” By contrast, .fill may crop part of the image, so options using .fill do not satisfy the requirement.

Why the others are wrong:

Option A uses .fill, so the full image may not remain visible.

Option B uses invalid modifiers such as .sizablc() and .size(width: 300), and also uses Rectangle(cornerRadius: 50), which is not the correct rounded-rectangle shape syntax.

Option C also uses invalid syntax and .fill, which can crop the image.

Option D uses valid SwiftUI syntax and the correct content mode.

So the correct choice is D , because it is the only option that correctly creates a 300-width image with rounded corners while ensuring the entire image is shown.

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.