export function providesRouteFactoryMap<T>(
    routeFactories: Iterable<RouteFactory<T>>): RouteFactoryMap<T> {
  return ImmutableMap.of(
      ImmutableSet.of([...routeFactories])
          .mapItem((factory: RouteFactory<T>) => {
            return [factory.getType(), factory] as [T, RouteFactory<T>];
          }));
}

 /**
  * @param files The bundle of files to add.
  * @return Object containing the bundle ID and a function to delete the bundle.
  */
 addBundle(files: File[]): {deleteFn: () => void, id: string} {
   const id = this.idGenerator_.generate([...ImmutableMap.of(this.bundles_).keys()]);
   this.bundles_.set(id, files);
   return {
     deleteFn: function(this: FileService): void {
       this.bundles_.delete(id);
     }.bind(this),
     id: id,
   };
 }

  static create<T>(factoryMap: Iterable<[string, T]>): FakeRouteFactoryService<T> {
    const factories = ImmutableMap.of([...factoryMap])
        .map((type: T) => new FakeRouteFactory(type));
    const service = new FakeRouteFactoryService(factories.values());

    for (const [key] of factoryMap) {
      service[key] = () => factories.get(key);
    }

    return service;
  }

  it(`should return null if none of the route factory maps produces any routes`, () => {
    const path = 'path';
    const mockFactory = jasmine.createSpyObj('Factory', ['createFromPath']);
    mockFactory.createFromPath.and.returnValue(null);

    const map = ImmutableMap.of([
      [Mocks.object('view'), mockFactory],
    ]);

    assert(providesMatch(path, map)).to.beNull();
    assert(mockFactory.createFromPath).to.haveBeenCalledWith(path);
  });

 it('should return empty object', () => {
   assert(factory['getRelativeMatchParams_'](ImmutableMap.of<string, string>([]))).to.equal({});
 });