Microsoft MB2-701 Practice Test Questions, Microsoft MB2-701 Exam Dumps

Passing the IT Certification Exams can be Tough, but with the right exam prep materials, that can be solved. ExamLabs providers 100% Real and updated Microsoft MB2-701 exam dumps, practice test questions and answers which can make you equipped with the right knowledge required to pass the exams. Our Microsoft MB2-701 exam dumps, practice test questions and answers, are reviewed constantly by IT Experts to Ensure their Validity and help you pass without putting in hundreds and hours of studying.

Dynamics CRM Extensibility Foundations for the MB2-701 Exam

The Extending Microsoft Dynamics CRM 2013 exam, known by the code MB2-701, was a specialist-level certification from Microsoft. It was designed to validate the skills of developers and technical consultants who customize and extend the Dynamics CRM platform to meet specific business requirements. This exam was not for beginners; it was targeted at professionals with a solid background in .NET development and a foundational understanding of the Dynamics CRM application. It was a key credential for any developer working in the Dynamics ecosystem.

Passing the MB2-701 Exam signified that a developer could move beyond simple point-and-click customizations and write code to create powerful, tailored business solutions. The certification demonstrated expertise in both client-side scripting to enhance the user interface and server-side code to implement complex business logic. The exam's focus on the core extensibility points of the platform, such as plug-ins and web services, ensured that a certified professional had the foundational knowledge needed to build robust and scalable applications on the Dynamics CRM platform, making the skills tested in the MB2-701 Exam highly valuable.

The Dynamics CRM 2013 Platform for Developers

To succeed on the MB2-701 Exam, you must first understand that Dynamics CRM is more than just a customer relationship management application; it is a powerful development platform. This concept is often referred to as xRM, where the "x" stands for anything. It means you can use the CRM platform's framework of entities, relationships, and web services to build almost any kind of line-of-business application, not just traditional sales, service, or marketing solutions.

The architecture is metadata-driven, meaning that the structure of the entities, forms, and views is stored in a database and can be modified. All interactions with the platform, whether from the user interface or from custom code, go through a secure web services layer. For the MB2-701 Exam, a developer must also master the solution framework. Solutions are the containers used to package all your customizations and extensions, allowing you to move them from a development environment to a testing or production environment in a controlled manner.

Navigating the MB2-701 Exam Blueprint

The official Microsoft "Skills Measured" document, or exam blueprint, is the most critical resource for preparing for the MB2-701 Exam. This document provides a detailed breakdown of all the specific skills and topics that will be covered on the test, along with the approximate weighting for each major section. This allows you to create a focused and efficient study plan, dedicating more of your time to the areas that form the largest part of the exam, such as plug-in development.

The key domains of the MB2-701 Exam blueprint typically included extending Microsoft Dynamics CRM with client-side code, developing and deploying plug-ins and custom workflow activities, and using the CRM web services to interact with data and metadata. By using the blueprint as a detailed checklist, you can systematically assess your existing knowledge, identify any gaps, and ensure that your study efforts are perfectly aligned with the skills the exam is designed to validate.

Key Development Tools and Resources

A developer is only as good as their tools, and the MB2-701 Exam requires proficiency with a specific set of them. For all server-side development, including plug-ins and custom workflow activities, your primary tool will be Visual Studio. You will also use the CRM Developer Toolkit, which was an add-in for Visual Studio that provided project templates and tools to streamline the development and deployment of your custom code.

For all client-side scripting, your most important tool will be the developer tools built into your web browser (often accessed by pressing F12). These tools are essential for debugging your JScript code. The single most important resource for any developer preparing for the MB2-701 Exam is the CRM 2013 Software Development Kit (SDK). The SDK contains detailed documentation for all the APIs, sample code, and the essential tools like the Plug-in Registration Tool.

Setting Up Your Development Environment for the MB2-701 Exam

It is impossible to pass a development-focused certification like the MB2-701 Exam without extensive hands-on coding practice. Reading about the APIs is not enough; you must write code that uses them. This requires a dedicated development environment. For CRM 2013, the most common approach was to set up a local virtual machine using Hyper-V. You would have a complete, self-contained environment with a domain controller, SQL Server, and the Dynamics CRM 2013 server installed.

