Posted incompare

How To Compare Two Objects In Angular: A Comprehensive Guide

No Comments

Comparing objects in Angular can be a complex task, but understanding the right techniques is crucial for efficient development. COMPARE.EDU.VN provides a detailed guide to simplify this process, offering solutions for developers of all skill levels. This article explores various methods to compare two objects in Angular, ensuring you choose the best approach for your needs, ultimately improving your application’s performance and reliability with object equality checks, angular comparison strategies and efficient comparison techniques.

1. Understanding Object Comparison in Angular

In Angular, comparing objects goes beyond simple equality checks. It often involves determining whether two objects have the same properties and values. This is crucial in many scenarios, such as:

  • Data Binding: Ensuring that changes in one object are correctly reflected in the user interface.
  • State Management: Verifying if the application state has changed, triggering necessary updates.
  • Change Detection: Optimizing the change detection process by comparing objects to prevent unnecessary updates.
  • Testing: Validating that the application behaves as expected by comparing the state of objects before and after an action.

To effectively compare objects, it’s important to understand the difference between referential equality and deep equality. Referential equality checks if two variables point to the same object in memory. Deep equality, on the other hand, checks if two objects have the same properties and values, even if they are stored in different memory locations.


1.1. Referential Equality vs. Deep Equality

  • Referential Equality: This type of equality checks if two object references point to the exact same object in memory. In JavaScript, you can use the strict equality operator (===) to check for referential equality.

    const obj1 = { name: 'John' };
const obj2 = obj1;

console.log(obj1 === obj2); // true, because obj1 and obj2 point to the same object

const obj3 = { name: 'John' };
console.log(obj1 === obj3); // false, because obj1 and obj3 are different objects in memory

  • Deep Equality: Deep equality, on the other hand, checks if two objects have the same properties and values. This is more complex because you need to iterate through the properties of both objects and compare their values.

    const obj1 = { name: 'John', age: 30 };
const obj2 = { name: 'John', age: 30 };

// This will return false because obj1 and obj2 are different objects in memory
console.log(obj1 === obj2);

// You need a custom function to check for deep equality
function deepEqualityCheck(obj1: any, obj2: any): boolean {
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);

    if (keys1.length !== keys2.length) {
        return false;
    }

    for (let key of keys1) {
        if (obj1[key] !== obj2[key]) {
            return false;
        }
    }

    return true;
}

console.log(deepEqualityCheck(obj1, obj2)); // true

1.2. Why Deep Equality Matters in Angular

In Angular applications, deep equality is often more relevant than referential equality. This is because Angular’s change detection mechanism relies on comparing the current state of an object with its previous state to determine if an update is needed. If you only check for referential equality, Angular might not detect changes in the object’s properties, leading to unexpected behavior in the user interface.

For example, consider a scenario where you have a component that displays a user’s profile. The user profile data is stored in an object. If you update the user’s name in the object, Angular needs to detect this change and update the UI accordingly. If you only check for referential equality, Angular will not detect that the object’s properties have changed because the object reference remains the same.

Deep equality ensures that Angular correctly detects changes in the object’s properties, allowing it to update the UI and maintain data consistency.

1.3. Challenges in Comparing Objects

Comparing objects in Angular can be challenging due to the following reasons:

  • Nested Objects: Objects can have nested objects, making it necessary to recursively compare the properties of each nested object.
  • Circular References: Objects can have circular references, where an object references itself, leading to infinite loops if not handled properly.
  • Performance: Deep comparison can be computationally expensive, especially for large objects with many properties.
  • Data Types: JavaScript has different data types, and comparing values of different types can be tricky.

To overcome these challenges, developers need to use appropriate techniques and libraries that provide efficient and reliable object comparison methods. COMPARE.EDU.VN aims to provide you with the necessary knowledge and tools to tackle these challenges effectively, ensuring that your Angular applications are robust and performant.

2. Methods for Comparing Objects in Angular

There are several methods for comparing objects in Angular, each with its own advantages and disadvantages. Let’s explore some of the most common techniques:

  1. Manual Comparison: Implementing a custom function to compare objects property by property.
  2. JSON.stringify(): Converting objects to JSON strings and comparing the strings.
  3. Lodash’s isEqual(): Using the isEqual() function from the Lodash library.
  4. deep-equal Library: Utilizing the deepEqual function from the deep-equal NPM package.
  5. Angular’s KeyValuePipe: Leveraging the KeyValuePipe for comparing object properties in templates.

