address comments

Author: mmalerba

src/cdk/testing/component-harness.ts

@@ -412,7 +412,7 @@ export class HarnessPredicate<T extends ComponentHarness> {
    * @param pattern The pattern the value is expected to match. If `pattern` is a string,
    *   `value` is expected to match exactly. If `pattern` is a regex, a partial match is
    *   allowed. If `pattern` is `null`, the value is expected to be `null`.
-   * @return A Promise that resolves to whether the value matches the pattern.
+   * @return Whether the value matches the pattern.
    */
   static async stringMatches(value: string | null | Promise<string | null>,
                              pattern: string | RegExp | null): Promise<boolean> {

src/material/list/testing/list-harness.ts

@@ -7,7 +7,6 @@
  */
 
 import {
-  BaseHarnessFilters,
   ComponentHarness,
   ComponentHarnessConstructor,
   HarnessPredicate
@@ -26,7 +25,8 @@ import {
   ListItemHarnessFilters,
   ListOptionHarnessFilters,
   NavListHarnessFilters,
-  NavListItemHarnessFilters, SelectionListHarnessFilters,
+  NavListItemHarnessFilters,
+  SelectionListHarnessFilters,
   SubheaderHarnessFilters
 } from './list-harness-filters';
 import {
@@ -48,13 +48,14 @@ export interface ListSection<I> {
 
 /**
  * Shared behavior among the harnesses for the various `MatList` flavors.
+ * @template T A constructor type for a list item harness type used by this list harness.
+ * @template C The list item harness type that `T` constructs.
+ * @template F The filter type used filter list item harness of type `C`.
  * @docs-private
  */
 export class MatListHarnessBase
     <
-      T extends (ComponentHarnessConstructor<C> & {
-        with: (options?: BaseHarnessFilters) => HarnessPredicate<C>
-      }),
+      T extends (ComponentHarnessConstructor<C> & {with: (options?: F) => HarnessPredicate<C>}),
       C extends ComponentHarness,
       F extends BaseListItemHarnessFilters
     > extends ComponentHarness {
@@ -72,14 +73,14 @@ export class MatListHarnessBase
   /**
    * Gets a list of `ListSection` representing the list items grouped by subheaders. If the list has
    * no subheaders it is represented as a single `ListSection` with an undefined `heading` property.
-   * @param filters Optional filters used to narrow which list item harnesses are included
+   * @param filters?? Optional filters used to narrow which list item harnesses are included
    * @return The list of items matching the given filters, grouped into sections by subheader.
    */
-  async getItemsBySubheader(filters?: F): Promise<ListSection<C>[]> {
+  async getItemsGroupedBySubheader(filters?: F): Promise<ListSection<C>[]> {
     const listSections = [];
     let currentSection: ListSection<C> = {items: []};
     const itemsAndSubheaders =
-        await this.getItemsSubheadersAndDividers({item: filters, divider: false});
+        await this.getItemsWithSubheadersAndDividers({item: filters, divider: false});
     for (const itemOrSubheader of itemsAndSubheaders) {
       if (itemOrSubheader instanceof MatSubheaderHarness) {
         if (currentSection.heading !== undefined || currentSection.items.length) {
@@ -103,11 +104,11 @@ export class MatListHarnessBase
    * @param filters Optional filters used to narrow which list item harnesses are included
    * @return The list of items matching the given filters, grouped into sub-lists by divider.
    */
-  async getItemsDivided(filters?: F): Promise<C[][]> {
+  async getItemsGroupedByDividers(filters?: F): Promise<C[][]> {
     const listSections = [];
     let currentSection = [];
     const itemsAndDividers =
-        await this.getItemsSubheadersAndDividers({item: filters, subheader: false});
+        await this.getItemsWithSubheadersAndDividers({item: filters, subheader: false});
     for (const itemOrDivider of itemsAndDividers) {
       if (itemOrDivider instanceof MatDividerHarness) {
         listSections.push(currentSection);
@@ -130,47 +131,47 @@ export class MatListHarnessBase
    * @return The list of harnesses representing the items, subheaders, and dividers matching the
    *     given filters.
    */
-  getItemsSubheadersAndDividers(filters: {
+  getItemsWithSubheadersAndDividers(filters: {
     item: false,
     subheader: false,
     divider: false
   }): Promise<[]>;
-  getItemsSubheadersAndDividers(filters: {
+  getItemsWithSubheadersAndDividers(filters: {
     item?: F | false,
     subheader: false,
     divider: false
   }): Promise<C[]>;
-  getItemsSubheadersAndDividers(filters: {
+  getItemsWithSubheadersAndDividers(filters: {
     item: false,
     subheader?: SubheaderHarnessFilters | false,
     divider: false
   }): Promise<MatSubheaderHarness[]>;
-  getItemsSubheadersAndDividers(filters: {
+  getItemsWithSubheadersAndDividers(filters: {
     item: false,
     subheader: false,
     divider?: DividerHarnessFilters | false
   }): Promise<MatDividerHarness[]>;
-  getItemsSubheadersAndDividers(filters: {
+  getItemsWithSubheadersAndDividers(filters: {
     item?: F | false,
     subheader?: SubheaderHarnessFilters | false,
     divider: false
   }): Promise<(C | MatSubheaderHarness)[]>;
-  getItemsSubheadersAndDividers(filters: {
+  getItemsWithSubheadersAndDividers(filters: {
     item?: F | false,
     subheader: false,
     divider?: false | DividerHarnessFilters
   }): Promise<(C | MatDividerHarness)[]>;
-  getItemsSubheadersAndDividers(filters: {
+  getItemsWithSubheadersAndDividers(filters: {
     item: false,
     subheader?: false | SubheaderHarnessFilters,
     divider?: false | DividerHarnessFilters
   }): Promise<(MatSubheaderHarness | MatDividerHarness)[]>;
-  getItemsSubheadersAndDividers(filters?: {
+  getItemsWithSubheadersAndDividers(filters?: {
     item?: F | false,
     subheader?: SubheaderHarnessFilters | false,
     divider?: DividerHarnessFilters | false
   }): Promise<(C | MatSubheaderHarness | MatDividerHarness)[]>;
-  async getItemsSubheadersAndDividers(filters: {
+  async getItemsWithSubheadersAndDividers(filters: {
     item?: F | false,
     subheader?: SubheaderHarnessFilters | false,
     divider?: DividerHarnessFilters | false
@@ -274,18 +275,18 @@ export class MatSelectionListHarness extends MatListHarnessBase<
    * Selects all items matching any of the given filters.
    * @param filters Filters that specify which items should be selected.
    */
-  async checkItems(...filters: ListOptionHarnessFilters[]): Promise<void> {
+  async selectItems(...filters: ListOptionHarnessFilters[]): Promise<void> {
     const items = await this._getItems(filters);
-    await Promise.all(items.map(item => item.check()));
+    await Promise.all(items.map(item => item.select()));
   }
 
   /**
    * Deselects all items matching any of the given filters.
    * @param filters Filters that specify which items should be deselected.
    */
-  async uncheckItems(...filters: ListItemHarnessFilters[]): Promise<void> {
+  async deselectItems(...filters: ListItemHarnessFilters[]): Promise<void> {
     const items = await this._getItems(filters);
-    await Promise.all(items.map(item => item.uncheck()));
+    await Promise.all(items.map(item => item.deselect()));
   }
 
   /** Gets all items matching the given list of filters. */

src/material/list/testing/list-item-harness.ts

@@ -25,9 +25,17 @@ import {
   SubheaderHarnessFilters
 } from './list-harness-filters';
 
-function getListItemPredicate
-    <H extends MatListItemHarnessBase, F extends BaseListItemHarnessFilters>
-    (harnessType: ComponentHarnessConstructor<H>, options: F): HarnessPredicate<H> {
+/**
+ * Gets a `HarnessPredicate` that applies the given `BaseListItemHarnessFilters` to the given
+ * list item harness.
+ * @template H The type of list item harness to create a predicate for.
+ * @param harnessType A constructor for a list item harness.
+ * @param options An instance of `BaseListItemHarnessFilters` to apply.
+ * @return A `HarnessPredicate` for the given harness type with the given options applied.
+ */
+function getListItemPredicate<H extends MatListItemHarnessBase>(
+    harnessType: ComponentHarnessConstructor<H>,
+    options: BaseListItemHarnessFilters): HarnessPredicate<H> {
   return new HarnessPredicate(harnessType, options)
       .addOption('text', options.text,
           (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text));
@@ -230,7 +238,7 @@ export class MatListOptionHarness extends MatListItemHarnessBase {
    * Puts the list option in a checked state by toggling it if it is currently unchecked, or doing
    * nothing if it is already checked.
    */
-  async check() {
+  async select() {
     if (!await this.isSelected()) {
       return this.toggle();
     }
@@ -240,7 +248,7 @@ export class MatListOptionHarness extends MatListItemHarnessBase {
    * Puts the list option in an unchecked state by toggling it if it is currently checked, or doing
    * nothing if it is already unchecked.
    */
-  async uncheck() {
+  async deselect() {
     if (await this.isSelected()) {
       return this.toggle();
     }

src/material/list/testing/shared.spec.ts

@@ -78,7 +78,7 @@ function runBaseListFunctionalityTests<
     });
 
     it('should get items by subheader', async () => {
-      const sections = await simpleListHarness.getItemsBySubheader();
+      const sections = await simpleListHarness.getItemsGroupedBySubheader();
       expect(sections.length).toBe(3);
       expect(sections[0].heading).toBeUndefined();
       expect(await Promise.all(sections[0].items.map(i => i.getText()))).toEqual(['Item 1']);
@@ -90,28 +90,28 @@ function runBaseListFunctionalityTests<
     });
 
     it('should get items by subheader for an empty list', async () => {
-      const sections = await emptyListHarness.getItemsBySubheader();
+      const sections = await emptyListHarness.getItemsGroupedBySubheader();
       expect(sections.length).toBe(1);
       expect(sections[0].heading).toBeUndefined();
       expect(sections[0].items.length).toBe(0);
     });
 
     it('should get items grouped by divider', async () => {
-      const sections = await simpleListHarness.getItemsDivided();
+      const sections = await simpleListHarness.getItemsGroupedByDividers();
       expect(sections.length).toBe(3);
       expect(await Promise.all(sections[0].map(i => i.getText()))).toEqual(['Item 1']);
       expect(await Promise.all(sections[1].map(i => i.getText()))).toEqual(['Item 2', 'Item 3']);
       expect(sections[2].length).toBe(0);
     });
 
     it('should get items grouped by divider for an empty list', async () => {
-      const sections = await emptyListHarness.getItemsDivided();
+      const sections = await emptyListHarness.getItemsGroupedByDividers();
       expect(sections.length).toBe(1);
       expect(sections[0].length).toBe(0);
     });
 
     it('should get all items, subheaders, and dividers', async () => {
-      const itemsSubheadersAndDividers = await simpleListHarness.getItemsSubheadersAndDividers();
+      const itemsSubheadersAndDividers = await simpleListHarness.getItemsWithSubheadersAndDividers();
       expect(itemsSubheadersAndDividers.length).toBe(7);
       expect(itemsSubheadersAndDividers[0] instanceof listItemHarnessBase).toBe(true);
       expect(await (itemsSubheadersAndDividers[0] as MatListItemHarnessBase).getText())
@@ -134,11 +134,11 @@ function runBaseListFunctionalityTests<
 
     it('should get all items, subheaders, and dividers excluding some harness types', async () => {
       const items =
-          await simpleListHarness.getItemsSubheadersAndDividers({subheader: false, divider: false});
+          await simpleListHarness.getItemsWithSubheadersAndDividers({subheader: false, divider: false});
       const subheaders =
-          await simpleListHarness.getItemsSubheadersAndDividers({item: false, divider: false});
+          await simpleListHarness.getItemsWithSubheadersAndDividers({item: false, divider: false});
       const dividers =
-          await simpleListHarness.getItemsSubheadersAndDividers({item: false, subheader: false});
+          await simpleListHarness.getItemsWithSubheadersAndDividers({item: false, subheader: false});
       expect(await Promise.all(items.map(i => i.getText())))
           .toEqual(['Item 1', 'Item 2', 'Item 3']);
       expect(await Promise.all(subheaders.map(s => s.getText())))
@@ -148,7 +148,7 @@ function runBaseListFunctionalityTests<
     });
 
     it('should get all items, subheaders, and dividers with filters', async () => {
-      const itemsSubheadersAndDividers = await simpleListHarness.getItemsSubheadersAndDividers({
+      const itemsSubheadersAndDividers = await simpleListHarness.getItemsWithSubheadersAndDividers({
         item: {text: /1/},
         subheader: {text: /2/}
       });
@@ -328,22 +328,22 @@ export function runHarnessTests(
       it('should get all selected options', async () => {
         expect((await harness.getItems({selected: true})).length).toBe(0);
         const items = await harness.getItems();
-        await Promise.all(items.map(item => item.check()));
+        await Promise.all(items.map(item => item.select()));
         expect((await harness.getItems({selected: true})).length).toBe(3);
       });
 
       it('should check multiple options', async () => {
         expect((await harness.getItems({selected: true})).length).toBe(0);
-        await harness.checkItems({text: /1/}, {text: /3/});
+        await harness.selectItems({text: /1/}, {text: /3/});
         const selected = await harness.getItems({selected: true});
         expect(await Promise.all(selected.map(item => item.getText())))
             .toEqual(['Item 1', 'Item 3']);
       });
 
       it('should uncheck multiple options', async () => {
-        await harness.checkItems();
+        await harness.selectItems();
         expect((await harness.getItems({selected: true})).length).toBe(3);
-        await harness.uncheckItems({text: /1/}, {text: /3/});
+        await harness.deselectItems({text: /1/}, {text: /3/});
         const selected = await harness.getItems({selected: true});
         expect(await Promise.all(selected.map(item => item.getText()))).toEqual(['Item 2']);
       });
@@ -369,20 +369,20 @@ export function runHarnessTests(
         const items = await harness.getItems();
         expect(items.length).toBe(3);
         expect(await items[0].isSelected()).toBe(false);
-        await items[0].check();
+        await items[0].select();
         expect(await items[0].isSelected()).toBe(true);
-        await items[0].check();
+        await items[0].select();
         expect(await items[0].isSelected()).toBe(true);
       });
 
       it('should uncheck single option', async () => {
         const items = await harness.getItems();
         expect(items.length).toBe(3);
-        await items[0].check();
+        await items[0].select();
         expect(await items[0].isSelected()).toBe(true);
-        await items[0].uncheck();
+        await items[0].deselect();
         expect(await items[0].isSelected()).toBe(false);
-        await items[0].uncheck();
+        await items[0].deselect();
         expect(await items[0].isSelected()).toBe(false);
       });