Once the server environment is running, you need to install your development tools on your workstation. This includes the correct version of Visual Studio, the CRM 2013 SDK, and the associated CRM Developer Toolkit. Setting up this environment can be a complex task, but it is a necessary first step. It provides you with a sandbox where you can safely build, test, and debug all the solutions required to master the topics for the MB2-701 Exam.

Introduction to Client-Side Scripting

A significant portion of the MB2-701 Exam is dedicated to client-side scripting, which is used to customize the behavior of the Dynamics CRM user interface. The scripting language used is JScript, which is Microsoft's implementation of JavaScript. The key to client-side scripting in CRM is the Xrm.Page object model. This is a comprehensive API provided by the platform that gives your JScript code access to all the elements on a CRM form.

Common use cases for client-side scripting, which you must master for the MB2-701 Exam, include performing data validations on a field when it is changed, automatically populating one field based on the value of another, and dynamically showing or hiding fields, sections, or tabs on a form based on the user's role or the data in other fields. This allows you to create a much more dynamic and responsive user experience.

Introduction to Server-Side Extensions

While client-side scripting is powerful, it is limited to the user interface. For implementing complex, server-side business logic, the MB2-701 Exam requires you to master two main extensibility points: plug-ins and custom workflow activities. A plug-in is a piece of custom code, written in .NET, that is registered to execute in response to a specific event on the CRM server. For example, you could write a plug-in that runs every time an account record is updated.

Custom workflow activities are similar in that they are also written in .NET, but they are designed to be used as reusable steps within the CRM workflow engine. A core concept for server-side development is the event execution pipeline. This is a series of stages that a CRM operation goes through, and you can register your plug-in to run at different stages to achieve different results. Understanding this pipeline is fundamental to passing the MB2-701 Exam.

Initial Steps and Study Strategy for the MB2-701 Exam

Your study strategy for the MB2-701 Exam should be built around the official CRM 2013 SDK. The SDK should be your primary reference for every API, class, and method. Your plan must create a balance between learning the client-side Xrm.Page object model for JScript and the server-side .NET assemblies for plug-in and workflow development. The exam covers both in depth, so you cannot afford to be weak in either area.

The most effective study method is to be relentlessly hands-on. For every single objective in the exam blueprint, you should create a small project in your development environment to implement it. After reading about how to create a pre-validation plug-in, you should immediately open Visual Studio and build one. This practical, project-based approach will be far more effective than simply reading the documentation and is the key to success on the MB2-701 Exam.

The JScript Object Model for the MB2-701 Exam

The cornerstone of all client-side development in Dynamics CRM, and a major focus of the MB2-701 Exam, is the Xrm.Page object model. This is the API that your JavaScript code uses to interact with a CRM entity form. It is crucial to understand its structure. The Xrm.Page object is organized into three main sub-objects: context, data, and ui.

The Xrm.Page.context object provides information about the execution context, such as the current user's ID, their security roles, and the organization's settings. The Xrm.Page.data object is used to interact with the business data on the form, including the attributes of the record being displayed. The Xrm.Page.ui object gives you control over the user interface elements of the form, such as tabs, sections, fields, and the form's navigation pane. A deep knowledge of these three objects is essential for the MB2-701 Exam.

Working with Attributes and Controls

A common point of confusion for new developers, and a key distinction for the MB2-701 Exam, is the difference between an attribute and a control. An attribute represents the actual data for a field, such as the text in the "Account Name" field. A control is the user interface element on the form that is used to display and edit that data. It is possible for the same attribute to be displayed by multiple controls on a form.

Your JScript code will need to interact with both. You use the attribute object's getValue and setValue methods to read and write the data. You use the control object's methods to manipulate the user interface. For example, you would use a control's setVisible method to hide or show it, its setDisabled method to make it read-only, and its setLabel method to change the text that is displayed next to it.

Form and Field Events

Your JScript code does not run on its own; it must be triggered by an event. The MB2-701 Exam requires you to be an expert in the CRM form event model. The two main form-level events are the OnLoad event, which fires every time a form is loaded, and the OnSave event, which fires when a user clicks the save button. You use the form editor in the CRM customization tools to attach your JScript functions to these events.

In addition to the form events, every field on the form has an OnChange event. This event fires whenever the value of that field is changed by the user. This is extremely useful for implementing interactive logic, such as populating one field based on the value selected in another. For the MB2-701 Exam, you must also understand how to configure your event handlers to pass the event's execution context object to your function, which provides important contextual information.