2.1. Manual Comparison: A Step-by-Step Guide

Manual comparison involves writing a custom function that iterates through the properties of both objects and compares their values. This method provides the most control over the comparison process, allowing you to handle specific cases and data types.

2.1.1. Implementing the deepEqualityCheck Function

Here’s a step-by-step guide to implementing a deepEqualityCheck function in TypeScript:

  1. Get the keys of both objects: Use Object.keys() to get an array of the keys for each object.
  2. Check if the number of keys is the same: If the number of keys is different, the objects cannot be equal.
  3. Iterate through the keys: Use a for...of loop to iterate through the keys of the first object.
  4. Check if the key exists in both objects: If a key exists in one object but not the other, the objects cannot be equal.
  5. Compare the values of the keys: If the values are primitive types, use the strict equality operator (===) to compare them. If the values are objects, recursively call the deepEqualityCheck function.
  6. Handle null and undefined values: Ensure that you handle null and undefined values appropriately.
function deepEqualityCheck(obj1: any, obj2: any): boolean {
    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);

    if (keys1.length !== keys2.length) {
        return false;
    }

    for (let key of keys1) {
        if (!obj2.hasOwnProperty(key) || !isEqual(obj1[key], obj2[key])) {
            return false;
        }
    }

    return true;
}

function isEqual(value1: any, value2: any): boolean {
    if (value1 === value2) {
        return true;
    }

    if (typeof value1 !== typeof value2) {
        return false;
    }

    if (typeof value1 === 'object' && value1 !== null && value2 !== null) {
        return deepEqualityCheck(value1, value2);
    }

    return false;
}

const obj1 = { name: 'John', age: 30, address: { city: 'New York' } };
const obj2 = { name: 'John', age: 30, address: { city: 'New York' } };
const obj3 = { name: 'Jane', age: 25, address: { city: 'Los Angeles' } };

console.log('Obj1 and Obj2 are equal:', deepEqualityCheck(obj1, obj2)); // true
console.log('Obj1 and Obj3 are equal:', deepEqualityCheck(obj1, obj3)); // false

2.1.2. Advantages and Disadvantages of Manual Comparison

Advantages:

  • Control: You have complete control over the comparison process.
  • Customization: You can customize the comparison logic to handle specific data types and cases.
  • No Dependencies: You don’t need to rely on external libraries.

Disadvantages:

  • Complexity: Implementing a deep equality check can be complex, especially for objects with nested properties.
  • Performance: Manual comparison can be slow, especially for large objects.
  • Maintenance: You need to maintain the comparison logic yourself.

2.1.3. Best Use Cases for Manual Comparison

Manual comparison is best suited for scenarios where:

  • You need to compare objects with specific data types or custom logic.
  • You want to avoid dependencies on external libraries.
  • The objects being compared are relatively small.

2.2. JSON.stringify(): A Quick and Dirty Approach

The JSON.stringify() method is a simple way to compare objects by converting them to JSON strings and then comparing the strings. This method is easy to implement, but it has some limitations.

2.2.1. How to Use JSON.stringify() for Object Comparison

To use JSON.stringify() for object comparison, simply pass the objects to the function and compare the resulting strings:

const obj1 = { name: 'John', age: 30, address: { city: 'New York' } };
const obj2 = { name: 'John', age: 30, address: { city: 'New York' } };
const obj3 = { name: 'John', age: 30, address: { city: 'Los Angeles' } };

console.log('Obj1 and Obj2 are equal:', JSON.stringify(obj1) === JSON.stringify(obj2)); // true
console.log('Obj1 and Obj3 are equal:', JSON.stringify(obj1) === JSON.stringify(obj3)); // false

2.2.2. Limitations of JSON.stringify()

While JSON.stringify() provides a quick way to compare objects, it has several limitations:

  • Order of Properties: The order of properties in the objects matters. If the properties are in a different order, the strings will be different, even if the objects have the same values.
  • Circular References: JSON.stringify() cannot handle circular references. It will throw an error if an object has a circular reference.
  • Data Types: JSON.stringify() treats different data types differently. For example, it treats undefined and null as the same value.
  • Performance: JSON.stringify() can be slow for large objects.

