Gosu Bundle Transactions
Given the following code sample: var newBundle = gw.transaction.Transaction.newBundle() var targetCo = gw.api.database.Query.make(ABCompany) targetCo.compare(ABCompany#Name, Equals, "Acme Brick Co.") var company = targetCo.select().AtMostOneRow company.Notes = "TBD" Following best practices, what two items should be changed to create a bundle and commit this data change to the database? (Select two)
A. End with newBundle.commit()
B. Add Notes to the bundle
C. Add targetCo to the bundle
D. Add company to the bundle
E. Add runWithNewBundle(\newBundle -> { to the first line
Answer Option (Which option is correct) A. End with newBundle.commit()
Answer Option (Which option is correct) D. Add company to the bundle
Explanation:
A queried entity must be placed in a writable bundle before it is modified. Add the entity rather than the Query object or an individual property. A managed runWithNewBundle block handles its transaction boundary; a manually created bundle requires an explicit commit after the intended changes.
Why the other options are incorrect:
B. Add Notes to the bundle:
Notes is a property on the company. It is not the entity that must become writable. Move the company into the bundle before setting Notes.
C. Add targetCo to the bundle:
targetCo is the query builder. It does not represent the returned company record. Adding it cannot make the record writable.
E. Add runWithNewBundle(\newBundle -> { to the first line:
A managed block is an alternative transaction strategy. The provided code creates a manual bundle. Simply adding this fragment would leave an incomplete rewrite.
References:
Guidewire-authored PolicyCenter 10.1.2 - Bundle transactions
According to best practices, which two requirements should be implemented using a Pre-Update Rule? (Select two)
A. Update the address details on all currently unissued checks associated with a Contact when that Contact's address is changed.
B. Initiate an asynchronous background workflow process after a Claim has been committed to the database.
C. Create a transactional audit entry that captures both the prior value and the new value immediately before committing a change to a specific field.
D. Automatically determine the optimal adjuster to handle a newly reported loss.
Answer Option (Which option is correct) A. Update the address details on all currently unissued checks associated with a Contact when that Contact's address is changed.
Answer Option (Which option is correct) C. Create a transactional audit entry that captures both the prior value and the new value immediately before committing a change to a specific field.
Explanation:
A Pre-Update rule can detect a changed entity field and perform related transactional changes before the update commits. This is suitable for recording update metadata, creating an audit entry, or creating a related activity and history record. Assignment and post-commit asynchronous processing serve different stages of the lifecycle.
Why the other options are incorrect:
B. Initiate an asynchronous background workflow process after a Claim has been committed to the database:
The event is specified to occur after commit. A Pre-Update rule belongs before that boundary. Use the appropriate post-commit mechanism for asynchronous work.
D. Automatically determine the optimal adjuster to handle a newly reported loss:
Selecting an adjuster is an assignment concern. It differs from synchronizing a changed field before persistence. The question selects transactional update and auditing tasks.
References:
Guidewire - Business logic and pre-update rules
Guidewire-authored PolicyCenter 10.1.2 - Rules and validation signatures
Which two are capabilities of the Guidewire Profiler? (Select two)
A. Track where time is spent in Guidewire application code
B. Measure network latency between the database server and application server
C. Measure network latency between the browser and application server
D. Provide timing information of application calls to external services
E. Track time spent in the web browser
Answer Option (Which option is correct) A. Track where time is spent in Guidewire application code
Answer Option (Which option is correct) D. Provide timing information of application calls to external services
Explanation:
The Guidewire Profiler measures application-side execution, including UI requests and other server entry points such as batch processing. It can help identify time spent in application code and external-service calls. Browser-only timing and independent network-latency measurements are different diagnostic concerns.
Why the other options are incorrect:
B. Measure network latency between the database server and application server:
The profiler can time application calls to the database. That is not an isolated measurement of network latency. Database processing and other waiting time can contribute.
C. Measure network latency between the browser and application server:
Browser-to-server transport occurs outside the server-side timing window. The application profiler does not isolate that network delay. A client or network measurement is needed.
E. Track time spent in the web browser:
The web profiler captures server-side processing. It does not measure the browser execution itself. Client timing requires a separate tool.
References:
Guidewire-authored PolicyCenter 10.1.2 - Web and entry-point profilers
There is a requirement for an additional filter on Desktop Activities. The filter requires a complex query. Which option will meet the requirement and follow best practices?
A. Use a Gosu query with a "where" clause to find the needed rows, then pass the results to the filter.
B. Use a "for" loop with an "if" statement to find the needed rows, then pass the results to the filter.
C. Create a function using a Gosu query and a subselect clause, then call that function from the filter property.
D. Create a function using a Gosu query and compare clauses, then call that function from the filter property.
Answer Option (Which option is correct) C. Create a function using a Gosu query and a subselect clause, then call that function from the filter property.
Explanation:
Apply query predicates and sorting in the database before selecting or materializing results. Query-backed list filters should refine the query rather than hide already-loaded rows or filter a large collection in application memory. This reduces unnecessary data transfer and entity loading.
Verification note: The exact option selection could not be independently verified from accessible official documentation. Relevant official topic links are provided, but some exact configuration or training rules require the product Configuration Guide or Cloud Standards behind sign-in. The source key is retained.
Why the other options are incorrect:
A. Use a Gosu query with a "where" clause to find the needed rows, then pass the results to the filter:
A collection where filter can run after selection. That may load rows which will later be discarded. The complex filter should refine the query itself.
B. Use a "for" loop with an "if" statement to find the needed rows, then pass the results to the filter:
A for loop and if check filter loaded records. They do not restrict the SQL result. The database should perform the qualifying selection.
D. Create a function using a Gosu query and compare clauses, then call that function from the filter property:
compare clauses can express many valid filters. The source has not described the complex predicate in enough detail. Excluding this alternative requires the missing query requirements.
References:
Guidewire - Query-backed collections and buildBaseQuery
An insurer wants to add a new typecode for a loan account to a base typelist, BankAccountType, that has not been extended. Which step must a developer take to perform this task following best practices?
A. Create a BankAccountType.ttx file and add a new typecode LoanAccount_Ext.
B. Create a BankAccountType.ttx file and add a new typecode LoanAccount.
C. Open the BankAccountType.tti and add a new typecode LoanAccount.
D. Create a BankAccountType_Ext.tti file and add a new typecode LoanAccount.
Answer Option (Which option is correct) A. Create a BankAccountType.ttx file and add a new typecode LoanAccount_Ext.
Explanation:
An existing typelist is extended through its .ttx file, creating that extension file when necessary. A new standalone typelist uses .tti instead. Updating the delivered .tti file or generated Java code is not the extension mechanism.
Verification note: The exact option selection could not be independently verified from accessible official documentation. Relevant official topic links are provided, but some exact configuration or training rules require the product Configuration Guide or Cloud Standards behind sign-in. The source key is retained.
Why the other options are incorrect:
B. Create a BankAccountType.ttx file and add a new typecode LoanAccount:
The extension file name is appropriate. The new code lacks the custom suffix selected by the PDF. Naming must distinguish the base-list addition.
C. Open the BankAccountType.tti and add a new typecode LoanAccount:
Modifying the tti edits the delivered typelist. The requirement calls for an extension. The separate ttx file preserves the base definition.
D. Create a BankAccountType_Ext.tti file and add a new typecode LoanAccount:
This defines another typelist under a different name. It does not extend BankAccountType itself. The loan code must belong to the existing list.
References:
Guidewire - Typelist definition file kinds
Guidewire Cloud Standards - Sign-in required
Which statement is true about the Project Release branch for an implementation using Git?
A. It stores the current production code and is updated whenever the production system is updated
B. It is used by the implementation team to develop code for a specific release
C. It is used by the implementation team to stabilize the code for a specific release
D. It contains product releases from Guidewire
Answer Option (Which option is correct) C. It is used by the implementation team to stabilize the code for a specific release
Explanation:
A mainline contains ongoing development across releases, whereas a project release branch is used to stabilize a particular release. Production and product-release branches represent other states in the branching model. Branch responsibilities should not be confused with the immutable snapshot represented by a commit.
Verification note: The exact option selection could not be independently verified from accessible official documentation. Relevant official topic links are provided, but some exact configuration or training rules require the product Configuration Guide or Cloud Standards behind sign-in. The source key is retained.
Why the other options are incorrect:
A. It stores the current production code and is updated whenever the production system is updated:
This describes the deployed production state. A release stabilization branch serves an earlier stage. The two branch responsibilities are distinct.
B. It is used by the implementation team to develop code for a specific release:
Active feature development may precede release stabilization. The PDF assigns the release branch to stabilization. Its exact branch policy still requires course confirmation.
D. It contains product releases from Guidewire:
A vendor product-release branch contains a different source lineage. The implementation team release branch contains customer changes. Do not equate those branch roles.
References:
Guidewire - Source repository and build promotion
Git project - Commits and branch references
Guidewire - TeamCity builds and dependencies
Given the following query: uses gw.api.database.Query var query = Query.make(Claim) query.compare(Claim#ClaimNumber, Equals, "123-45-6789") var claim = query.select().AtMostOneRow Which follows the best practice to find the urgent open activities of the claim, considering the memory usage and bundle size?
A. var activityQuery = gw.api.database.Query.make(Activity)
activityQuery.compare(Activity#Status, Equals, TC_OPEN)
activityQuery.compare(Activity#Claim, Equals, claim)
var urgentActivities = activityQuery.select().where(\ activity -> activity.Priority == TC_URGENT)
B. var urgentActivities = claim.Activities.where(\ activity -> activity.Priority == Priority.TC_URGENT and activity.Status == TC_OPEN)
C. var urgentActivities = claim.Activities.where(\ activity -> activity.Status == TC_OPEN).where(\ activity -> activity.Priority == TC_URGENT)
D. var activityQuery = gw.api.database.Query.make(Activity)
activityQuery.compare(Activity#Priority, Equals, Priority.TC_URGENT)
activityQuery.compare(Activity#Status, Equals, TC_OPEN)
activityQuery.compare(Activity#Claim, Equals, claim)
var urgentActivities = activityQuery.select()
Answer Option (Which option is correct) D. var activityQuery = gw.api.database.Query.make(Activity)
activityQuery.compare(Activity#Priority, Equals, Priority.TC_URGENT)
activityQuery.compare(Activity#Status, Equals, TC_OPEN)
activityQuery.compare(Activity#Claim, Equals, claim)
var urgentActivities = activityQuery.select()
Explanation:
Apply query predicates and sorting in the database before selecting or materializing results. Query-backed list filters should refine the query rather than hide already-loaded rows or filter a large collection in application memory. This reduces unnecessary data transfer and entity loading.
Why the other options are incorrect:
A. var activityQuery = gw.api.database.Query.make(Activity)
activityQuery.compare(Activity#Status, Equals, TC_OPEN)
activityQuery.compare(Activity#Claim, Equals, claim)
var urgentActivities = activityQuery.select().where(\ activity -> activity.Priority == TC_URGENT):
The priority predicate is applied after select. That can load nonurgent activities before discarding them. Place all three constraints in the query.
B. var urgentActivities = claim.Activities.where(\ activity -> activity.Priority == Priority.TC_URGENT and activity.Status == TC_OPEN):
Navigating claim Activities loads the relationship collection. where then filters it in application memory. A constrained activity query avoids that broad collection load.
C. var urgentActivities = claim.Activities.where(\ activity -> activity.Status == TC_OPEN).where(\ activity -> activity.Priority == TC_URGENT):
Two successive where calls still filter after traversal. They do not push those predicates into SQL. The urgent and open conditions belong before selection.
References:
Guidewire - Query-backed collections and buildBaseQuery
Which statement is correct and recommended for writing GUnit tests?
A. Use the init() method to set up objects shared by all tests in a test class
B. Handle any exceptions thrown by test methods in the finally() method
C. Clear all instance variables of completed test in the tearDown() method
D. Use fluent assertions over conventional assert statements
Answer Option (Which option is correct) A. Use the init() method to set up objects shared by all tests in a test class
Explanation:
A GUnit test needs an appropriate test base class and a valid test lifecycle. Tests that execute Gosu database queries need a server-capable environment. Test method naming and shared setup should follow the conventions of the target Guidewire release.
Verification note: The source selects init(), but the release-specific setup lifecycle is not supplied. Other listed practices may also be valid; verify against the GUnit training version.
Why the other options are incorrect:
B. Handle any exceptions thrown by test methods in the finally() method:
finally is a language cleanup construct rather than the named GUnit test lifecycle. It is not a catch handler. The proposed exception-handling advice is misleading.
C. Clear all instance variables of completed test in the tearDown() method:
tearDown is associated with post-test cleanup. Clearing shared state can be appropriate in a test framework. The PDF provides no release-specific rule that confidently excludes it.
D. Use fluent assertions over conventional assert statements:
Fluent assertions can produce readable test failures. Their availability depends on the test libraries used. The source does not establish why this recommendation must be rejected.
References:
Guidewire-authored PolicyCenter 10.1.2 - GUnit Testing Guide
Succeed Insurance needs to extend the contact functionality to support tracking agency information. The new agency entity should have all of the fields of ABCompany, but include fields that are specific to the agency. Following best practices, which of the following options would implement this requirement?
A. A new foreign key should be added to ABCompany that points to a new Agency_Ext entity. The new fields should be added to the new Agency entity.
B. A new Agency_Ext entity should be added so that ABCompany becomes a subtype of Agency_Ext. The new fields should be added to the new Agency entity.
C. A new array should be added to ABCompany that points to a new Agency_Ext entity. The new fields should be added to the new Agency_Ext entity, including a foreign key pointing back to ABCompany.
D. Add a new Agency subtype of ABCompany. The new fields should be added to the new Agency_Ext subtype.
Answer Option (Which option is correct) D. Add a new Agency subtype of ABCompany. The new fields should be added to the new Agency_Ext subtype.
Explanation:
A specialized contact should be represented as a subtype of the closest applicable existing entity. The subtype inherits the common fields and adds only the fields specific to that contact kind. A scalar flag or a separately linked entity does not provide the same inheritance relationship.
Why the other options are incorrect:
A. A new foreign key should be added to ABCompany that points to a new Agency_Ext entity. The new fields should be added to the new Agency entity:
A foreign key establishes a linked record. It does not make Agency inherit ABCompany fields. The requirement describes an agency subtype.
B. A new Agency_Ext entity should be added so that ABCompany becomes a subtype of Agency_Ext. The new fields should be added to the new Agency entity:
Making ABCompany the child reverses the requested inheritance. An agency is a specialized company. The base company should remain the parent.
C. A new array should be added to ABCompany that points to a new Agency_Ext entity. The new fields should be added to the new Agency_Ext entity, including a foreign key pointing back to ABCompany:
An array introduces multiple related agency records. The question instead asks for the agency to inherit company fields. A subtype expresses that relationship directly.
References:
Guidewire - Custom entity and subtype data model examples
Given this function: 929 public function checkConnection() { 930 try 931 { 932 var conn = DriverManager.getConnection(url) 933 // logic here 934 } 935 catch (e : Exception) 936 { 937 // handle exception 938 } 939 } What action will align the function with Gosu best practices?
A. Move left curly braces on lines 931, 934, and 936 to the end of the previous lines
B. Change line 935 to read 'catch {e: Exception)'
C. In line 933, change DriverManager to driver Manager (camel case)
D. Add a comment for lines with significant code (specifically, lines 933 and 937)
Answer Option (Which option is correct) A. Move left curly braces on lines 931, 934, and 936 to the end of the previous lines
Explanation:
Gosu declarations must use valid parameter and return types, meaningful names, and the expected naming conventions. Function names use lower camel case. A declared return type is a type such as Decimal, not the name of the incoming value.
Verification note: Option A refers to left braces on lines 931, 934, and 936, but line 934 contains a right brace. The source line reference is inconsistent.
Why the other options are incorrect:
B. Change line 935 to read 'catch {e: Exception)':
The proposed catch text mixes braces and parentheses. It is not a valid correction of the shown exception parameter. The existing parameter declaration should remain intact.
C. In line 933, change DriverManager to driver Manager (camel case):
DriverManager is a declared class name. Changing its capitalization or inserting a space changes the identifier. Naming style does not authorize renaming a library type.
D. Add a comment for lines with significant code (specifically, lines 933 and 937):
Comments can clarify significant logic. They do not resolve the displayed brace-format issue. The source also needs its line-number reference corrected.
References:
Guidewire-authored PolicyCenter 10.1.2 - Gosu naming and declarations
Gosu language project - Operators, loops, functions, and properties
Which logging statement follows best practice?
A. if(_logger.InfoEnabled) { _logger.debug("Adding '${contact.PublicID}' to ContactManager") }
B. _logger.error(DisplayKey.get("Web.ContactManager.Error.GeneralException", e.Message))
C. if(_logger.DebugEnabled) { _logger.debug(logPrefix + someReallyExpensiveOperation()) }
D. _logger.info(logPrefix + "[Address#AddressLine1=" + address.AddressLine1 + "] [Address#City" + address.City + "] [Address#State" + address.State + "]")
Answer Option (Which option is correct) C. if(_logger.DebugEnabled) { _logger.debug(logPrefix + someReallyExpensiveOperation()) }
Explanation:
Guard an expensive debug-message expression with the matching DebugEnabled check. That prevents the expensive operation from running when debug logging is disabled. Include useful diagnostic context and avoid excessive output or unmasked personal information.
Why the other options are incorrect:
A. if(_logger.InfoEnabled) { _logger.debug("Adding '${contact.PublicID}' to ContactManager") }:
The guard checks the info level. The actual call writes at debug level. Those levels can be enabled differently.
B. _logger.error(DisplayKey.get("Web.ContactManager.Error.GeneralException", e.Message)):
DisplayKey creates localized interface text. The proposal does not demonstrate stable diagnostic context or controlled exception handling. The guarded expensive debug call is the stronger listed choice.
D. _logger.info(logPrefix + "[Address#AddressLine1=" + address.AddressLine1 + "] [Address#City" + address.City + "] [Address#State" + address.State + "]"):
The log records a street address and location. Those values can identify a person. The message should avoid exposing clear-text address data.
References:
Apache Log4j - Disabled logging and expensive message construction
Guidewire Security - Logging sensitive information
According to the training, which application in Guidewire Home is used to configure custom quality gates for pre-merge or pre-promotion stages within the GWCP pipeline? (Select Two)
A. Storage Access
B. Repository Settings
C. CI/CD Manager
D. Quality Gates
E. Build Promotion
F. Automated Builds
Answer Option (Which option is correct) C. CI/CD Manager
Answer Option (Which option is correct) D. Quality Gates
Explanation:
Official documentation names the Quality Gates app and the CI/CD Manager API for managing custom gates. It does not establish a separate CI/CD Manager app as worded in option C. Because the prompt asks for two applications, its original C,D key is retained with an ambiguity flag.
Verification note: The prompt asks which application, yet says Select Two and supplies two app names. Verify the release-specific Guidewire Home workflow.
Why the other options are incorrect:
A. Storage Access:
Storage Access controls storage credentials and permissions. It does not evaluate custom pipeline gates. The topic is quality checks before progression.
B. Repository Settings:
Repository Settings configures source repositories. It is not the named custom-gate management interface. The API and Quality Gates app are documented separately.
E. Build Promotion:
Build Promotion uses gate status when promoting. It does not replace the custom-gate creation workflow. Creating and consuming a gate are different tasks.
F. Automated Builds:
Automated builds run pipeline work. That name does not identify the documented custom-gate configuration tool. The requested two-app wording remains ambiguous.
References:
Guidewire - Custom quality gates and CI/CD Manager API
| Page 3 out of 13 Pages |
| 1234 |
| InsuranceSuite-Developer Practice Test Home |
Real-World Scenario Mastery: Our InsuranceSuite-Developer practice exam don't just test definitions. They present you with the same complex, scenario-based problems you'll encounter on the actual exam.
Strategic Weakness Identification: Each practice session reveals exactly where you stand. Discover which domains need more attention, before Associate Certification - InsuranceSuite Developer - Mammoth Proctored Exam exam day arrives.
Confidence Through Familiarity: There's no substitute for knowing what to expect. When you've worked through our comprehensive InsuranceSuite-Developer practice exam questions pool covering all topics, the real exam feels like just another practice session.
Copyright © All Rights Reserved