Advanced UI Customization with JScript

Beyond basic field manipulation, the MB2-701 Exam will test your ability to perform more advanced UI customizations with JScript. You can use the Xrm.Page.ui object to display notifications to the user. You can show a form-level notification at the top of the page using setNotification, or a field-level notification next to a specific control. This is the standard way to display error or informational messages.

A particularly powerful set of functions relates to lookup fields. You must know how to use the addPreSearch and addCustomFilter methods. These methods allow you to dynamically filter the results that are shown in a lookup dialog. For example, when a user clicks the lookup for a contact, you could add a filter to only show contacts that are related to the account that is currently on the form. You can also dynamically add and remove options from an option set (dropdown) field.

Asynchronous Programming with Web Services

A common requirement is for your JScript code to retrieve data from the CRM server that is not already on the form. It is critical for the MB2-701 Exam that you understand that these calls must be made asynchronously. A synchronous call will freeze the entire browser user interface while it waits for the server to respond, creating a very poor user experience. The exam will expect you to know how to use the available web service endpoints to perform these asynchronous data operations.

Dynamics CRM 2013 provides two main endpoints for client-side code. The OData (or REST) endpoint is a lightweight, modern endpoint that is ideal for performing data queries. The older SOAP endpoint is more powerful and is required for performing create, update, and delete operations. For the MB2-701 Exam, you should be familiar with using the browser's native XMLHttpRequest object to construct and execute these asynchronous web service calls.

HTML Web Resources

Sometimes, the standard CRM form controls are not sufficient to meet a specific UI requirement. In these cases, you can create a completely custom user interface using an HTML web resource. This is an important topic for the MB2-701 Exam. An HTML web resource is simply an HTML file (along with any supporting CSS and JavaScript files) that you upload into the CRM solution. You can then add this web resource to an entity form, where it will be displayed in an iframe.

A key feature that you must know for the exam is that the JavaScript within your HTML web resource can communicate with the parent CRM form. It can access the Xrm.Page object of the host form by using parent.Xrm.Page. This allows your custom UI to read data from the main form and to write data back to it, enabling the creation of highly interactive and custom components, such as data visualizations or integrations with external services.

Debugging JScript in Dynamics CRM

Writing complex client-side code without a proper debugging strategy is nearly impossible. The MB2-701 Exam requires you to be proficient in debugging your JScript code. The primary tool for this is the set of developer tools that are built into all modern web browsers, which are typically accessed by pressing the F12 key. These tools provide a powerful and essential environment for diagnosing problems in your code.

Within the developer tools, you can view your loaded JScript files, set breakpoints to pause the execution of your code at a specific line, and then step through the code line by line. While the code is paused, you can inspect the values of all your variables and examine the state of the Xrm.Page object. The console window is also an invaluable tool for logging messages and testing small snippets of code.

The Plug-in Architecture for the MB2-701 Exam

Plug-ins are the most powerful tool for extending the server-side business logic of Dynamics CRM, and they are the most heavily weighted topic on the MB2-701 Exam. A plug-in is a custom event handler, written in the .NET Framework, that you register to run in response to a specific message being processed by the CRM platform. To create a plug-in, you write a C# class that implements the IPlugin interface. This interface has a single method, Execute, which is where all your business logic will reside.

A critical concept you must master for the MB2-701 Exam is the event execution pipeline. This is a series of stages that a CRM operation, like creating an account, passes through. You can register your plug-in to run at different stages: Pre-Validation, Pre-Operation, and Post-Operation. You can also choose whether your plug-in runs synchronously (as part of the core transaction) or asynchronously (in the background after the transaction is complete).

The Plug-in Execution Context

When your plug-in's Execute method is called, it is passed a service provider object. From this object, you can retrieve the IPluginExecutionContext, which is the most important object in any plug-in. This "context" object contains all the information about the event that caused your plug-in to fire. A deep understanding of this object's properties is essential for the MB2-701 Exam.

The context's InputParameters and OutputParameters collections contain the data being passed into and out of the core CRM operation. The most important input parameter is the Target, which is typically an Entity object containing all the data for the record being created or updated. The context also provides access to Pre and Post Business Entity Images. These are snapshots of the record before and after the core operation, which are essential for comparing what data was changed.