2.2.3. When to Use JSON.stringify()

JSON.stringify() is best suited for scenarios where:

  • You need a quick and easy way to compare objects.
  • The order of properties in the objects is consistent.
  • The objects do not have circular references.
  • Performance is not a critical concern.

2.3. Lodash’s isEqual(): A Comprehensive Solution

Lodash is a popular JavaScript utility library that provides a wide range of functions for working with arrays, objects, and strings. The isEqual() function from Lodash provides a comprehensive solution for comparing objects, handling nested properties, circular references, and different data types.

2.3.1. Installing and Importing Lodash

To use Lodash in your Angular project, you need to install it using NPM:

npm install lodash

Once installed, you can import the isEqual() function in your TypeScript code:

import { isEqual } from 'lodash';

2.3.2. Using isEqual() for Object Comparison

To use isEqual() for object comparison, simply pass the objects to the function:

import { isEqual } from 'lodash';

const obj1 = { name: 'John', age: 30, address: { city: 'New York' } };
const obj2 = { name: 'John', age: 30, address: { city: 'New York' } };
const obj3 = { name: 'John', age: 30, address: { city: 'Los Angeles' } };

console.log('Obj1 and Obj2 are equal:', isEqual(obj1, obj2)); // true
console.log('Obj1 and Obj3 are equal:', isEqual(obj1, obj3)); // false

2.3.3. Advantages of Using Lodash’s isEqual()

  • Comprehensive: isEqual() handles nested properties, circular references, and different data types.
  • Easy to Use: isEqual() is easy to use and requires minimal code.
  • Performance: isEqual() is optimized for performance.
  • Reliable: Lodash is a well-tested and widely used library.

2.3.4. Considerations When Using Lodash

While Lodash’s isEqual() is a powerful tool, there are a few considerations to keep in mind:

  • Dependency: You need to add Lodash as a dependency to your project.
  • Size: Lodash is a large library, so it can increase the size of your bundle. However, you can use tree shaking to only include the isEqual() function in your bundle.

2.3.5. Best Scenarios for Lodash’s isEqual()

Lodash’s isEqual() is best suited for scenarios where:

  • You need a comprehensive solution for comparing objects.
  • You are already using Lodash in your project.
  • Performance is important.

2.4. deep-equal Library: A Lightweight Alternative

The deep-equal library is a lightweight alternative to Lodash that provides a single function for comparing objects. This library is smaller than Lodash and can be a good choice if you only need to compare objects.

2.4.1. Installing and Importing deep-equal

To use the deep-equal library in your Angular project, you need to install it using NPM:

npm install deep-equal

Once installed, you can import the deepEqual function in your TypeScript code:

import * as deepEqual from 'deep-equal';

2.4.2. Using deepEqual for Object Comparison

To use deepEqual for object comparison, simply pass the objects to the function:

import * as deepEqual from 'deep-equal';

const obj1 = { name: 'John', age: 30, address: { city: 'New York' } };
const obj2 = { name: 'John', age: 30, address: { city: 'New York' } };
const obj3 = { name: 'John', age: 30, address: { city: 'Los Angeles' } };

console.log('Obj1 and Obj2 are equal:', deepEqual(obj1, obj2)); // true
console.log('Obj1 and Obj3 are equal:', deepEqual(obj1, obj3)); // false

2.4.3. Key Features of the deep-equal Library

  • Lightweight: The deep-equal library is smaller than Lodash.
  • Easy to Use: deepEqual is easy to use and requires minimal code.
  • Customizable: The deepEqual function can be customized with options to control the comparison process.

2.4.4. Use Cases for the deep-equal Library

The deep-equal library is best suited for scenarios where:

  • You need a lightweight solution for comparing objects.
  • You want to avoid adding a large dependency like Lodash.
  • You need to customize the comparison process.

2.5. Angular’s KeyValuePipe: Comparing Objects in Templates

Angular’s KeyValuePipe is primarily designed for iterating over objects in templates, but it can also be used to compare objects. This method is useful for displaying object properties in a specific order or for filtering objects based on their properties.

2.5.1. Understanding the KeyValuePipe