Developing and Building a Plug-in

The development of a plug-in is done in Visual Studio, and the MB2-701 Exam requires you to be proficient in this process. Using the CRM Developer Toolkit, you can create a new plug-in project, which provides the necessary assembly references and a basic template class. You then write your business logic in C# within the Execute method of your plug-in class.

When writing your code, you can choose between two programming styles: late-bound and early-bound. The late-bound style uses a generic Entity class and string-based attribute names, which is flexible but prone to typos. The early-bound style uses strongly-typed classes that are generated based on your CRM customizations, providing compile-time checking and IntelliSense. Once your code is complete, you must sign the assembly with a strong name key before it can be deployed to CRM.

The Plug-in Registration Tool

Writing the plug-in code is only half the battle. To make it run, you must deploy and register it with the Dynamics CRM platform. This is done using a standalone application called the Plug-in Registration Tool, which is included in the CRM SDK. The MB2-701 Exam requires you to be an expert in using this tool. The first step is to create a connection to your CRM organization.

You then register your compiled plug-in assembly. After the assembly is loaded, you can register a "step." A step is what ties your plug-in code to a specific event. When you register a step, you must specify the Message (e.g., Create, Update, Delete), the Primary Entity (e.g., Account, Contact), and the execution Stage (Pre-Operation, Post-Operation). You can also configure filtering attributes so that a plug-in on an update message only fires when a specific field is changed.

Advanced Plug-in Concepts

The MB2-701 Exam goes beyond simple plug-ins and covers several advanced concepts. One of these is impersonation. By default, a plug-in runs under the security context of the user who initiated the action. However, you can write your plug-in to run as a different user, such as a system administrator, which is useful when the plug-in needs to perform an action that the original user does not have permission for.

Another critical concept is preventing infinite loops. If you have a plug-in on the update of an account that in turn updates the same account, you can easily create a loop. The execution context provides a depth property that you can check to see how many times your plug-in has been called in the same transaction, allowing you to exit gracefully. You can also use Shared Variables to pass data from one plug-in to another that is running in the same execution pipeline.

Plug-in Deployment and Solutions

While you can use the Plug-in Registration Tool to deploy your plug-ins directly, this is not a best practice for moving customizations between environments. The correct way to manage your plug-in deployments is to include them in a CRM solution. The MB2-701 Exam requires you to understand this process. When you add your plug-in assembly and its associated steps to a solution, they become components that can be exported and imported.

This allows you to move your server-side extensions from your development environment to your test and production environments in a consistent and repeatable manner. You must also understand the difference between managed and unmanaged solutions. Unmanaged solutions are used in development environments, while managed solutions are used for deploying to any other environment, as they provide a cleaner way to install and uninstall your customizations.

Debugging Plug-ins

Troubleshooting server-side code can be challenging. The MB2-701 Exam expects you to know the different methods for debugging your plug-ins. For plug-ins that are registered to run on-premise, you can perform real-time, interactive debugging. This involves attaching the Visual Studio debugger to the appropriate CRM process (such as w3wp.exe for synchronous plug-ins or CrmAsyncService.exe for asynchronous ones) and then setting breakpoints in your code.

For CRM Online, or for scenarios where interactive debugging is not possible, the primary tool is the Plug-in Profiler. This tool is part of the Plug-in Registration Tool. It allows you to capture the complete execution context of a plug-in as it runs in CRM. You can then replay that exact execution on your local machine with the Visual Studio debugger attached. You can also write diagnostic messages from your plug-in using the Tracing Service.

Extending CRM Workflows for the MB2-701 Exam

The out-of-the-box workflow designer in Dynamics CRM is a powerful tool for automating business processes without writing any code. However, it has its limitations. For scenarios that require complex calculations, integration with external systems, or any logic that cannot be achieved with the standard workflow steps, you need to create a Custom Workflow Activity. This is a key extensibility point covered in the MB2-701 Exam.

A custom workflow activity allows you to create a reusable piece of business logic, written in .NET, that can be used as a step within any CRM workflow. It is important for the MB2-701 Exam that you understand the difference between a plug-in and a custom workflow activity. A plug-in is tied to a specific event in the platform pipeline, while a custom workflow activity is a self-contained, reusable component that can be used on-demand by a workflow designer.

Developing Custom Workflow Activities