The KeyValuePipe transforms an object or a map into an array of key-value pairs, which can then be iterated over using *ngFor. This allows you to display the properties of an object in a specific order or to filter the properties based on their values.

2.5.2. Using KeyValuePipe for Object Comparison

To use KeyValuePipe for object comparison, you can iterate over the properties of both objects and compare their values in the template:

import { Component } from '@angular/core';

@Component({
  selector: 'app-object-comparison',
  template: `
    <div>
      <h2>Object 1</h2>
      <ul>
        <li *ngFor="let item of obj1 | keyvalue">
          <strong>{{item.key}}:</strong> {{item.value}}
        </li>
      </ul>

      <h2>Object 2</h2>
      <ul>
        <li *ngFor="let item of obj2 | keyvalue">
          <strong>{{item.key}}:</strong> {{item.value}}
        </li>
      </ul>

      <p>Objects are equal: {{ areObjectsEqual() }}</p>
    </div>
  `,
})
export class ObjectComparisonComponent {
  obj1 = { name: 'John', age: 30, address: { city: 'New York' } };
  obj2 = { name: 'John', age: 30, address: { city: 'New York' } };

  areObjectsEqual(): boolean {
    // Manual comparison logic here
    const keys1 = Object.keys(this.obj1);
    const keys2 = Object.keys(this.obj2);

    if (keys1.length !== keys2.length) {
      return false;
    }

    for (let key of keys1) {
      if (this.obj1[key] !== this.obj2[key]) {
        return false;
      }
    }

    return true;
  }
}

2.5.3. Benefits of Using KeyValuePipe in Templates

  • Dynamic Display: You can dynamically display the properties of an object in the template.
  • Filtering: You can filter the properties of an object based on their values.
  • Ordering: You can order the properties of an object in a specific order.

2.5.4. Limitations of Using KeyValuePipe

  • Complexity: Using KeyValuePipe for object comparison can be complex, especially for objects with nested properties.
  • Performance: Iterating over objects in the template can be slow.
  • Limited Functionality: KeyValuePipe is primarily designed for displaying object properties, not for comparing objects.

2.5.5. Ideal Use Cases for KeyValuePipe

KeyValuePipe is best suited for scenarios where:

  • You need to dynamically display the properties of an object in the template.
  • You need to filter the properties of an object based on their values.
  • You need to order the properties of an object in a specific order.

3. Practical Examples and Use Cases

To illustrate how these methods can be used in real-world scenarios, let’s look at some practical examples and use cases.

3.1. Comparing User Profile Objects

In many applications, you need to compare user profile objects to determine if a user’s information has changed. This is important for updating the user interface and for triggering other actions, such as sending notifications.

import { isEqual } from 'lodash';

interface UserProfile {
  name: string;
  age: number;
  address: {
    city: string;
    country: string;
  };
}

const oldProfile: UserProfile = {
  name: 'John',
  age: 30,
  address: {
    city: 'New York',
    country: 'USA',
  },
};

const newProfile: UserProfile = {
  name: 'John',
  age: 31,
  address: {
    city: 'New York',
    country: 'USA',
  },
};

function compareUserProfiles(oldProfile: UserProfile, newProfile: UserProfile): boolean {
  return isEqual(oldProfile, newProfile);
}

console.log('User profiles are equal:', compareUserProfiles(oldProfile, newProfile)); // false

In this example, we use Lodash’s isEqual() function to compare two user profile objects. If the objects are different, we can update the user interface and send a notification to the user.

3.2. Detecting Changes in Form Data

When working with forms in Angular, you often need to detect changes in the form data to enable or disable certain actions, such as saving the form.

import { isEqual } from 'lodash';
import { FormGroup } from '@angular/forms';

function compareFormValues(form: FormGroup, initialValues: any): boolean {
  return isEqual(form.value, initialValues);
}

// Example usage:
// const form = new FormGroup({ ... });
// const initialValues = form.value;
// form.valueChanges.subscribe(() => {
//   const isFormDirty = !compareFormValues(form, initialValues);
//   // Enable or disable the save button based on isFormDirty
// });

In this example, we use Lodash’s isEqual() function to compare the current form values with the initial values. If the values are different, we can enable the save button.

3.3. Optimizing Change Detection in Angular

Angular’s change detection mechanism can be optimized by comparing objects to prevent unnecessary updates. By implementing a custom trackBy function, you can tell Angular to only update the DOM if the object has changed.