The process of developing a custom workflow activity is a core skill for the MB2-701 Exam. In Visual Studio, you create a class that inherits from the CodeActivity class, which is part of the Windows Workflow Foundation framework. Within this class, you define the input and output arguments for your activity. These arguments are defined as properties and are decorated with .NET attributes to specify them as [Input("...")] or [Output("...")].

These arguments are what the workflow designer will see, allowing them to pass data into your custom activity and receive data back from it. All of your business logic is placed within the overridden Execute method. Inside this method, you can access the input arguments, perform your complex logic, and then set the values of the output arguments. You can also access the CRM organization service to query and update data within your custom code.

Deploying and Using Custom Workflow Activities

Similar to plug-ins, custom workflow activities are packaged in a .NET assembly that must be registered with the Dynamics CRM platform. This is done using the same Plug-in Registration Tool that is used for plug-ins, a process you must know for the MB2-701 Exam. You register the assembly that contains your custom workflow activity code. Unlike plug-ins, you do not need to register any steps. The platform automatically discovers the custom activity within the assembly.

Once the assembly is registered, the custom workflow activity will automatically appear in the toolbox of the workflow designer, typically in its own category. A workflow author can then drag and drop your custom activity onto the workflow canvas just like any other standard workflow step. They can then configure its properties, mapping workflow data to your activity's input arguments and using its output arguments in subsequent steps of the workflow.

The CRM Web Services

Every data operation and almost every action in Dynamics CRM goes through its web services layer. The MB2-701 Exam requires a deep understanding of these services, as they are the primary way that custom applications and external systems integrate with CRM. There are two primary web service endpoints that you must master. The first is the Organization Service, which is a powerful, full-featured SOAP endpoint. The second is the OData Service, which is a lightweight, modern REST-based endpoint.

In addition to these, there is also a Discovery Service, which is used by multi-tenant applications to find the correct organization endpoint for a given user. All calls to these web services must be authenticated, and understanding how to manage the security context for these calls is a critical part of the knowledge required for the MB2-701 Exam.

Using the Organization Service (SOAP)

The Organization Service is the primary and most powerful endpoint for interacting with Dynamics CRM data and metadata. It is the same service that is used by the CRM web application itself. The MB2-701 Exam will expect you to be proficient in using this service from your custom .NET code, such as in a plug-in, a custom workflow activity, or an external application. You interact with this service through the IOrganizationService interface.

This interface provides the core methods for all data operations: Create, Retrieve, Update, and Delete. For performing complex data queries, you must be an expert in using the QueryExpression class. This class allows you to build a structured query with filters, column sets, and sorting orders. The Organization Service also allows you to execute specialized "messages," which are predefined platform operations like assigning a record or qualifying a lead.

Using the OData Service (REST)

The OData Service, also known as the REST endpoint, was introduced to provide a more lightweight and web-friendly way to interact with CRM data, especially from client-side JavaScript code. This is a key topic for the MB2-701 Exam. The REST endpoint is primarily designed for data query operations. It supports a rich set of OData query options, which are appended to the URL to control the data that is returned.

You must be familiar with the key OData query options, such as $select to specify which columns to return, $filter to apply a query condition, $orderby to sort the results, and $expand to retrieve data from related entities. While the REST endpoint in CRM 2013 also supported create, update, and delete operations, it was more limited in its capabilities compared to the SOAP service. Its primary use case was for data retrieval in client-side scripts.

Early-Bound vs. Late-Bound Development

When you write server-side code that interacts with the Organization Service, you have a choice between two development styles: early-bound and late-bound. The MB2-701 Exam requires you to understand the pros and cons of each. The late-bound style is the default. With this approach, you work with a generic Entity class. You refer to the entity's attributes using their logical name as a string, for example, account["name"]. This is flexible but offers no compile-time type checking.

The early-bound style involves using a command-line tool, crmsvcutil.exe, to generate a set of C# classes that are strongly-typed representations of your CRM entities. With this approach, you can write code like account.Name. This provides full IntelliSense in Visual Studio and compile-time checking, which dramatically reduces the risk of runtime errors due to typos. Most professional development is done using the early-bound style.

Scenario 1: Implementing Complex Lead Validation for the MB2-701 Exam

A classic advanced scenario for the MB2-701 Exam involves implementing a complex data validation rule. For example, a business rule states that on the save of a Lead record, the email address must be unique across all existing Lead and Contact records in the system. A robust solution would involve both client-side and server-side code.

On the client-side, you would write a JScript function that triggers on the OnChange event of the email address field. This function would use an asynchronous OData query to check for duplicates and, if one is found, display a form notification to the user. On the server-side, you would register a plug-in on the Pre-Operation stage of the Create and Update messages for the Lead entity. This plug-in would perform the same check using a QueryExpression and, if a duplicate is found, throw an InvalidPluginExecutionException to block the save and display an error.

Scenario 2: Automating Territory Assignment

Another common scenario for the MB2-701 Exam is the automation of a business process that is too complex for a standard workflow. For example, when a user updates the address on an Account record, the system must automatically assign the Account to the correct sales territory and sales representative based on the postal code. The first step would be to create a custom "Territory" entity in CRM to store the mapping of postal codes to users.

The core of the solution would be a plug-in. You would develop a plug-in that is registered on the Post-Operation stage of the Update message for the Account entity, with filtering attributes set to the address fields. When the address is changed, the plug-in reads the new postal code, queries your custom Territory entity to find the appropriate sales representative, and then uses the Assign message to reassign the Account record to that user.

Scenario 3: Creating a Custom Quoting Interface

The MB2-701 Exam will test your ability to create custom user interfaces. Consider a scenario where the sales team needs a more user-friendly way to add products to an Opportunity. They want to be able to search for products from an external ERP system and add them directly to the Opportunity Product sub-grid on the form. The best solution for this would be an HTML Web Resource.

You would create an HTML page with a search box and a results grid. The JavaScript within this web resource would make calls to an external web service (or a provider-hosted app endpoint) to query the ERP's product catalog in real time. When the user selects a product from the results, the JavaScript would then use the parent.Xrm.Page object model to create a new Opportunity Product record in the parent form's sub-grid, populating it with the data from the ERP system.

Solution Management Best Practices

An advanced developer must be an expert in packaging and deploying their customizations. This is a key professional skill tested in the MB2-701 Exam. All of your customizations, including JScript web resources, plug-in assemblies, custom workflow assemblies, and any new entities or fields, should be packaged into a single CRM Solution. This makes your customizations portable and easy to manage.

You must understand the importance of using a solution Publisher, which applies a unique prefix to all your custom components. You also need to master the concept of managed versus unmanaged solutions. Unmanaged solutions are used in development environments where you need to make changes. Managed solutions are used to deploy your finished application to a test or production environment. A managed solution can be uninstalled cleanly, and its components can be locked down to prevent modification.

Mastering the MB2-701 Exam Question Style

The MB2-701 Exam is a developer-focused exam, and the question style reflects this. You must be prepared to read and interpret snippets of C# and JScript code. The exam will not ask you to write code from scratch, but it will test your ability to understand what a piece of code does, identify bugs in it, or choose the correct code to complete a given task.

Many questions will be scenario-based, presenting a business problem and asking you to choose the most appropriate extensibility point. For example, should you use JScript, a plug-in, a workflow, or a custom action to solve the problem? Success on these questions requires a deep understanding of the capabilities and limitations of each of the core extensibility tools covered in the MB2-701 Exam syllabus.

Conclusion

In your final days of preparation for the MB2-701 Exam, your focus should be on reviewing the key objects and interfaces that are the foundation of CRM development. Do a rapid review of the IPluginExecutionContext object and all of its properties. Re-familiarize yourself with the methods of the IOrganizationService interface. Go over the Xrm.Page object model one last time.

It is also highly beneficial to memorize the stages of the plug-in event execution pipeline (Pre-Validation, Pre-Operation, Post-Operation) and the key messages (Create, Update, Delete, Assign, etc.). A certification like the one validated by the MB2-701 Exam proves that you have the essential skills to build powerful, enterprise-grade line-of-business applications. This core competency is incredibly valuable and serves as the foundation for a successful career as a Dynamics 365 developer.

Choose ExamLabs to get the latest & updated Microsoft MB2-701 practice test questions, exam dumps with verified answers to pass your certification exam. Try our reliable MB2-701 exam dumps, practice test questions and answers for your next certification exam. Premium Exam Files, Question and Answers for Microsoft MB2-701 are actually exam dumps which help you pass quickly.

Hide