import { Component, Input } from '@angular/core';
import { isEqual } from 'lodash';

@Component({
  selector: 'app-list-item',
  template: `
    <div>{{ item.name }}</div>
  `,
})
export class ListItemComponent {
  @Input() item: any;

  ngOnChanges(changes: any) {
    if (changes.item) {
      const oldValue = changes.item.previousValue;
      const newValue = changes.item.currentValue;

      if (!isEqual(oldValue, newValue)) {
        console.log('Item has changed, updating the DOM');
      } else {
        console.log('Item has not changed, skipping DOM update');
      }
    }
  }
}

// Example usage in the parent component:
// <div *ngFor="let item of items; trackBy: trackByFn">
//   <app-list-item [item]="item"></app-list-item>
// </div>
//
// trackByFn(index: number, item: any): any {
//   return item.id;
// }

In this example, we use Lodash’s isEqual() function to compare the old and new values of the item input. If the values are the same, we can skip updating the DOM, improving the performance of the application.

4. Performance Considerations

When comparing objects in Angular, it’s important to consider the performance implications of each method. Deep comparison can be computationally expensive, especially for large objects with many properties.

4.1. Benchmarking Different Methods

To determine which method is the most performant, you can benchmark the different methods using a tool like console.time() and console.timeEnd().

const obj1 = { ... }; // Large object
const obj2 = { ... }; // Large object

console.time('Manual Comparison');
deepEqualityCheck(obj1, obj2);
console.timeEnd('Manual Comparison');

console.time('JSON.stringify()');
JSON.stringify(obj1) === JSON.stringify(obj2);
console.timeEnd('JSON.stringify()');

console.time('Lodash's isEqual()');
isEqual(obj1, obj2);
console.timeEnd('Lodash's isEqual()');

console.time('deep-equal Library');
deepEqual(obj1, obj2);
console.timeEnd('deep-equal Library');

By running this code, you can get an idea of how long each method takes to compare the objects.

4.2. Optimizing Object Comparison

To optimize object comparison, consider the following tips:

  • Use the Right Method: Choose the method that is best suited for your specific use case. For example, if you only need to compare small objects with simple properties, JSON.stringify() might be sufficient. If you need to compare large objects with nested properties, Lodash’s isEqual() might be a better choice.
  • Avoid Deep Comparison When Possible: If you only need to check if an object has changed, consider using a shallow comparison instead of a deep comparison.
  • Use Memoization: Memoization is a technique that can be used to cache the results of expensive function calls. By memoizing the results of object comparisons, you can avoid recomputing the same result multiple times.

4.3. Reducing Unnecessary Comparisons

One of the best ways to improve the performance of object comparison is to reduce the number of unnecessary comparisons. This can be achieved by:

  • Using Immutable Data: Immutable data is data that cannot be changed after it is created. By using immutable data, you can be sure that an object has not changed unless its reference has changed.
  • Implementing a Custom trackBy Function: By implementing a custom trackBy function, you can tell Angular to only update the DOM if the object has changed.
  • Using OnPush Change Detection: The OnPush change detection strategy tells Angular to only check for changes in a component if its input properties have changed.

5. Best Practices for Object Comparison in Angular

To ensure that you are comparing objects in Angular effectively, follow these best practices:

5.1. Choosing the Right Method for the Job

Select the method that best fits your specific needs. Consider the size of the objects, the complexity of their properties, and the performance implications of each method.

5.2. Handling Circular References

Be aware of circular references and use methods that can handle them gracefully, such as Lodash’s isEqual() or the deep-equal library.

5.3. Writing Unit Tests

Write unit tests to ensure that your object comparison logic is working correctly. This will help you catch bugs early and prevent unexpected behavior in your application.

5.4. Documenting Your Code

Document your code to explain how your object comparison logic works. This will make it easier for other developers to understand and maintain your code.

5.5. Staying Updated with Angular Best Practices

Keep up-to-date with the latest Angular best practices to ensure that you are using the most efficient and effective methods for comparing objects.


6. Advanced Techniques

For more complex scenarios, consider these advanced techniques:

6.1. Custom Comparison Functions

Write custom comparison functions to handle specific data types or cases. This can be useful for comparing objects with custom properties or for implementing custom comparison logic.

6.2. Using RxJS Operators for Object Comparison

Use RxJS operators like distinctUntilChanged and pairwise to compare objects in streams. This can be useful for detecting changes in data streams and for triggering actions based on those changes.

6.3. Memoization Techniques

Implement memoization techniques to cache the results of expensive object comparisons. This can improve the performance of your application by avoiding recomputing the same result multiple times.

7. Common Pitfalls and How to Avoid Them

7.1. Failing to Handle Null and Undefined Values

Ensure that you handle null and undefined values appropriately in your object comparison logic. Failing to do so can lead to unexpected behavior and errors.

7.2. Ignoring the Order of Properties

Be aware that the order of properties matters when using JSON.stringify() for object comparison. If the order of properties is not consistent, the comparison will not work correctly.

7.3. Overlooking Performance Implications

Consider the performance implications of each method and choose the method that is best suited for your specific use case. Avoid deep comparison when possible and use memoization to cache the results of expensive function calls.

7.4. Neglecting Unit Tests

Write unit tests to ensure that your object comparison logic is working correctly. This will help you catch bugs early and prevent unexpected behavior in your application.

8. Conclusion

Comparing objects in Angular is a crucial task for ensuring data consistency, optimizing change detection, and improving the overall performance of your application. By understanding the different methods available and following best practices, you can effectively compare objects and avoid common pitfalls.

Remember to choose the right method for the job, handle circular references, write unit tests, and document your code. Stay updated with Angular best practices to ensure that you are using the most efficient and effective methods for comparing objects.

If you’re looking for more in-depth comparisons and resources to help you make informed decisions, visit COMPARE.EDU.VN today. Our team is dedicated to providing you with the tools and knowledge you need to succeed.

Need help making a comparison decision? Visit COMPARE.EDU.VN for detailed comparisons and expert insights. Our resources are designed to help you evaluate your options and make the best choice for your needs. Check out our detailed guides and reviews at COMPARE.EDU.VN today.

Contact us at 333 Comparison Plaza, Choice City, CA 90210, United States. Reach out via Whatsapp at +1 (626) 555-9090 or visit our website at compare.edu.vn for more information.

9. FAQ: Comparing Objects in Angular

Q1: Why is it important to compare objects in Angular?

Comparing objects is crucial for data binding, state management, change detection, and testing in Angular applications. It ensures that changes are correctly reflected in the UI and that the application behaves as expected.

Q2: What is the difference between referential equality and deep equality?

Referential equality checks if two variables point to the same object in memory, while deep equality checks if two objects have the same properties and values, even if they are stored in different memory locations.

Q3: When should I use manual comparison for comparing objects?

Manual comparison is best suited for scenarios where you need to compare objects with specific data types or custom logic, you want to avoid dependencies on external libraries, and the objects being compared are relatively small.

Q4: What are the limitations of using JSON.stringify() for object comparison?

The limitations of JSON.stringify() include the order of properties mattering, not handling circular references, treating different data types differently, and potentially being slow for large objects.

Q5: What are the advantages of using Lodash’s isEqual() for object comparison?

Lodash’s isEqual() is comprehensive, easy to use, optimized for performance, and reliable. It handles nested properties, circular references, and different data types.

Q6: When is the deep-equal library a good choice for object comparison?

The deep-equal library is a good choice when you need a lightweight solution, want to avoid adding a large dependency like Lodash, and need to customize the comparison process.

Q7: How can Angular’s KeyValuePipe be used for object comparison?

KeyValuePipe can be used for iterating over objects in templates, allowing you to dynamically display, filter, and order object properties. However, it is primarily designed for displaying object properties, not for comparing objects.

Q8: What are some performance considerations when comparing objects in Angular?

Performance considerations include the computational expense of deep comparison, especially for large objects. Optimizations include using the right method, avoiding deep comparison when possible, and using memoization.

Q9: How can I reduce unnecessary object comparisons in Angular?

You can reduce unnecessary comparisons by using immutable data, implementing a custom trackBy function, and using the OnPush change detection strategy.

Q10: What are some common pitfalls to avoid when comparing objects in Angular?

Common pitfalls include failing to handle null and undefined values, ignoring the order of properties when using JSON.stringify(), overlooking performance implications, and neglecting unit tests.

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *